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

#ifndef TRACE_NBD_GENERATED_TRACERS_H
#define TRACE_NBD_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_NBD_SEND_OPTION_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_OPTION_REPLY_EVENT;
extern TraceEvent _TRACE_NBD_SERVER_ERROR_MSG_EVENT;
extern TraceEvent _TRACE_NBD_REPLY_ERR_IGNORED_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_LIST_EVENT;
extern TraceEvent _TRACE_NBD_OPT_INFO_GO_START_EVENT;
extern TraceEvent _TRACE_NBD_OPT_INFO_GO_SUCCESS_EVENT;
extern TraceEvent _TRACE_NBD_OPT_INFO_UNKNOWN_EVENT;
extern TraceEvent _TRACE_NBD_OPT_INFO_BLOCK_SIZE_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_QUERY_EXPORTS_START_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE_EVENT;
extern TraceEvent _TRACE_NBD_OPT_META_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_OPT_META_REPLY_EVENT;
extern TraceEvent _TRACE_NBD_START_NEGOTIATE_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_NEGOTIATE_NAME_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS_EVENT;
extern TraceEvent _TRACE_NBD_INIT_SET_SOCKET_EVENT;
extern TraceEvent _TRACE_NBD_INIT_SET_BLOCK_SIZE_EVENT;
extern TraceEvent _TRACE_NBD_INIT_SET_SIZE_EVENT;
extern TraceEvent _TRACE_NBD_INIT_TRAILING_BYTES_EVENT;
extern TraceEvent _TRACE_NBD_INIT_SET_READONLY_EVENT;
extern TraceEvent _TRACE_NBD_INIT_FINISH_EVENT;
extern TraceEvent _TRACE_NBD_CLIENT_LOOP_EVENT;
extern TraceEvent _TRACE_NBD_CLIENT_LOOP_RET_EVENT;
extern TraceEvent _TRACE_NBD_CLIENT_CLEAR_QUEUE_EVENT;
extern TraceEvent _TRACE_NBD_CLIENT_CLEAR_SOCKET_EVENT;
extern TraceEvent _TRACE_NBD_SEND_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_SIMPLE_REPLY_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_WRONG_HEADER_EVENT;
extern TraceEvent _TRACE_NBD_UNKNOWN_ERROR_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_SEND_REP_LEN_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_SEND_REP_ERR_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_SEND_REP_LIST_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_SEND_INFO_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_META_CONTEXT_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_META_QUERY_SKIP_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_META_QUERY_PARSE_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_META_QUERY_REPLY_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_BEGIN_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS_EVENT;
extern TraceEvent _TRACE_NBD_NEGOTIATE_SUCCESS_EVENT;
extern TraceEvent _TRACE_NBD_RECEIVE_REQUEST_EVENT;
extern TraceEvent _TRACE_NBD_BLK_AIO_ATTACHED_EVENT;
extern TraceEvent _TRACE_NBD_BLK_AIO_DETACH_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_SIMPLE_REPLY_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_CHUNK_DONE_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_CHUNK_READ_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_CHUNK_READ_HOLE_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_EXTENTS_EVENT;
extern TraceEvent _TRACE_NBD_CO_SEND_CHUNK_ERROR_EVENT;
extern TraceEvent _TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE_EVENT;
extern TraceEvent _TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE_EVENT;
extern TraceEvent _TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED_EVENT;
extern TraceEvent _TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE_EVENT;
extern TraceEvent _TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE_EVENT;
extern TraceEvent _TRACE_NBD_TRIP_EVENT;
extern TraceEvent _TRACE_NBD_HANDSHAKE_TIMER_CB_EVENT;
extern TraceEvent _TRACE_NBD_CONNECT_THREAD_SLEEP_EVENT;
extern uint16_t _TRACE_NBD_SEND_OPTION_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_OPTION_REPLY_DSTATE;
extern uint16_t _TRACE_NBD_SERVER_ERROR_MSG_DSTATE;
extern uint16_t _TRACE_NBD_REPLY_ERR_IGNORED_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_LIST_DSTATE;
extern uint16_t _TRACE_NBD_OPT_INFO_GO_START_DSTATE;
extern uint16_t _TRACE_NBD_OPT_INFO_GO_SUCCESS_DSTATE;
extern uint16_t _TRACE_NBD_OPT_INFO_UNKNOWN_DSTATE;
extern uint16_t _TRACE_NBD_OPT_INFO_BLOCK_SIZE_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_QUERY_EXPORTS_START_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE_DSTATE;
extern uint16_t _TRACE_NBD_OPT_META_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_OPT_META_REPLY_DSTATE;
extern uint16_t _TRACE_NBD_START_NEGOTIATE_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_NEGOTIATE_NAME_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS_DSTATE;
extern uint16_t _TRACE_NBD_INIT_SET_SOCKET_DSTATE;
extern uint16_t _TRACE_NBD_INIT_SET_BLOCK_SIZE_DSTATE;
extern uint16_t _TRACE_NBD_INIT_SET_SIZE_DSTATE;
extern uint16_t _TRACE_NBD_INIT_TRAILING_BYTES_DSTATE;
extern uint16_t _TRACE_NBD_INIT_SET_READONLY_DSTATE;
extern uint16_t _TRACE_NBD_INIT_FINISH_DSTATE;
extern uint16_t _TRACE_NBD_CLIENT_LOOP_DSTATE;
extern uint16_t _TRACE_NBD_CLIENT_LOOP_RET_DSTATE;
extern uint16_t _TRACE_NBD_CLIENT_CLEAR_QUEUE_DSTATE;
extern uint16_t _TRACE_NBD_CLIENT_CLEAR_SOCKET_DSTATE;
extern uint16_t _TRACE_NBD_SEND_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_SIMPLE_REPLY_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_WRONG_HEADER_DSTATE;
extern uint16_t _TRACE_NBD_UNKNOWN_ERROR_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_SEND_REP_LEN_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_SEND_REP_ERR_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_SEND_REP_LIST_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_SEND_INFO_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_META_CONTEXT_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_META_QUERY_SKIP_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_META_QUERY_PARSE_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_META_QUERY_REPLY_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_BEGIN_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS_DSTATE;
extern uint16_t _TRACE_NBD_NEGOTIATE_SUCCESS_DSTATE;
extern uint16_t _TRACE_NBD_RECEIVE_REQUEST_DSTATE;
extern uint16_t _TRACE_NBD_BLK_AIO_ATTACHED_DSTATE;
extern uint16_t _TRACE_NBD_BLK_AIO_DETACH_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_SIMPLE_REPLY_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_CHUNK_DONE_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_CHUNK_READ_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_CHUNK_READ_HOLE_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_EXTENTS_DSTATE;
extern uint16_t _TRACE_NBD_CO_SEND_CHUNK_ERROR_DSTATE;
extern uint16_t _TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE_DSTATE;
extern uint16_t _TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE_DSTATE;
extern uint16_t _TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED_DSTATE;
extern uint16_t _TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE_DSTATE;
extern uint16_t _TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE_DSTATE;
extern uint16_t _TRACE_NBD_TRIP_DSTATE;
extern uint16_t _TRACE_NBD_HANDSHAKE_TIMER_CB_DSTATE;
extern uint16_t _TRACE_NBD_CONNECT_THREAD_SLEEP_DSTATE;
#define TRACE_NBD_SEND_OPTION_REQUEST_ENABLED 1
#define TRACE_NBD_RECEIVE_OPTION_REPLY_ENABLED 1
#define TRACE_NBD_SERVER_ERROR_MSG_ENABLED 1
#define TRACE_NBD_REPLY_ERR_IGNORED_ENABLED 1
#define TRACE_NBD_RECEIVE_LIST_ENABLED 1
#define TRACE_NBD_OPT_INFO_GO_START_ENABLED 1
#define TRACE_NBD_OPT_INFO_GO_SUCCESS_ENABLED 1
#define TRACE_NBD_OPT_INFO_UNKNOWN_ENABLED 1
#define TRACE_NBD_OPT_INFO_BLOCK_SIZE_ENABLED 1
#define TRACE_NBD_RECEIVE_QUERY_EXPORTS_START_ENABLED 1
#define TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS_ENABLED 1
#define TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT_ENABLED 1
#define TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE_ENABLED 1
#define TRACE_NBD_OPT_META_REQUEST_ENABLED 1
#define TRACE_NBD_OPT_META_REPLY_ENABLED 1
#define TRACE_NBD_START_NEGOTIATE_ENABLED 1
#define TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC_ENABLED 1
#define TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS_ENABLED 1
#define TRACE_NBD_RECEIVE_NEGOTIATE_NAME_ENABLED 1
#define TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS_ENABLED 1
#define TRACE_NBD_INIT_SET_SOCKET_ENABLED 1
#define TRACE_NBD_INIT_SET_BLOCK_SIZE_ENABLED 1
#define TRACE_NBD_INIT_SET_SIZE_ENABLED 1
#define TRACE_NBD_INIT_TRAILING_BYTES_ENABLED 1
#define TRACE_NBD_INIT_SET_READONLY_ENABLED 1
#define TRACE_NBD_INIT_FINISH_ENABLED 1
#define TRACE_NBD_CLIENT_LOOP_ENABLED 1
#define TRACE_NBD_CLIENT_LOOP_RET_ENABLED 1
#define TRACE_NBD_CLIENT_CLEAR_QUEUE_ENABLED 1
#define TRACE_NBD_CLIENT_CLEAR_SOCKET_ENABLED 1
#define TRACE_NBD_SEND_REQUEST_ENABLED 1
#define TRACE_NBD_RECEIVE_SIMPLE_REPLY_ENABLED 1
#define TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER_ENABLED 1
#define TRACE_NBD_RECEIVE_WRONG_HEADER_ENABLED 1
#define TRACE_NBD_UNKNOWN_ERROR_ENABLED 1
#define TRACE_NBD_NEGOTIATE_SEND_REP_LEN_ENABLED 1
#define TRACE_NBD_NEGOTIATE_SEND_REP_ERR_ENABLED 1
#define TRACE_NBD_NEGOTIATE_SEND_REP_LIST_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST_ENABLED 1
#define TRACE_NBD_NEGOTIATE_SEND_INFO_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_ENABLED 1
#define TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE_ENABLED 1
#define TRACE_NBD_NEGOTIATE_META_CONTEXT_ENABLED 1
#define TRACE_NBD_NEGOTIATE_META_QUERY_SKIP_ENABLED 1
#define TRACE_NBD_NEGOTIATE_META_QUERY_PARSE_ENABLED 1
#define TRACE_NBD_NEGOTIATE_META_QUERY_REPLY_ENABLED 1
#define TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS_ENABLED 1
#define TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC_ENABLED 1
#define TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION_ENABLED 1
#define TRACE_NBD_NEGOTIATE_BEGIN_ENABLED 1
#define TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS_ENABLED 1
#define TRACE_NBD_NEGOTIATE_SUCCESS_ENABLED 1
#define TRACE_NBD_RECEIVE_REQUEST_ENABLED 1
#define TRACE_NBD_BLK_AIO_ATTACHED_ENABLED 1
#define TRACE_NBD_BLK_AIO_DETACH_ENABLED 1
#define TRACE_NBD_CO_SEND_SIMPLE_REPLY_ENABLED 1
#define TRACE_NBD_CO_SEND_CHUNK_DONE_ENABLED 1
#define TRACE_NBD_CO_SEND_CHUNK_READ_ENABLED 1
#define TRACE_NBD_CO_SEND_CHUNK_READ_HOLE_ENABLED 1
#define TRACE_NBD_CO_SEND_EXTENTS_ENABLED 1
#define TRACE_NBD_CO_SEND_CHUNK_ERROR_ENABLED 1
#define TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE_ENABLED 1
#define TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE_ENABLED 1
#define TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED_ENABLED 1
#define TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE_ENABLED 1
#define TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE_ENABLED 1
#define TRACE_NBD_TRIP_ENABLED 1
#define TRACE_NBD_HANDSHAKE_TIMER_CB_ENABLED 1
#define TRACE_NBD_CONNECT_THREAD_SLEEP_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_NBD_SEND_OPTION_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_SEND_OPTION_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_send_option_request(uint32_t opt, const char * name, uint32_t len)
{
    if (trace_event_get_state(TRACE_NBD_SEND_OPTION_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_send_option_request " "Sending option request %" PRIu32" (%s), len %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opt, name, len);
#line 247 "trace/trace-nbd.h"
        } else {
#line 4 "../git/nbd/trace-events"
            qemu_log("nbd_send_option_request " "Sending option request %" PRIu32" (%s), len %" PRIu32 "\n", opt, name, len);
#line 251 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_send_option_request(uint32_t opt, const char * name, uint32_t len)
{
    if (true) {
        _nocheck__trace_nbd_send_option_request(opt, name, len);
    }
}

#define TRACE_NBD_RECEIVE_OPTION_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_OPTION_REPLY) || \
    false)

static inline void _nocheck__trace_nbd_receive_option_reply(uint32_t option, const char * optname, uint32_t type, const char * typename, uint32_t length)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_OPTION_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_option_reply " "Received option reply %" PRIu32" (%s), type %" PRIu32" (%s), len %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , option, optname, type, typename, length);
#line 278 "trace/trace-nbd.h"
        } else {
#line 5 "../git/nbd/trace-events"
            qemu_log("nbd_receive_option_reply " "Received option reply %" PRIu32" (%s), type %" PRIu32" (%s), len %" PRIu32 "\n", option, optname, type, typename, length);
#line 282 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_option_reply(uint32_t option, const char * optname, uint32_t type, const char * typename, uint32_t length)
{
    if (true) {
        _nocheck__trace_nbd_receive_option_reply(option, optname, type, typename, length);
    }
}

#define TRACE_NBD_SERVER_ERROR_MSG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_SERVER_ERROR_MSG) || \
    false)

static inline void _nocheck__trace_nbd_server_error_msg(uint32_t err, const char * type, const char * msg)
{
    if (trace_event_get_state(TRACE_NBD_SERVER_ERROR_MSG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_server_error_msg " "server reported error 0x%" PRIx32 " (%s) with additional message: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , err, type, msg);
#line 309 "trace/trace-nbd.h"
        } else {
#line 6 "../git/nbd/trace-events"
            qemu_log("nbd_server_error_msg " "server reported error 0x%" PRIx32 " (%s) with additional message: %s" "\n", err, type, msg);
#line 313 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_server_error_msg(uint32_t err, const char * type, const char * msg)
{
    if (true) {
        _nocheck__trace_nbd_server_error_msg(err, type, msg);
    }
}

#define TRACE_NBD_REPLY_ERR_IGNORED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_REPLY_ERR_IGNORED) || \
    false)

static inline void _nocheck__trace_nbd_reply_err_ignored(uint32_t option, const char * name, uint32_t reply, const char * reply_name)
{
    if (trace_event_get_state(TRACE_NBD_REPLY_ERR_IGNORED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_reply_err_ignored " "server failed request %" PRIu32 " (%s) with error 0x%" PRIx32 " (%s), attempting fallback" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , option, name, reply, reply_name);
#line 340 "trace/trace-nbd.h"
        } else {
#line 7 "../git/nbd/trace-events"
            qemu_log("nbd_reply_err_ignored " "server failed request %" PRIu32 " (%s) with error 0x%" PRIx32 " (%s), attempting fallback" "\n", option, name, reply, reply_name);
#line 344 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_reply_err_ignored(uint32_t option, const char * name, uint32_t reply, const char * reply_name)
{
    if (true) {
        _nocheck__trace_nbd_reply_err_ignored(option, name, reply, reply_name);
    }
}

#define TRACE_NBD_RECEIVE_LIST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_LIST) || \
    false)

static inline void _nocheck__trace_nbd_receive_list(const char * name, const char * desc)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_LIST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_list " "export list includes '%s', description '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name, desc);
#line 371 "trace/trace-nbd.h"
        } else {
#line 8 "../git/nbd/trace-events"
            qemu_log("nbd_receive_list " "export list includes '%s', description '%s'" "\n", name, desc);
#line 375 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_list(const char * name, const char * desc)
{
    if (true) {
        _nocheck__trace_nbd_receive_list(name, desc);
    }
}

#define TRACE_NBD_OPT_INFO_GO_START_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_INFO_GO_START) || \
    false)

static inline void _nocheck__trace_nbd_opt_info_go_start(const char * opt, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_OPT_INFO_GO_START) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 9 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_info_go_start " "Attempting %s for export '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opt, name);
#line 402 "trace/trace-nbd.h"
        } else {
#line 9 "../git/nbd/trace-events"
            qemu_log("nbd_opt_info_go_start " "Attempting %s for export '%s'" "\n", opt, name);
#line 406 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_info_go_start(const char * opt, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_opt_info_go_start(opt, name);
    }
}

#define TRACE_NBD_OPT_INFO_GO_SUCCESS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_INFO_GO_SUCCESS) || \
    false)

static inline void _nocheck__trace_nbd_opt_info_go_success(const char * opt)
{
    if (trace_event_get_state(TRACE_NBD_OPT_INFO_GO_SUCCESS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 10 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_info_go_success " "Export is ready after %s request" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opt);
#line 433 "trace/trace-nbd.h"
        } else {
#line 10 "../git/nbd/trace-events"
            qemu_log("nbd_opt_info_go_success " "Export is ready after %s request" "\n", opt);
#line 437 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_info_go_success(const char * opt)
{
    if (true) {
        _nocheck__trace_nbd_opt_info_go_success(opt);
    }
}

#define TRACE_NBD_OPT_INFO_UNKNOWN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_INFO_UNKNOWN) || \
    false)

static inline void _nocheck__trace_nbd_opt_info_unknown(int info, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_OPT_INFO_UNKNOWN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_info_unknown " "Ignoring unknown info %d (%s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , info, name);
#line 464 "trace/trace-nbd.h"
        } else {
#line 11 "../git/nbd/trace-events"
            qemu_log("nbd_opt_info_unknown " "Ignoring unknown info %d (%s)" "\n", info, name);
#line 468 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_info_unknown(int info, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_opt_info_unknown(info, name);
    }
}

#define TRACE_NBD_OPT_INFO_BLOCK_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_INFO_BLOCK_SIZE) || \
    false)

static inline void _nocheck__trace_nbd_opt_info_block_size(uint32_t minimum, uint32_t preferred, uint32_t maximum)
{
    if (trace_event_get_state(TRACE_NBD_OPT_INFO_BLOCK_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_info_block_size " "Block sizes are 0x%" PRIx32 ", 0x%" PRIx32 ", 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , minimum, preferred, maximum);
#line 495 "trace/trace-nbd.h"
        } else {
#line 12 "../git/nbd/trace-events"
            qemu_log("nbd_opt_info_block_size " "Block sizes are 0x%" PRIx32 ", 0x%" PRIx32 ", 0x%" PRIx32 "\n", minimum, preferred, maximum);
#line 499 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_info_block_size(uint32_t minimum, uint32_t preferred, uint32_t maximum)
{
    if (true) {
        _nocheck__trace_nbd_opt_info_block_size(minimum, preferred, maximum);
    }
}

#define TRACE_NBD_RECEIVE_QUERY_EXPORTS_START_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_QUERY_EXPORTS_START) || \
    false)

static inline void _nocheck__trace_nbd_receive_query_exports_start(const char * wantname)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_QUERY_EXPORTS_START) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_query_exports_start " "Querying export list for '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , wantname);
#line 526 "trace/trace-nbd.h"
        } else {
#line 13 "../git/nbd/trace-events"
            qemu_log("nbd_receive_query_exports_start " "Querying export list for '%s'" "\n", wantname);
#line 530 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_query_exports_start(const char * wantname)
{
    if (true) {
        _nocheck__trace_nbd_receive_query_exports_start(wantname);
    }
}

#define TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS) || \
    false)

static inline void _nocheck__trace_nbd_receive_query_exports_success(const char * wantname)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_QUERY_EXPORTS_SUCCESS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_query_exports_success " "Found desired export name '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , wantname);
#line 557 "trace/trace-nbd.h"
        } else {
#line 14 "../git/nbd/trace-events"
            qemu_log("nbd_receive_query_exports_success " "Found desired export name '%s'" "\n", wantname);
#line 561 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_query_exports_success(const char * wantname)
{
    if (true) {
        _nocheck__trace_nbd_receive_query_exports_success(wantname);
    }
}

#define TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT) || \
    false)

static inline void _nocheck__trace_nbd_receive_starttls_new_client(void)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_STARTTLS_NEW_CLIENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 15 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_starttls_new_client " "Setting up TLS" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 588 "trace/trace-nbd.h"
        } else {
#line 15 "../git/nbd/trace-events"
            qemu_log("nbd_receive_starttls_new_client " "Setting up TLS" "\n");
#line 592 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_starttls_new_client(void)
{
    if (true) {
        _nocheck__trace_nbd_receive_starttls_new_client();
    }
}

#define TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE) || \
    false)

static inline void _nocheck__trace_nbd_receive_starttls_tls_handshake(void)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_STARTTLS_TLS_HANDSHAKE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 16 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_starttls_tls_handshake " "Starting TLS handshake" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 619 "trace/trace-nbd.h"
        } else {
#line 16 "../git/nbd/trace-events"
            qemu_log("nbd_receive_starttls_tls_handshake " "Starting TLS handshake" "\n");
#line 623 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_starttls_tls_handshake(void)
{
    if (true) {
        _nocheck__trace_nbd_receive_starttls_tls_handshake();
    }
}

#define TRACE_NBD_OPT_META_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_META_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_opt_meta_request(const char * optname, const char * context, const char * export)
{
    if (trace_event_get_state(TRACE_NBD_OPT_META_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 17 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_meta_request " "Requesting %s %s for export %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , optname, context, export);
#line 650 "trace/trace-nbd.h"
        } else {
#line 17 "../git/nbd/trace-events"
            qemu_log("nbd_opt_meta_request " "Requesting %s %s for export %s" "\n", optname, context, export);
#line 654 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_meta_request(const char * optname, const char * context, const char * export)
{
    if (true) {
        _nocheck__trace_nbd_opt_meta_request(optname, context, export);
    }
}

#define TRACE_NBD_OPT_META_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_OPT_META_REPLY) || \
    false)

static inline void _nocheck__trace_nbd_opt_meta_reply(const char * optname, const char * context, uint32_t id)
{
    if (trace_event_get_state(TRACE_NBD_OPT_META_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_opt_meta_reply " "Received %s mapping of %s to id %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , optname, context, id);
#line 681 "trace/trace-nbd.h"
        } else {
#line 18 "../git/nbd/trace-events"
            qemu_log("nbd_opt_meta_reply " "Received %s mapping of %s to id %" PRIu32 "\n", optname, context, id);
#line 685 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_opt_meta_reply(const char * optname, const char * context, uint32_t id)
{
    if (true) {
        _nocheck__trace_nbd_opt_meta_reply(optname, context, id);
    }
}

#define TRACE_NBD_START_NEGOTIATE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_START_NEGOTIATE) || \
    false)

static inline void _nocheck__trace_nbd_start_negotiate(void * tlscreds, const char * hostname)
{
    if (trace_event_get_state(TRACE_NBD_START_NEGOTIATE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_start_negotiate " "Receiving negotiation tlscreds=%p hostname=%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , tlscreds, hostname);
#line 712 "trace/trace-nbd.h"
        } else {
#line 19 "../git/nbd/trace-events"
            qemu_log("nbd_start_negotiate " "Receiving negotiation tlscreds=%p hostname=%s" "\n", tlscreds, hostname);
#line 716 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_start_negotiate(void * tlscreds, const char * hostname)
{
    if (true) {
        _nocheck__trace_nbd_start_negotiate(tlscreds, hostname);
    }
}

#define TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC) || \
    false)

static inline void _nocheck__trace_nbd_receive_negotiate_magic(uint64_t magic)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_NEGOTIATE_MAGIC) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_negotiate_magic " "Magic is 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , magic);
#line 743 "trace/trace-nbd.h"
        } else {
#line 20 "../git/nbd/trace-events"
            qemu_log("nbd_receive_negotiate_magic " "Magic is 0x%" PRIx64 "\n", magic);
#line 747 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_negotiate_magic(uint64_t magic)
{
    if (true) {
        _nocheck__trace_nbd_receive_negotiate_magic(magic);
    }
}

#define TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS) || \
    false)

static inline void _nocheck__trace_nbd_receive_negotiate_server_flags(uint32_t globalflags)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_NEGOTIATE_SERVER_FLAGS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_negotiate_server_flags " "Global flags are 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , globalflags);
#line 774 "trace/trace-nbd.h"
        } else {
#line 21 "../git/nbd/trace-events"
            qemu_log("nbd_receive_negotiate_server_flags " "Global flags are 0x%" PRIx32 "\n", globalflags);
#line 778 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_negotiate_server_flags(uint32_t globalflags)
{
    if (true) {
        _nocheck__trace_nbd_receive_negotiate_server_flags(globalflags);
    }
}

#define TRACE_NBD_RECEIVE_NEGOTIATE_NAME_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_NEGOTIATE_NAME) || \
    false)

static inline void _nocheck__trace_nbd_receive_negotiate_name(const char * name)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_NEGOTIATE_NAME) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_negotiate_name " "Requesting NBD export name '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name);
#line 805 "trace/trace-nbd.h"
        } else {
#line 22 "../git/nbd/trace-events"
            qemu_log("nbd_receive_negotiate_name " "Requesting NBD export name '%s'" "\n", name);
#line 809 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_negotiate_name(const char * name)
{
    if (true) {
        _nocheck__trace_nbd_receive_negotiate_name(name);
    }
}

#define TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS) || \
    false)

static inline void _nocheck__trace_nbd_receive_negotiate_size_flags(uint64_t size, uint16_t flags)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_NEGOTIATE_SIZE_FLAGS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 23 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_negotiate_size_flags " "Size is %" PRIu64 ", export flags 0x%" PRIx16 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, flags);
#line 836 "trace/trace-nbd.h"
        } else {
#line 23 "../git/nbd/trace-events"
            qemu_log("nbd_receive_negotiate_size_flags " "Size is %" PRIu64 ", export flags 0x%" PRIx16 "\n", size, flags);
#line 840 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_negotiate_size_flags(uint64_t size, uint16_t flags)
{
    if (true) {
        _nocheck__trace_nbd_receive_negotiate_size_flags(size, flags);
    }
}

#define TRACE_NBD_INIT_SET_SOCKET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_SET_SOCKET) || \
    false)

static inline void _nocheck__trace_nbd_init_set_socket(void)
{
    if (trace_event_get_state(TRACE_NBD_INIT_SET_SOCKET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 24 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_set_socket " "Setting NBD socket" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 867 "trace/trace-nbd.h"
        } else {
#line 24 "../git/nbd/trace-events"
            qemu_log("nbd_init_set_socket " "Setting NBD socket" "\n");
#line 871 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_set_socket(void)
{
    if (true) {
        _nocheck__trace_nbd_init_set_socket();
    }
}

#define TRACE_NBD_INIT_SET_BLOCK_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_SET_BLOCK_SIZE) || \
    false)

static inline void _nocheck__trace_nbd_init_set_block_size(unsigned long block_size)
{
    if (trace_event_get_state(TRACE_NBD_INIT_SET_BLOCK_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_set_block_size " "Setting block size to %lu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , block_size);
#line 898 "trace/trace-nbd.h"
        } else {
#line 25 "../git/nbd/trace-events"
            qemu_log("nbd_init_set_block_size " "Setting block size to %lu" "\n", block_size);
#line 902 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_set_block_size(unsigned long block_size)
{
    if (true) {
        _nocheck__trace_nbd_init_set_block_size(block_size);
    }
}

#define TRACE_NBD_INIT_SET_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_SET_SIZE) || \
    false)

static inline void _nocheck__trace_nbd_init_set_size(unsigned long sectors)
{
    if (trace_event_get_state(TRACE_NBD_INIT_SET_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_set_size " "Setting size to %lu block(s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , sectors);
#line 929 "trace/trace-nbd.h"
        } else {
#line 26 "../git/nbd/trace-events"
            qemu_log("nbd_init_set_size " "Setting size to %lu block(s)" "\n", sectors);
#line 933 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_set_size(unsigned long sectors)
{
    if (true) {
        _nocheck__trace_nbd_init_set_size(sectors);
    }
}

#define TRACE_NBD_INIT_TRAILING_BYTES_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_TRAILING_BYTES) || \
    false)

static inline void _nocheck__trace_nbd_init_trailing_bytes(int ignored_bytes)
{
    if (trace_event_get_state(TRACE_NBD_INIT_TRAILING_BYTES) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_trailing_bytes " "Ignoring trailing %d bytes of export" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , ignored_bytes);
#line 960 "trace/trace-nbd.h"
        } else {
#line 27 "../git/nbd/trace-events"
            qemu_log("nbd_init_trailing_bytes " "Ignoring trailing %d bytes of export" "\n", ignored_bytes);
#line 964 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_trailing_bytes(int ignored_bytes)
{
    if (true) {
        _nocheck__trace_nbd_init_trailing_bytes(ignored_bytes);
    }
}

#define TRACE_NBD_INIT_SET_READONLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_SET_READONLY) || \
    false)

static inline void _nocheck__trace_nbd_init_set_readonly(void)
{
    if (trace_event_get_state(TRACE_NBD_INIT_SET_READONLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_set_readonly " "Setting readonly attribute" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 991 "trace/trace-nbd.h"
        } else {
#line 28 "../git/nbd/trace-events"
            qemu_log("nbd_init_set_readonly " "Setting readonly attribute" "\n");
#line 995 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_set_readonly(void)
{
    if (true) {
        _nocheck__trace_nbd_init_set_readonly();
    }
}

#define TRACE_NBD_INIT_FINISH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_INIT_FINISH) || \
    false)

static inline void _nocheck__trace_nbd_init_finish(void)
{
    if (trace_event_get_state(TRACE_NBD_INIT_FINISH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_init_finish " "Negotiation ended" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1022 "trace/trace-nbd.h"
        } else {
#line 29 "../git/nbd/trace-events"
            qemu_log("nbd_init_finish " "Negotiation ended" "\n");
#line 1026 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_init_finish(void)
{
    if (true) {
        _nocheck__trace_nbd_init_finish();
    }
}

#define TRACE_NBD_CLIENT_LOOP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CLIENT_LOOP) || \
    false)

static inline void _nocheck__trace_nbd_client_loop(void)
{
    if (trace_event_get_state(TRACE_NBD_CLIENT_LOOP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_client_loop " "Doing NBD loop" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1053 "trace/trace-nbd.h"
        } else {
#line 30 "../git/nbd/trace-events"
            qemu_log("nbd_client_loop " "Doing NBD loop" "\n");
#line 1057 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_client_loop(void)
{
    if (true) {
        _nocheck__trace_nbd_client_loop();
    }
}

#define TRACE_NBD_CLIENT_LOOP_RET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CLIENT_LOOP_RET) || \
    false)

static inline void _nocheck__trace_nbd_client_loop_ret(int ret, const char * error)
{
    if (trace_event_get_state(TRACE_NBD_CLIENT_LOOP_RET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 31 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_client_loop_ret " "NBD loop returned %d: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , ret, error);
#line 1084 "trace/trace-nbd.h"
        } else {
#line 31 "../git/nbd/trace-events"
            qemu_log("nbd_client_loop_ret " "NBD loop returned %d: %s" "\n", ret, error);
#line 1088 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_client_loop_ret(int ret, const char * error)
{
    if (true) {
        _nocheck__trace_nbd_client_loop_ret(ret, error);
    }
}

#define TRACE_NBD_CLIENT_CLEAR_QUEUE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CLIENT_CLEAR_QUEUE) || \
    false)

static inline void _nocheck__trace_nbd_client_clear_queue(void)
{
    if (trace_event_get_state(TRACE_NBD_CLIENT_CLEAR_QUEUE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_client_clear_queue " "Clearing NBD queue" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1115 "trace/trace-nbd.h"
        } else {
#line 32 "../git/nbd/trace-events"
            qemu_log("nbd_client_clear_queue " "Clearing NBD queue" "\n");
#line 1119 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_client_clear_queue(void)
{
    if (true) {
        _nocheck__trace_nbd_client_clear_queue();
    }
}

#define TRACE_NBD_CLIENT_CLEAR_SOCKET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CLIENT_CLEAR_SOCKET) || \
    false)

static inline void _nocheck__trace_nbd_client_clear_socket(void)
{
    if (trace_event_get_state(TRACE_NBD_CLIENT_CLEAR_SOCKET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_client_clear_socket " "Clearing NBD socket" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1146 "trace/trace-nbd.h"
        } else {
#line 33 "../git/nbd/trace-events"
            qemu_log("nbd_client_clear_socket " "Clearing NBD socket" "\n");
#line 1150 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_client_clear_socket(void)
{
    if (true) {
        _nocheck__trace_nbd_client_clear_socket();
    }
}

#define TRACE_NBD_SEND_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_SEND_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_send_request(uint64_t from, uint64_t len, uint64_t cookie, uint16_t flags, uint16_t type, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_SEND_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_send_request " "Sending request to server: { .from = %" PRIu64", .len = %" PRIu64 ", .cookie = %" PRIu64 ", .flags = 0x%" PRIx16 ", .type = %" PRIu16 " (%s) }" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , from, len, cookie, flags, type, name);
#line 1177 "trace/trace-nbd.h"
        } else {
#line 34 "../git/nbd/trace-events"
            qemu_log("nbd_send_request " "Sending request to server: { .from = %" PRIu64", .len = %" PRIu64 ", .cookie = %" PRIu64 ", .flags = 0x%" PRIx16 ", .type = %" PRIu16 " (%s) }" "\n", from, len, cookie, flags, type, name);
#line 1181 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_send_request(uint64_t from, uint64_t len, uint64_t cookie, uint16_t flags, uint16_t type, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_send_request(from, len, cookie, flags, type, name);
    }
}

#define TRACE_NBD_RECEIVE_SIMPLE_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_SIMPLE_REPLY) || \
    false)

static inline void _nocheck__trace_nbd_receive_simple_reply(int32_t error, const char * errname, uint64_t cookie)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_SIMPLE_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_simple_reply " "Got simple reply: { .error = %" PRId32 " (%s), cookie = %" PRIu64" }" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , error, errname, cookie);
#line 1208 "trace/trace-nbd.h"
        } else {
#line 35 "../git/nbd/trace-events"
            qemu_log("nbd_receive_simple_reply " "Got simple reply: { .error = %" PRId32 " (%s), cookie = %" PRIu64" }" "\n", error, errname, cookie);
#line 1212 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_simple_reply(int32_t error, const char * errname, uint64_t cookie)
{
    if (true) {
        _nocheck__trace_nbd_receive_simple_reply(error, errname, cookie);
    }
}

#define TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER) || \
    false)

static inline void _nocheck__trace_nbd_receive_reply_chunk_header(uint16_t flags, uint16_t type, const char * name, uint64_t cookie, uint32_t length)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_REPLY_CHUNK_HEADER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_reply_chunk_header " "Got reply chunk header: { flags = 0x%" PRIx16 ", type = %" PRIu16 " (%s), cookie = %" PRIu64 ", length = %" PRIu32 " }" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , flags, type, name, cookie, length);
#line 1239 "trace/trace-nbd.h"
        } else {
#line 36 "../git/nbd/trace-events"
            qemu_log("nbd_receive_reply_chunk_header " "Got reply chunk header: { flags = 0x%" PRIx16 ", type = %" PRIu16 " (%s), cookie = %" PRIu64 ", length = %" PRIu32 " }" "\n", flags, type, name, cookie, length);
#line 1243 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_reply_chunk_header(uint16_t flags, uint16_t type, const char * name, uint64_t cookie, uint32_t length)
{
    if (true) {
        _nocheck__trace_nbd_receive_reply_chunk_header(flags, type, name, cookie, length);
    }
}

#define TRACE_NBD_RECEIVE_WRONG_HEADER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_WRONG_HEADER) || \
    false)

static inline void _nocheck__trace_nbd_receive_wrong_header(uint32_t magic, const char * mode)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_WRONG_HEADER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_wrong_header " "Server sent unexpected magic 0x%" PRIx32 " for negotiated mode %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , magic, mode);
#line 1270 "trace/trace-nbd.h"
        } else {
#line 37 "../git/nbd/trace-events"
            qemu_log("nbd_receive_wrong_header " "Server sent unexpected magic 0x%" PRIx32 " for negotiated mode %s" "\n", magic, mode);
#line 1274 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_wrong_header(uint32_t magic, const char * mode)
{
    if (true) {
        _nocheck__trace_nbd_receive_wrong_header(magic, mode);
    }
}

#define TRACE_NBD_UNKNOWN_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_UNKNOWN_ERROR) || \
    false)

static inline void _nocheck__trace_nbd_unknown_error(int err)
{
    if (trace_event_get_state(TRACE_NBD_UNKNOWN_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 40 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_unknown_error " "Squashing unexpected error %d to EINVAL" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , err);
#line 1301 "trace/trace-nbd.h"
        } else {
#line 40 "../git/nbd/trace-events"
            qemu_log("nbd_unknown_error " "Squashing unexpected error %d to EINVAL" "\n", err);
#line 1305 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_unknown_error(int err)
{
    if (true) {
        _nocheck__trace_nbd_unknown_error(err);
    }
}

#define TRACE_NBD_NEGOTIATE_SEND_REP_LEN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_SEND_REP_LEN) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_send_rep_len(uint32_t opt, const char * optname, uint32_t type, const char * typename, uint32_t len)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_SEND_REP_LEN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 43 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_send_rep_len " "Reply opt=%" PRIu32 " (%s), type=%" PRIu32 " (%s), len=%" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opt, optname, type, typename, len);
#line 1332 "trace/trace-nbd.h"
        } else {
#line 43 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_send_rep_len " "Reply opt=%" PRIu32 " (%s), type=%" PRIu32 " (%s), len=%" PRIu32 "\n", opt, optname, type, typename, len);
#line 1336 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_send_rep_len(uint32_t opt, const char * optname, uint32_t type, const char * typename, uint32_t len)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_send_rep_len(opt, optname, type, typename, len);
    }
}

#define TRACE_NBD_NEGOTIATE_SEND_REP_ERR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_SEND_REP_ERR) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_send_rep_err(const char * msg)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_SEND_REP_ERR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 44 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_send_rep_err " "sending error message \"%s\"" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , msg);
#line 1363 "trace/trace-nbd.h"
        } else {
#line 44 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_send_rep_err " "sending error message \"%s\"" "\n", msg);
#line 1367 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_send_rep_err(const char * msg)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_send_rep_err(msg);
    }
}

#define TRACE_NBD_NEGOTIATE_SEND_REP_LIST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_SEND_REP_LIST) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_send_rep_list(const char * name, const char * desc)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_SEND_REP_LIST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 45 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_send_rep_list " "Advertising export name '%s' description '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name, desc);
#line 1394 "trace/trace-nbd.h"
        } else {
#line 45 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_send_rep_list " "Advertising export name '%s' description '%s'" "\n", name, desc);
#line 1398 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_send_rep_list(const char * name, const char * desc)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_send_rep_list(name, desc);
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_export_name(void)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 46 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_export_name " "Checking length" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1425 "trace/trace-nbd.h"
        } else {
#line 46 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_export_name " "Checking length" "\n");
#line 1429 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_export_name(void)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_export_name();
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_export_name_request(const char * name)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_EXPORT_NAME_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 47 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_export_name_request " "Client requested export '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name);
#line 1456 "trace/trace-nbd.h"
        } else {
#line 47 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_export_name_request " "Client requested export '%s'" "\n", name);
#line 1460 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_export_name_request(const char * name)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_export_name_request(name);
    }
}

#define TRACE_NBD_NEGOTIATE_SEND_INFO_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_SEND_INFO) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_send_info(int info, const char * name, uint32_t length)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_SEND_INFO) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 48 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_send_info " "Sending NBD_REP_INFO type %d (%s) with remaining length %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , info, name, length);
#line 1487 "trace/trace-nbd.h"
        } else {
#line 48 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_send_info " "Sending NBD_REP_INFO type %d (%s) with remaining length %" PRIu32 "\n", info, name, length);
#line 1491 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_send_info(int info, const char * name, uint32_t length)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_send_info(info, name, length);
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_info_requests(int requests)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUESTS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 49 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_info_requests " "Client requested %d items of info" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , requests);
#line 1518 "trace/trace-nbd.h"
        } else {
#line 49 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_info_requests " "Client requested %d items of info" "\n", requests);
#line 1522 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_info_requests(int requests)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_info_requests(requests);
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_info_request(int request, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_INFO_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 50 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_info_request " "Client requested info %d (%s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , request, name);
#line 1549 "trace/trace-nbd.h"
        } else {
#line 50 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_info_request " "Client requested info %d (%s)" "\n", request, name);
#line 1553 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_info_request(int request, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_info_request(request, name);
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_info_block_size(uint32_t minimum, uint32_t preferred, uint32_t maximum)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_INFO_BLOCK_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 51 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_info_block_size " "advertising minimum 0x%" PRIx32 ", preferred 0x%" PRIx32 ", maximum 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , minimum, preferred, maximum);
#line 1580 "trace/trace-nbd.h"
        } else {
#line 51 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_info_block_size " "advertising minimum 0x%" PRIx32 ", preferred 0x%" PRIx32 ", maximum 0x%" PRIx32 "\n", minimum, preferred, maximum);
#line 1584 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_info_block_size(uint32_t minimum, uint32_t preferred, uint32_t maximum)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_info_block_size(minimum, preferred, maximum);
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_starttls(void)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 52 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_starttls " "Setting up TLS" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1611 "trace/trace-nbd.h"
        } else {
#line 52 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_starttls " "Setting up TLS" "\n");
#line 1615 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_starttls(void)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_starttls();
    }
}

#define TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_handle_starttls_handshake(void)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_HANDLE_STARTTLS_HANDSHAKE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 53 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_handle_starttls_handshake " "Starting TLS handshake" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1642 "trace/trace-nbd.h"
        } else {
#line 53 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_handle_starttls_handshake " "Starting TLS handshake" "\n");
#line 1646 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_handle_starttls_handshake(void)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_handle_starttls_handshake();
    }
}

#define TRACE_NBD_NEGOTIATE_META_CONTEXT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_META_CONTEXT) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_meta_context(const char * optname, const char * export, uint32_t queries)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_META_CONTEXT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 54 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_meta_context " "Client requested %s for export %s, with %" PRIu32 " queries" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , optname, export, queries);
#line 1673 "trace/trace-nbd.h"
        } else {
#line 54 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_meta_context " "Client requested %s for export %s, with %" PRIu32 " queries" "\n", optname, export, queries);
#line 1677 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_meta_context(const char * optname, const char * export, uint32_t queries)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_meta_context(optname, export, queries);
    }
}

#define TRACE_NBD_NEGOTIATE_META_QUERY_SKIP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_META_QUERY_SKIP) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_meta_query_skip(const char * reason)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_META_QUERY_SKIP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 55 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_meta_query_skip " "Skipping meta query: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reason);
#line 1704 "trace/trace-nbd.h"
        } else {
#line 55 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_meta_query_skip " "Skipping meta query: %s" "\n", reason);
#line 1708 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_meta_query_skip(const char * reason)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_meta_query_skip(reason);
    }
}

#define TRACE_NBD_NEGOTIATE_META_QUERY_PARSE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_META_QUERY_PARSE) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_meta_query_parse(const char * query)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_META_QUERY_PARSE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 56 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_meta_query_parse " "Parsed meta query '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , query);
#line 1735 "trace/trace-nbd.h"
        } else {
#line 56 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_meta_query_parse " "Parsed meta query '%s'" "\n", query);
#line 1739 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_meta_query_parse(const char * query)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_meta_query_parse(query);
    }
}

#define TRACE_NBD_NEGOTIATE_META_QUERY_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_META_QUERY_REPLY) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_meta_query_reply(const char * context, uint32_t id)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_META_QUERY_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 57 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_meta_query_reply " "Replying with meta context '%s' id %" PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , context, id);
#line 1766 "trace/trace-nbd.h"
        } else {
#line 57 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_meta_query_reply " "Replying with meta context '%s' id %" PRIu32 "\n", context, id);
#line 1770 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_meta_query_reply(const char * context, uint32_t id)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_meta_query_reply(context, id);
    }
}

#define TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_options_flags(uint32_t flags)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_OPTIONS_FLAGS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 58 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_options_flags " "Received client flags 0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , flags);
#line 1797 "trace/trace-nbd.h"
        } else {
#line 58 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_options_flags " "Received client flags 0x%" PRIx32 "\n", flags);
#line 1801 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_options_flags(uint32_t flags)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_options_flags(flags);
    }
}

#define TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_options_check_magic(uint64_t magic)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_MAGIC) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 59 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_options_check_magic " "Checking opts magic 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , magic);
#line 1828 "trace/trace-nbd.h"
        } else {
#line 59 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_options_check_magic " "Checking opts magic 0x%" PRIx64 "\n", magic);
#line 1832 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_options_check_magic(uint64_t magic)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_options_check_magic(magic);
    }
}

#define TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_options_check_option(uint32_t option, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_OPTIONS_CHECK_OPTION) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 60 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_options_check_option " "Checking option %" PRIu32 " (%s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , option, name);
#line 1859 "trace/trace-nbd.h"
        } else {
#line 60 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_options_check_option " "Checking option %" PRIu32 " (%s)" "\n", option, name);
#line 1863 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_options_check_option(uint32_t option, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_options_check_option(option, name);
    }
}

#define TRACE_NBD_NEGOTIATE_BEGIN_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_BEGIN) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_begin(void)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_BEGIN) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 61 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_begin " "Beginning negotiation" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1890 "trace/trace-nbd.h"
        } else {
#line 61 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_begin " "Beginning negotiation" "\n");
#line 1894 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_begin(void)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_begin();
    }
}

#define TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_new_style_size_flags(uint64_t size, unsigned flags)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_NEW_STYLE_SIZE_FLAGS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 62 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_new_style_size_flags " "advertising size %" PRIu64 " and flags 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, flags);
#line 1921 "trace/trace-nbd.h"
        } else {
#line 62 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_new_style_size_flags " "advertising size %" PRIu64 " and flags 0x%x" "\n", size, flags);
#line 1925 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_new_style_size_flags(uint64_t size, unsigned flags)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_new_style_size_flags(size, flags);
    }
}

#define TRACE_NBD_NEGOTIATE_SUCCESS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_NEGOTIATE_SUCCESS) || \
    false)

static inline void _nocheck__trace_nbd_negotiate_success(void)
{
    if (trace_event_get_state(TRACE_NBD_NEGOTIATE_SUCCESS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 63 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_negotiate_success " "Negotiation succeeded" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1952 "trace/trace-nbd.h"
        } else {
#line 63 "../git/nbd/trace-events"
            qemu_log("nbd_negotiate_success " "Negotiation succeeded" "\n");
#line 1956 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_negotiate_success(void)
{
    if (true) {
        _nocheck__trace_nbd_negotiate_success();
    }
}

#define TRACE_NBD_RECEIVE_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_RECEIVE_REQUEST) || \
    false)

static inline void _nocheck__trace_nbd_receive_request(uint32_t magic, uint16_t flags, uint16_t type, uint64_t from, uint64_t len)
{
    if (trace_event_get_state(TRACE_NBD_RECEIVE_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 64 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_receive_request " "Got request: { magic = 0x%" PRIx32 ", .flags = 0x%" PRIx16 ", .type = 0x%" PRIx16 ", from = %" PRIu64 ", len = %" PRIu64 " }" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , magic, flags, type, from, len);
#line 1983 "trace/trace-nbd.h"
        } else {
#line 64 "../git/nbd/trace-events"
            qemu_log("nbd_receive_request " "Got request: { magic = 0x%" PRIx32 ", .flags = 0x%" PRIx16 ", .type = 0x%" PRIx16 ", from = %" PRIu64 ", len = %" PRIu64 " }" "\n", magic, flags, type, from, len);
#line 1987 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_receive_request(uint32_t magic, uint16_t flags, uint16_t type, uint64_t from, uint64_t len)
{
    if (true) {
        _nocheck__trace_nbd_receive_request(magic, flags, type, from, len);
    }
}

#define TRACE_NBD_BLK_AIO_ATTACHED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_BLK_AIO_ATTACHED) || \
    false)

static inline void _nocheck__trace_nbd_blk_aio_attached(const char * name, void * ctx)
{
    if (trace_event_get_state(TRACE_NBD_BLK_AIO_ATTACHED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 65 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_blk_aio_attached " "Export %s: Attaching clients to AIO context %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name, ctx);
#line 2014 "trace/trace-nbd.h"
        } else {
#line 65 "../git/nbd/trace-events"
            qemu_log("nbd_blk_aio_attached " "Export %s: Attaching clients to AIO context %p" "\n", name, ctx);
#line 2018 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_blk_aio_attached(const char * name, void * ctx)
{
    if (true) {
        _nocheck__trace_nbd_blk_aio_attached(name, ctx);
    }
}

#define TRACE_NBD_BLK_AIO_DETACH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_BLK_AIO_DETACH) || \
    false)

static inline void _nocheck__trace_nbd_blk_aio_detach(const char * name, void * ctx)
{
    if (trace_event_get_state(TRACE_NBD_BLK_AIO_DETACH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 66 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_blk_aio_detach " "Export %s: Detaching clients from AIO context %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name, ctx);
#line 2045 "trace/trace-nbd.h"
        } else {
#line 66 "../git/nbd/trace-events"
            qemu_log("nbd_blk_aio_detach " "Export %s: Detaching clients from AIO context %p" "\n", name, ctx);
#line 2049 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_blk_aio_detach(const char * name, void * ctx)
{
    if (true) {
        _nocheck__trace_nbd_blk_aio_detach(name, ctx);
    }
}

#define TRACE_NBD_CO_SEND_SIMPLE_REPLY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_SIMPLE_REPLY) || \
    false)

static inline void _nocheck__trace_nbd_co_send_simple_reply(uint64_t cookie, uint32_t error, const char * errname, uint64_t len)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_SIMPLE_REPLY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 67 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_simple_reply " "Send simple reply: cookie = %" PRIu64 ", error = %" PRIu32 " (%s), len = %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, error, errname, len);
#line 2076 "trace/trace-nbd.h"
        } else {
#line 67 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_simple_reply " "Send simple reply: cookie = %" PRIu64 ", error = %" PRIu32 " (%s), len = %" PRIu64 "\n", cookie, error, errname, len);
#line 2080 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_simple_reply(uint64_t cookie, uint32_t error, const char * errname, uint64_t len)
{
    if (true) {
        _nocheck__trace_nbd_co_send_simple_reply(cookie, error, errname, len);
    }
}

#define TRACE_NBD_CO_SEND_CHUNK_DONE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_CHUNK_DONE) || \
    false)

static inline void _nocheck__trace_nbd_co_send_chunk_done(uint64_t cookie)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_CHUNK_DONE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 68 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_chunk_done " "Send structured reply done: cookie = %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie);
#line 2107 "trace/trace-nbd.h"
        } else {
#line 68 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_chunk_done " "Send structured reply done: cookie = %" PRIu64 "\n", cookie);
#line 2111 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_chunk_done(uint64_t cookie)
{
    if (true) {
        _nocheck__trace_nbd_co_send_chunk_done(cookie);
    }
}

#define TRACE_NBD_CO_SEND_CHUNK_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_CHUNK_READ) || \
    false)

static inline void _nocheck__trace_nbd_co_send_chunk_read(uint64_t cookie, uint64_t offset, void * data, uint64_t size)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_CHUNK_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 69 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_chunk_read " "Send structured read data reply: cookie = %" PRIu64 ", offset = %" PRIu64 ", data = %p, len = %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, offset, data, size);
#line 2138 "trace/trace-nbd.h"
        } else {
#line 69 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_chunk_read " "Send structured read data reply: cookie = %" PRIu64 ", offset = %" PRIu64 ", data = %p, len = %" PRIu64 "\n", cookie, offset, data, size);
#line 2142 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_chunk_read(uint64_t cookie, uint64_t offset, void * data, uint64_t size)
{
    if (true) {
        _nocheck__trace_nbd_co_send_chunk_read(cookie, offset, data, size);
    }
}

#define TRACE_NBD_CO_SEND_CHUNK_READ_HOLE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_CHUNK_READ_HOLE) || \
    false)

static inline void _nocheck__trace_nbd_co_send_chunk_read_hole(uint64_t cookie, uint64_t offset, uint64_t size)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_CHUNK_READ_HOLE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 70 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_chunk_read_hole " "Send structured read hole reply: cookie = %" PRIu64 ", offset = %" PRIu64 ", len = %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, offset, size);
#line 2169 "trace/trace-nbd.h"
        } else {
#line 70 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_chunk_read_hole " "Send structured read hole reply: cookie = %" PRIu64 ", offset = %" PRIu64 ", len = %" PRIu64 "\n", cookie, offset, size);
#line 2173 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_chunk_read_hole(uint64_t cookie, uint64_t offset, uint64_t size)
{
    if (true) {
        _nocheck__trace_nbd_co_send_chunk_read_hole(cookie, offset, size);
    }
}

#define TRACE_NBD_CO_SEND_EXTENTS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_EXTENTS) || \
    false)

static inline void _nocheck__trace_nbd_co_send_extents(uint64_t cookie, unsigned int extents, uint32_t id, uint64_t length, int last)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_EXTENTS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 71 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_extents " "Send block status reply: cookie = %" PRIu64 ", extents = %u, context = %d (extents cover %" PRIu64 " bytes, last chunk = %d)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, extents, id, length, last);
#line 2200 "trace/trace-nbd.h"
        } else {
#line 71 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_extents " "Send block status reply: cookie = %" PRIu64 ", extents = %u, context = %d (extents cover %" PRIu64 " bytes, last chunk = %d)" "\n", cookie, extents, id, length, last);
#line 2204 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_extents(uint64_t cookie, unsigned int extents, uint32_t id, uint64_t length, int last)
{
    if (true) {
        _nocheck__trace_nbd_co_send_extents(cookie, extents, id, length, last);
    }
}

#define TRACE_NBD_CO_SEND_CHUNK_ERROR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_SEND_CHUNK_ERROR) || \
    false)

static inline void _nocheck__trace_nbd_co_send_chunk_error(uint64_t cookie, int err, const char * errname, const char * msg)
{
    if (trace_event_get_state(TRACE_NBD_CO_SEND_CHUNK_ERROR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 72 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_send_chunk_error " "Send structured error reply: cookie = %" PRIu64 ", error = %d (%s), msg = '%s'" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, err, errname, msg);
#line 2231 "trace/trace-nbd.h"
        } else {
#line 72 "../git/nbd/trace-events"
            qemu_log("nbd_co_send_chunk_error " "Send structured error reply: cookie = %" PRIu64 ", error = %d (%s), msg = '%s'" "\n", cookie, err, errname, msg);
#line 2235 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_send_chunk_error(uint64_t cookie, int err, const char * errname, const char * msg)
{
    if (true) {
        _nocheck__trace_nbd_co_send_chunk_error(cookie, err, errname, msg);
    }
}

#define TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE) || \
    false)

static inline void _nocheck__trace_nbd_co_receive_block_status_payload_compliance(uint64_t from, uint64_t len)
{
    if (trace_event_get_state(TRACE_NBD_CO_RECEIVE_BLOCK_STATUS_PAYLOAD_COMPLIANCE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 73 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_receive_block_status_payload_compliance " "client sent unusable block status payload: from=0x%" PRIx64 ", len=0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , from, len);
#line 2262 "trace/trace-nbd.h"
        } else {
#line 73 "../git/nbd/trace-events"
            qemu_log("nbd_co_receive_block_status_payload_compliance " "client sent unusable block status payload: from=0x%" PRIx64 ", len=0x%" PRIx64 "\n", from, len);
#line 2266 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_receive_block_status_payload_compliance(uint64_t from, uint64_t len)
{
    if (true) {
        _nocheck__trace_nbd_co_receive_block_status_payload_compliance(from, len);
    }
}

#define TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE) || \
    false)

static inline void _nocheck__trace_nbd_co_receive_request_decode_type(uint64_t cookie, uint16_t type, const char * name)
{
    if (trace_event_get_state(TRACE_NBD_CO_RECEIVE_REQUEST_DECODE_TYPE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 74 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_receive_request_decode_type " "Decoding type: cookie = %" PRIu64 ", type = %" PRIu16 " (%s)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, type, name);
#line 2293 "trace/trace-nbd.h"
        } else {
#line 74 "../git/nbd/trace-events"
            qemu_log("nbd_co_receive_request_decode_type " "Decoding type: cookie = %" PRIu64 ", type = %" PRIu16 " (%s)" "\n", cookie, type, name);
#line 2297 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_receive_request_decode_type(uint64_t cookie, uint16_t type, const char * name)
{
    if (true) {
        _nocheck__trace_nbd_co_receive_request_decode_type(cookie, type, name);
    }
}

#define TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED) || \
    false)

static inline void _nocheck__trace_nbd_co_receive_request_payload_received(uint64_t cookie, uint64_t len)
{
    if (trace_event_get_state(TRACE_NBD_CO_RECEIVE_REQUEST_PAYLOAD_RECEIVED) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 75 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_receive_request_payload_received " "Payload received: cookie = %" PRIu64 ", len = %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cookie, len);
#line 2324 "trace/trace-nbd.h"
        } else {
#line 75 "../git/nbd/trace-events"
            qemu_log("nbd_co_receive_request_payload_received " "Payload received: cookie = %" PRIu64 ", len = %" PRIu64 "\n", cookie, len);
#line 2328 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_receive_request_payload_received(uint64_t cookie, uint64_t len)
{
    if (true) {
        _nocheck__trace_nbd_co_receive_request_payload_received(cookie, len);
    }
}

#define TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE) || \
    false)

static inline void _nocheck__trace_nbd_co_receive_ext_payload_compliance(uint64_t from, uint64_t len)
{
    if (trace_event_get_state(TRACE_NBD_CO_RECEIVE_EXT_PAYLOAD_COMPLIANCE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 76 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_receive_ext_payload_compliance " "client sent non-compliant write without payload flag: from=0x%" PRIx64 ", len=0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , from, len);
#line 2355 "trace/trace-nbd.h"
        } else {
#line 76 "../git/nbd/trace-events"
            qemu_log("nbd_co_receive_ext_payload_compliance " "client sent non-compliant write without payload flag: from=0x%" PRIx64 ", len=0x%" PRIx64 "\n", from, len);
#line 2359 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_receive_ext_payload_compliance(uint64_t from, uint64_t len)
{
    if (true) {
        _nocheck__trace_nbd_co_receive_ext_payload_compliance(from, len);
    }
}

#define TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE) || \
    false)

static inline void _nocheck__trace_nbd_co_receive_align_compliance(const char * op, uint64_t from, uint64_t len, uint32_t align)
{
    if (trace_event_get_state(TRACE_NBD_CO_RECEIVE_ALIGN_COMPLIANCE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 77 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_co_receive_align_compliance " "client sent non-compliant unaligned %s request: from=0x%" PRIx64 ", len=0x%" PRIx64 ", align=0x%" PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , op, from, len, align);
#line 2386 "trace/trace-nbd.h"
        } else {
#line 77 "../git/nbd/trace-events"
            qemu_log("nbd_co_receive_align_compliance " "client sent non-compliant unaligned %s request: from=0x%" PRIx64 ", len=0x%" PRIx64 ", align=0x%" PRIx32 "\n", op, from, len, align);
#line 2390 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_co_receive_align_compliance(const char * op, uint64_t from, uint64_t len, uint32_t align)
{
    if (true) {
        _nocheck__trace_nbd_co_receive_align_compliance(op, from, len, align);
    }
}

#define TRACE_NBD_TRIP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_TRIP) || \
    false)

static inline void _nocheck__trace_nbd_trip(void)
{
    if (trace_event_get_state(TRACE_NBD_TRIP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 78 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_trip " "Reading request" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 2417 "trace/trace-nbd.h"
        } else {
#line 78 "../git/nbd/trace-events"
            qemu_log("nbd_trip " "Reading request" "\n");
#line 2421 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_trip(void)
{
    if (true) {
        _nocheck__trace_nbd_trip();
    }
}

#define TRACE_NBD_HANDSHAKE_TIMER_CB_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_HANDSHAKE_TIMER_CB) || \
    false)

static inline void _nocheck__trace_nbd_handshake_timer_cb(void)
{
    if (trace_event_get_state(TRACE_NBD_HANDSHAKE_TIMER_CB) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 79 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_handshake_timer_cb " "client took too long to negotiate" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 2448 "trace/trace-nbd.h"
        } else {
#line 79 "../git/nbd/trace-events"
            qemu_log("nbd_handshake_timer_cb " "client took too long to negotiate" "\n");
#line 2452 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_handshake_timer_cb(void)
{
    if (true) {
        _nocheck__trace_nbd_handshake_timer_cb();
    }
}

#define TRACE_NBD_CONNECT_THREAD_SLEEP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_NBD_CONNECT_THREAD_SLEEP) || \
    false)

static inline void _nocheck__trace_nbd_connect_thread_sleep(uint64_t timeout)
{
    if (trace_event_get_state(TRACE_NBD_CONNECT_THREAD_SLEEP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 82 "../git/nbd/trace-events"
            qemu_log("%d@%zu.%06zu:nbd_connect_thread_sleep " "timeout %" PRIu64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , timeout);
#line 2479 "trace/trace-nbd.h"
        } else {
#line 82 "../git/nbd/trace-events"
            qemu_log("nbd_connect_thread_sleep " "timeout %" PRIu64 "\n", timeout);
#line 2483 "trace/trace-nbd.h"
        }
    }
}

static inline void trace_nbd_connect_thread_sleep(uint64_t timeout)
{
    if (true) {
        _nocheck__trace_nbd_connect_thread_sleep(timeout);
    }
}
#endif /* TRACE_NBD_GENERATED_TRACERS_H */
