arch/x86/kvm/trace.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
   3 #define _TRACE_KVM_H
   4
   5 #include <linux/tracepoint.h>
   6 #include <asm/vmx.h>
   7 #include <asm/svm.h>
   8 #include <asm/clocksource.h>
   9 #include <asm/pvclock-abi.h>
  10
  11 #undef TRACE_SYSTEM
  12 #define TRACE_SYSTEM kvm
  13
  14 /*
  15  * Tracepoint for guest mode entry.
  16  */
  17 TRACE_EVENT(kvm_entry,
  18         TP_PROTO(struct kvm_vcpu *vcpu),
  19         TP_ARGS(vcpu),
  20
  21         TP_STRUCT__entry(
  22                 __field(        unsigned int,   vcpu_id         )
  23                 __field(        unsigned long,  rip             )
  24         ),
  25
  26         TP_fast_assign(
  27                 __entry->vcpu_id        = vcpu->vcpu_id;
  28                 __entry->rip            = kvm_rip_read(vcpu);
  29         ),
  30
  31         TP_printk("vcpu %u, rip 0x%lx", __entry->vcpu_id, __entry->rip)
  32 );
  33
  34 /*
  35  * Tracepoint for hypercall.
  36  */
  37 TRACE_EVENT(kvm_hypercall,
  38         TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1,
  39                  unsigned long a2, unsigned long a3),
  40         TP_ARGS(nr, a0, a1, a2, a3),
  41
  42         TP_STRUCT__entry(
  43                 __field(        unsigned long,  nr              )
  44                 __field(        unsigned long,  a0              )
  45                 __field(        unsigned long,  a1              )
  46                 __field(        unsigned long,  a2              )
  47                 __field(        unsigned long,  a3              )
  48         ),
  49
  50         TP_fast_assign(
  51                 __entry->nr             = nr;
  52                 __entry->a0             = a0;
  53                 __entry->a1             = a1;
  54                 __entry->a2             = a2;
  55                 __entry->a3             = a3;
  56         ),
  57
  58         TP_printk("nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx",
  59                  __entry->nr, __entry->a0, __entry->a1,  __entry->a2,
  60                  __entry->a3)
  61 );
  62
  63 /*
  64  * Tracepoint for hypercall.
  65  */
  66 TRACE_EVENT(kvm_hv_hypercall,
  67         TP_PROTO(__u16 code, bool fast,  __u16 var_cnt, __u16 rep_cnt,
  68                  __u16 rep_idx, __u64 ingpa, __u64 outgpa),
  69         TP_ARGS(code, fast, var_cnt, rep_cnt, rep_idx, ingpa, outgpa),
  70
  71         TP_STRUCT__entry(
  72                 __field(        __u16,          rep_cnt         )
  73                 __field(        __u16,          rep_idx         )
  74                 __field(        __u64,          ingpa           )
  75                 __field(        __u64,          outgpa          )
  76                 __field(        __u16,          code            )
  77                 __field(        __u16,          var_cnt         )
  78                 __field(        bool,           fast            )
  79         ),
  80
  81         TP_fast_assign(
  82                 __entry->rep_cnt        = rep_cnt;
  83                 __entry->rep_idx        = rep_idx;
  84                 __entry->ingpa          = ingpa;
  85                 __entry->outgpa         = outgpa;
  86                 __entry->code           = code;
  87                 __entry->var_cnt        = var_cnt;
  88                 __entry->fast           = fast;
  89         ),
  90
  91         TP_printk("code 0x%x %s var_cnt 0x%x rep_cnt 0x%x idx 0x%x in 0x%llx out 0x%llx",
  92                   __entry->code, __entry->fast ? "fast" : "slow",
  93                   __entry->var_cnt, __entry->rep_cnt, __entry->rep_idx,
  94                   __entry->ingpa, __entry->outgpa)
  95 );
  96
  97 TRACE_EVENT(kvm_hv_hypercall_done,
  98         TP_PROTO(u64 result),
  99         TP_ARGS(result),
 100
 101         TP_STRUCT__entry(
 102                 __field(__u64, result)
 103         ),
 104
 105         TP_fast_assign(
 106                 __entry->result = result;
 107         ),
 108
 109         TP_printk("result 0x%llx", __entry->result)
 110 );
 111
 112 /*
 113  * Tracepoint for Xen hypercall.
 114  */
 115 TRACE_EVENT(kvm_xen_hypercall,
 116             TP_PROTO(u8 cpl, unsigned long nr,
 117                      unsigned long a0, unsigned long a1, unsigned long a2,
 118                      unsigned long a3, unsigned long a4, unsigned long a5),
 119             TP_ARGS(cpl, nr, a0, a1, a2, a3, a4, a5),
 120
 121         TP_STRUCT__entry(
 122                 __field(u8, cpl)
 123                 __field(unsigned long, nr)
 124                 __field(unsigned long, a0)
 125                 __field(unsigned long, a1)
 126                 __field(unsigned long, a2)
 127                 __field(unsigned long, a3)
 128                 __field(unsigned long, a4)
 129                 __field(unsigned long, a5)
 130         ),
 131
 132         TP_fast_assign(
 133                 __entry->cpl = cpl;
 134                 __entry->nr = nr;
 135                 __entry->a0 = a0;
 136                 __entry->a1 = a1;
 137                 __entry->a2 = a2;
 138                 __entry->a3 = a3;
 139                 __entry->a4 = a4;
 140                 __entry->a4 = a5;
 141         ),
 142
 143         TP_printk("cpl %d nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx a4 0x%lx a5 %lx",
 144                   __entry->cpl, __entry->nr,
 145                   __entry->a0, __entry->a1, __entry->a2,
 146                   __entry->a3, __entry->a4, __entry->a5)
 147 );
 148
 149
 150
 151 /*
 152  * Tracepoint for PIO.
 153  */
 154
 155 #define KVM_PIO_IN   0
 156 #define KVM_PIO_OUT  1
 157
 158 TRACE_EVENT(kvm_pio,
 159         TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
 160                  unsigned int count, const void *data),
 161         TP_ARGS(rw, port, size, count, data),
 162
 163         TP_STRUCT__entry(
 164                 __field(        unsigned int,   rw              )
 165                 __field(        unsigned int,   port            )
 166                 __field(        unsigned int,   size            )
 167                 __field(        unsigned int,   count           )
 168                 __field(        unsigned int,   val             )
 169         ),
 170
 171         TP_fast_assign(
 172                 __entry->rw             = rw;
 173                 __entry->port           = port;
 174                 __entry->size           = size;
 175                 __entry->count          = count;
 176                 if (size == 1)
 177                         __entry->val    = *(unsigned char *)data;
 178                 else if (size == 2)
 179                         __entry->val    = *(unsigned short *)data;
 180                 else
 181                         __entry->val    = *(unsigned int *)data;
 182         ),
 183
 184         TP_printk("pio_%s at 0x%x size %d count %d val 0x%x %s",
 185                   __entry->rw ? "write" : "read",
 186                   __entry->port, __entry->size, __entry->count, __entry->val,
 187                   __entry->count > 1 ? "(...)" : "")
 188 );
 189
 190 /*
 191  * Tracepoint for fast mmio.
 192  */
 193 TRACE_EVENT(kvm_fast_mmio,
 194         TP_PROTO(u64 gpa),
 195         TP_ARGS(gpa),
 196
 197         TP_STRUCT__entry(
 198                 __field(u64,    gpa)
 199         ),
 200
 201         TP_fast_assign(
 202                 __entry->gpa            = gpa;
 203         ),
 204
 205         TP_printk("fast mmio at gpa 0x%llx", __entry->gpa)
 206 );
 207
 208 /*
 209  * Tracepoint for cpuid.
 210  */
 211 TRACE_EVENT(kvm_cpuid,
 212         TP_PROTO(unsigned int function, unsigned int index, unsigned long rax,
 213                  unsigned long rbx, unsigned long rcx, unsigned long rdx,
 214                  bool found, bool used_max_basic),
 215         TP_ARGS(function, index, rax, rbx, rcx, rdx, found, used_max_basic),
 216
 217         TP_STRUCT__entry(
 218                 __field(        unsigned int,   function        )
 219                 __field(        unsigned int,   index           )
 220                 __field(        unsigned long,  rax             )
 221                 __field(        unsigned long,  rbx             )
 222                 __field(        unsigned long,  rcx             )
 223                 __field(        unsigned long,  rdx             )
 224                 __field(        bool,           found           )
 225                 __field(        bool,           used_max_basic  )
 226         ),
 227
 228         TP_fast_assign(
 229                 __entry->function       = function;
 230                 __entry->index          = index;
 231                 __entry->rax            = rax;
 232                 __entry->rbx            = rbx;
 233                 __entry->rcx            = rcx;
 234                 __entry->rdx            = rdx;
 235                 __entry->found          = found;
 236                 __entry->used_max_basic = used_max_basic;
 237         ),
 238
 239         TP_printk("func %x idx %x rax %lx rbx %lx rcx %lx rdx %lx, cpuid entry %s%s",
 240                   __entry->function, __entry->index, __entry->rax,
 241                   __entry->rbx, __entry->rcx, __entry->rdx,
 242                   __entry->found ? "found" : "not found",
 243                   __entry->used_max_basic ? ", used max basic" : "")
 244 );
 245
 246 #define AREG(x) { APIC_##x, "APIC_" #x }
 247
 248 #define kvm_trace_symbol_apic                                               \
 249         AREG(ID), AREG(LVR), AREG(TASKPRI), AREG(ARBPRI), AREG(PROCPRI),    \
 250         AREG(EOI), AREG(RRR), AREG(LDR), AREG(DFR), AREG(SPIV), AREG(ISR),  \
 251         AREG(TMR), AREG(IRR), AREG(ESR), AREG(ICR), AREG(ICR2), AREG(LVTT), \
 252         AREG(LVTTHMR), AREG(LVTPC), AREG(LVT0), AREG(LVT1), AREG(LVTERR),   \
 253         AREG(TMICT), AREG(TMCCT), AREG(TDCR), AREG(SELF_IPI), AREG(EFEAT),  \
 254         AREG(ECTRL)
 255 /*
 256  * Tracepoint for apic access.
 257  */
 258 TRACE_EVENT(kvm_apic,
 259         TP_PROTO(unsigned int rw, unsigned int reg, u64 val),
 260         TP_ARGS(rw, reg, val),
 261
 262         TP_STRUCT__entry(
 263                 __field(        unsigned int,   rw              )
 264                 __field(        unsigned int,   reg             )
 265                 __field(        u64,            val             )
 266         ),
 267
 268         TP_fast_assign(
 269                 __entry->rw             = rw;
 270                 __entry->reg            = reg;
 271                 __entry->val            = val;
 272         ),
 273
 274         TP_printk("apic_%s %s = 0x%llx",
 275                   __entry->rw ? "write" : "read",
 276                   __print_symbolic(__entry->reg, kvm_trace_symbol_apic),
 277                   __entry->val)
 278 );
 279
 280 #define trace_kvm_apic_read(reg, val)           trace_kvm_apic(0, reg, val)
 281 #define trace_kvm_apic_write(reg, val)          trace_kvm_apic(1, reg, val)
 282
 283 #define KVM_ISA_VMX   1
 284 #define KVM_ISA_SVM   2
 285
 286 #define kvm_print_exit_reason(exit_reason, isa)                         \
 287         (isa == KVM_ISA_VMX) ?                                          \
 288         __print_symbolic(exit_reason & 0xffff, VMX_EXIT_REASONS) :      \
 289         __print_symbolic(exit_reason, SVM_EXIT_REASONS),                \
 290         (isa == KVM_ISA_VMX && exit_reason & ~0xffff) ? " " : "",       \
 291         (isa == KVM_ISA_VMX) ?                                          \
 292         __print_flags(exit_reason & ~0xffff, " ", VMX_EXIT_REASON_FLAGS) : ""
 293
 294 #define TRACE_EVENT_KVM_EXIT(name)                                           \
 295 TRACE_EVENT(name,                                                            \
 296         TP_PROTO(struct kvm_vcpu *vcpu, u32 isa),                            \
 297         TP_ARGS(vcpu, isa),                                                  \
 298                                                                              \
 299         TP_STRUCT__entry(                                                    \
 300                 __field(        unsigned int,   exit_reason     )            \
 301                 __field(        unsigned long,  guest_rip       )            \
 302                 __field(        u32,            isa             )            \
 303                 __field(        u64,            info1           )            \
 304                 __field(        u64,            info2           )            \
 305                 __field(        u32,            intr_info       )            \
 306                 __field(        u32,            error_code      )            \
 307                 __field(        unsigned int,   vcpu_id         )            \
 308         ),                                                                   \
 309                                                                              \
 310         TP_fast_assign(                                                      \
 311                 __entry->guest_rip      = kvm_rip_read(vcpu);                \
 312                 __entry->isa            = isa;                               \
 313                 __entry->vcpu_id        = vcpu->vcpu_id;                     \
 314                 static_call(kvm_x86_get_exit_info)(vcpu,                     \
 315                                           &__entry->exit_reason,             \
 316                                           &__entry->info1,                   \
 317                                           &__entry->info2,                   \
 318                                           &__entry->intr_info,               \
 319                                           &__entry->error_code);             \
 320         ),                                                                   \
 321                                                                              \
 322         TP_printk("vcpu %u reason %s%s%s rip 0x%lx info1 0x%016llx "         \
 323                   "info2 0x%016llx intr_info 0x%08x error_code 0x%08x",      \
 324                   __entry->vcpu_id,                                          \
 325                   kvm_print_exit_reason(__entry->exit_reason, __entry->isa), \
 326                   __entry->guest_rip, __entry->info1, __entry->info2,        \
 327                   __entry->intr_info, __entry->error_code)                   \
 328 )
 329
 330 /*
 331  * Tracepoint for kvm guest exit:
 332  */
 333 TRACE_EVENT_KVM_EXIT(kvm_exit);
 334
 335 /*
 336  * Tracepoint for kvm interrupt injection:
 337  */
 338 TRACE_EVENT(kvm_inj_virq,
 339         TP_PROTO(unsigned int vector, bool soft, bool reinjected),
 340         TP_ARGS(vector, soft, reinjected),
 341
 342         TP_STRUCT__entry(
 343                 __field(        unsigned int,   vector          )
 344                 __field(        bool,           soft            )
 345                 __field(        bool,           reinjected      )
 346         ),
 347
 348         TP_fast_assign(
 349                 __entry->vector         = vector;
 350                 __entry->soft           = soft;
 351                 __entry->reinjected     = reinjected;
 352         ),
 353
 354         TP_printk("%s 0x%x%s",
 355                   __entry->soft ? "Soft/INTn" : "IRQ", __entry->vector,
 356                   __entry->reinjected ? " [reinjected]" : "")
 357 );
 358
 359 #define EXS(x) { x##_VECTOR, "#" #x }
 360
 361 #define kvm_trace_sym_exc                                               \
 362         EXS(DE), EXS(DB), EXS(BP), EXS(OF), EXS(BR), EXS(UD), EXS(NM),  \
 363         EXS(DF), EXS(TS), EXS(NP), EXS(SS), EXS(GP), EXS(PF),           \
 364         EXS(MF), EXS(AC), EXS(MC)
 365
 366 /*
 367  * Tracepoint for kvm interrupt injection:
 368  */
 369 TRACE_EVENT(kvm_inj_exception,
 370         TP_PROTO(unsigned exception, bool has_error, unsigned error_code,
 371                  bool reinjected),
 372         TP_ARGS(exception, has_error, error_code, reinjected),
 373
 374         TP_STRUCT__entry(
 375                 __field(        u8,     exception       )
 376                 __field(        u8,     has_error       )
 377                 __field(        u32,    error_code      )
 378                 __field(        bool,   reinjected      )
 379         ),
 380
 381         TP_fast_assign(
 382                 __entry->exception      = exception;
 383                 __entry->has_error      = has_error;
 384                 __entry->error_code     = error_code;
 385                 __entry->reinjected     = reinjected;
 386         ),
 387
 388         TP_printk("%s%s%s%s%s",
 389                   __print_symbolic(__entry->exception, kvm_trace_sym_exc),
 390                   !__entry->has_error ? "" : " (",
 391                   !__entry->has_error ? "" : __print_symbolic(__entry->error_code, { }),
 392                   !__entry->has_error ? "" : ")",
 393                   __entry->reinjected ? " [reinjected]" : "")
 394 );
 395
 396 /*
 397  * Tracepoint for page fault.
 398  */
 399 TRACE_EVENT(kvm_page_fault,
 400         TP_PROTO(struct kvm_vcpu *vcpu, u64 fault_address, u64 error_code),
 401         TP_ARGS(vcpu, fault_address, error_code),
 402
 403         TP_STRUCT__entry(
 404                 __field(        unsigned int,   vcpu_id         )
 405                 __field(        unsigned long,  guest_rip       )
 406                 __field(        u64,            fault_address   )
 407                 __field(        u64,            error_code      )
 408         ),
 409
 410         TP_fast_assign(
 411                 __entry->vcpu_id        = vcpu->vcpu_id;
 412                 __entry->guest_rip      = kvm_rip_read(vcpu);
 413                 __entry->fault_address  = fault_address;
 414                 __entry->error_code     = error_code;
 415         ),
 416
 417         TP_printk("vcpu %u rip 0x%lx address 0x%016llx error_code 0x%llx",
 418                   __entry->vcpu_id, __entry->guest_rip,
 419                   __entry->fault_address, __entry->error_code)
 420 );
 421
 422 /*
 423  * Tracepoint for guest MSR access.
 424  */
 425 TRACE_EVENT(kvm_msr,
 426         TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception),
 427         TP_ARGS(write, ecx, data, exception),
 428
 429         TP_STRUCT__entry(
 430                 __field(        unsigned,       write           )
 431                 __field(        u32,            ecx             )
 432                 __field(        u64,            data            )
 433                 __field(        u8,             exception       )
 434         ),
 435
 436         TP_fast_assign(
 437                 __entry->write          = write;
 438                 __entry->ecx            = ecx;
 439                 __entry->data           = data;
 440                 __entry->exception      = exception;
 441         ),
 442
 443         TP_printk("msr_%s %x = 0x%llx%s",
 444                   __entry->write ? "write" : "read",
 445                   __entry->ecx, __entry->data,
 446                   __entry->exception ? " (#GP)" : "")
 447 );
 448
 449 #define trace_kvm_msr_read(ecx, data)      trace_kvm_msr(0, ecx, data, false)
 450 #define trace_kvm_msr_write(ecx, data)     trace_kvm_msr(1, ecx, data, false)
 451 #define trace_kvm_msr_read_ex(ecx)         trace_kvm_msr(0, ecx, 0, true)
 452 #define trace_kvm_msr_write_ex(ecx, data)  trace_kvm_msr(1, ecx, data, true)
 453
 454 /*
 455  * Tracepoint for guest CR access.
 456  */
 457 TRACE_EVENT(kvm_cr,
 458         TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
 459         TP_ARGS(rw, cr, val),
 460
 461         TP_STRUCT__entry(
 462                 __field(        unsigned int,   rw              )
 463                 __field(        unsigned int,   cr              )
 464                 __field(        unsigned long,  val             )
 465         ),
 466
 467         TP_fast_assign(
 468                 __entry->rw             = rw;
 469                 __entry->cr             = cr;
 470                 __entry->val            = val;
 471         ),
 472
 473         TP_printk("cr_%s %x = 0x%lx",
 474                   __entry->rw ? "write" : "read",
 475                   __entry->cr, __entry->val)
 476 );
 477
 478 #define trace_kvm_cr_read(cr, val)              trace_kvm_cr(0, cr, val)
 479 #define trace_kvm_cr_write(cr, val)             trace_kvm_cr(1, cr, val)
 480
 481 TRACE_EVENT(kvm_pic_set_irq,
 482             TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
 483             TP_ARGS(chip, pin, elcr, imr, coalesced),
 484
 485         TP_STRUCT__entry(
 486                 __field(        __u8,           chip            )
 487                 __field(        __u8,           pin             )
 488                 __field(        __u8,           elcr            )
 489                 __field(        __u8,           imr             )
 490                 __field(        bool,           coalesced       )
 491         ),
 492
 493         TP_fast_assign(
 494                 __entry->chip           = chip;
 495                 __entry->pin            = pin;
 496                 __entry->elcr           = elcr;
 497                 __entry->imr            = imr;
 498                 __entry->coalesced      = coalesced;
 499         ),
 500
 501         TP_printk("chip %u pin %u (%s%s)%s",
 502                   __entry->chip, __entry->pin,
 503                   (__entry->elcr & (1 << __entry->pin)) ? "level":"edge",
 504                   (__entry->imr & (1 << __entry->pin)) ? "|masked":"",
 505                   __entry->coalesced ? " (coalesced)" : "")
 506 );
 507
 508 #define kvm_apic_dst_shorthand          \
 509         {0x0, "dst"},                   \
 510         {0x1, "self"},                  \
 511         {0x2, "all"},                   \
 512         {0x3, "all-but-self"}
 513
 514 TRACE_EVENT(kvm_apic_ipi,
 515             TP_PROTO(__u32 icr_low, __u32 dest_id),
 516             TP_ARGS(icr_low, dest_id),
 517
 518         TP_STRUCT__entry(
 519                 __field(        __u32,          icr_low         )
 520                 __field(        __u32,          dest_id         )
 521         ),
 522
 523         TP_fast_assign(
 524                 __entry->icr_low        = icr_low;
 525                 __entry->dest_id        = dest_id;
 526         ),
 527
 528         TP_printk("dst %x vec %u (%s|%s|%s|%s|%s)",
 529                   __entry->dest_id, (u8)__entry->icr_low,
 530                   __print_symbolic((__entry->icr_low >> 8 & 0x7),
 531                                    kvm_deliver_mode),
 532                   (__entry->icr_low & (1<<11)) ? "logical" : "physical",
 533                   (__entry->icr_low & (1<<14)) ? "assert" : "de-assert",
 534                   (__entry->icr_low & (1<<15)) ? "level" : "edge",
 535                   __print_symbolic((__entry->icr_low >> 18 & 0x3),
 536                                    kvm_apic_dst_shorthand))
 537 );
 538
 539 TRACE_EVENT(kvm_apic_accept_irq,
 540             TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec),
 541             TP_ARGS(apicid, dm, tm, vec),
 542
 543         TP_STRUCT__entry(
 544                 __field(        __u32,          apicid          )
 545                 __field(        __u16,          dm              )
 546                 __field(        __u16,          tm              )
 547                 __field(        __u8,           vec             )
 548         ),
 549
 550         TP_fast_assign(
 551                 __entry->apicid         = apicid;
 552                 __entry->dm             = dm;
 553                 __entry->tm             = tm;
 554                 __entry->vec            = vec;
 555         ),
 556
 557         TP_printk("apicid %x vec %u (%s|%s)",
 558                   __entry->apicid, __entry->vec,
 559                   __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
 560                   __entry->tm ? "level" : "edge")
 561 );
 562
 563 TRACE_EVENT(kvm_eoi,
 564             TP_PROTO(struct kvm_lapic *apic, int vector),
 565             TP_ARGS(apic, vector),
 566
 567         TP_STRUCT__entry(
 568                 __field(        __u32,          apicid          )
 569                 __field(        int,            vector          )
 570         ),
 571
 572         TP_fast_assign(
 573                 __entry->apicid         = apic->vcpu->vcpu_id;
 574                 __entry->vector         = vector;
 575         ),
 576
 577         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
 578 );
 579
 580 TRACE_EVENT(kvm_pv_eoi,
 581             TP_PROTO(struct kvm_lapic *apic, int vector),
 582             TP_ARGS(apic, vector),
 583
 584         TP_STRUCT__entry(
 585                 __field(        __u32,          apicid          )
 586                 __field(        int,            vector          )
 587         ),
 588
 589         TP_fast_assign(
 590                 __entry->apicid         = apic->vcpu->vcpu_id;
 591                 __entry->vector         = vector;
 592         ),
 593
 594         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
 595 );
 596
 597 /*
 598  * Tracepoint for nested VMRUN
 599  */
 600 TRACE_EVENT(kvm_nested_vmenter,
 601             TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl,
 602                      __u32 event_inj, bool tdp_enabled, __u64 guest_tdp_pgd,
 603                      __u64 guest_cr3, __u32 isa),
 604             TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, tdp_enabled,
 605                     guest_tdp_pgd, guest_cr3, isa),
 606
 607         TP_STRUCT__entry(
 608                 __field(        __u64,          rip             )
 609                 __field(        __u64,          vmcb            )
 610                 __field(        __u64,          nested_rip      )
 611                 __field(        __u32,          int_ctl         )
 612                 __field(        __u32,          event_inj       )
 613                 __field(        bool,           tdp_enabled     )
 614                 __field(        __u64,          guest_pgd       )
 615                 __field(        __u32,          isa             )
 616         ),
 617
 618         TP_fast_assign(
 619                 __entry->rip            = rip;
 620                 __entry->vmcb           = vmcb;
 621                 __entry->nested_rip     = nested_rip;
 622                 __entry->int_ctl        = int_ctl;
 623                 __entry->event_inj      = event_inj;
 624                 __entry->tdp_enabled    = tdp_enabled;
 625                 __entry->guest_pgd      = tdp_enabled ? guest_tdp_pgd : guest_cr3;
 626                 __entry->isa            = isa;
 627         ),
 628
 629         TP_printk("rip: 0x%016llx %s: 0x%016llx nested_rip: 0x%016llx "
 630                   "int_ctl: 0x%08x event_inj: 0x%08x nested_%s=%s %s: 0x%016llx",
 631                   __entry->rip,
 632                   __entry->isa == KVM_ISA_VMX ? "vmcs" : "vmcb",
 633                   __entry->vmcb,
 634                   __entry->nested_rip,
 635                   __entry->int_ctl,
 636                   __entry->event_inj,
 637                   __entry->isa == KVM_ISA_VMX ? "ept" : "npt",
 638                   __entry->tdp_enabled ? "y" : "n",
 639                   !__entry->tdp_enabled ? "guest_cr3" :
 640                   __entry->isa == KVM_ISA_VMX ? "nested_eptp" : "nested_cr3",
 641                   __entry->guest_pgd)
 642 );
 643
 644 TRACE_EVENT(kvm_nested_intercepts,
 645             TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions,
 646                      __u32 intercept1, __u32 intercept2, __u32 intercept3),
 647             TP_ARGS(cr_read, cr_write, exceptions, intercept1,
 648                     intercept2, intercept3),
 649
 650         TP_STRUCT__entry(
 651                 __field(        __u16,          cr_read         )
 652                 __field(        __u16,          cr_write        )
 653                 __field(        __u32,          exceptions      )
 654                 __field(        __u32,          intercept1      )
 655                 __field(        __u32,          intercept2      )
 656                 __field(        __u32,          intercept3      )
 657         ),
 658
 659         TP_fast_assign(
 660                 __entry->cr_read        = cr_read;
 661                 __entry->cr_write       = cr_write;
 662                 __entry->exceptions     = exceptions;
 663                 __entry->intercept1     = intercept1;
 664                 __entry->intercept2     = intercept2;
 665                 __entry->intercept3     = intercept3;
 666         ),
 667
 668         TP_printk("cr_read: %04x cr_write: %04x excp: %08x "
 669                   "intercepts: %08x %08x %08x",
 670                   __entry->cr_read, __entry->cr_write, __entry->exceptions,
 671                   __entry->intercept1, __entry->intercept2, __entry->intercept3)
 672 );
 673 /*
 674  * Tracepoint for #VMEXIT while nested
 675  */
 676 TRACE_EVENT_KVM_EXIT(kvm_nested_vmexit);
 677
 678 /*
 679  * Tracepoint for #VMEXIT reinjected to the guest
 680  */
 681 TRACE_EVENT(kvm_nested_vmexit_inject,
 682             TP_PROTO(__u32 exit_code,
 683                      __u64 exit_info1, __u64 exit_info2,
 684                      __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
 685             TP_ARGS(exit_code, exit_info1, exit_info2,
 686                     exit_int_info, exit_int_info_err, isa),
 687
 688         TP_STRUCT__entry(
 689                 __field(        __u32,          exit_code               )
 690                 __field(        __u64,          exit_info1              )
 691                 __field(        __u64,          exit_info2              )
 692                 __field(        __u32,          exit_int_info           )
 693                 __field(        __u32,          exit_int_info_err       )
 694                 __field(        __u32,          isa                     )
 695         ),
 696
 697         TP_fast_assign(
 698                 __entry->exit_code              = exit_code;
 699                 __entry->exit_info1             = exit_info1;
 700                 __entry->exit_info2             = exit_info2;
 701                 __entry->exit_int_info          = exit_int_info;
 702                 __entry->exit_int_info_err      = exit_int_info_err;
 703                 __entry->isa                    = isa;
 704         ),
 705
 706         TP_printk("reason: %s%s%s ext_inf1: 0x%016llx "
 707                   "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
 708                   kvm_print_exit_reason(__entry->exit_code, __entry->isa),
 709                   __entry->exit_info1, __entry->exit_info2,
 710                   __entry->exit_int_info, __entry->exit_int_info_err)
 711 );
 712
 713 /*
 714  * Tracepoint for nested #vmexit because of interrupt pending
 715  */
 716 TRACE_EVENT(kvm_nested_intr_vmexit,
 717             TP_PROTO(__u64 rip),
 718             TP_ARGS(rip),
 719
 720         TP_STRUCT__entry(
 721                 __field(        __u64,  rip     )
 722         ),
 723
 724         TP_fast_assign(
 725                 __entry->rip    =       rip
 726         ),
 727
 728         TP_printk("rip: 0x%016llx", __entry->rip)
 729 );
 730
 731 /*
 732  * Tracepoint for nested #vmexit because of interrupt pending
 733  */
 734 TRACE_EVENT(kvm_invlpga,
 735             TP_PROTO(__u64 rip, int asid, u64 address),
 736             TP_ARGS(rip, asid, address),
 737
 738         TP_STRUCT__entry(
 739                 __field(        __u64,  rip     )
 740                 __field(        int,    asid    )
 741                 __field(        __u64,  address )
 742         ),
 743
 744         TP_fast_assign(
 745                 __entry->rip            =       rip;
 746                 __entry->asid           =       asid;
 747                 __entry->address        =       address;
 748         ),
 749
 750         TP_printk("rip: 0x%016llx asid: %d address: 0x%016llx",
 751                   __entry->rip, __entry->asid, __entry->address)
 752 );
 753
 754 /*
 755  * Tracepoint for nested #vmexit because of interrupt pending
 756  */
 757 TRACE_EVENT(kvm_skinit,
 758             TP_PROTO(__u64 rip, __u32 slb),
 759             TP_ARGS(rip, slb),
 760
 761         TP_STRUCT__entry(
 762                 __field(        __u64,  rip     )
 763                 __field(        __u32,  slb     )
 764         ),
 765
 766         TP_fast_assign(
 767                 __entry->rip            =       rip;
 768                 __entry->slb            =       slb;
 769         ),
 770
 771         TP_printk("rip: 0x%016llx slb: 0x%08x",
 772                   __entry->rip, __entry->slb)
 773 );
 774
 775 #define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
 776 #define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
 777 #define KVM_EMUL_INSN_F_CS_D   (1 << 2)
 778 #define KVM_EMUL_INSN_F_CS_L   (1 << 3)
 779
 780 #define kvm_trace_symbol_emul_flags                       \
 781         { 0,                        "real" },             \
 782         { KVM_EMUL_INSN_F_CR0_PE                          \
 783           | KVM_EMUL_INSN_F_EFL_VM, "vm16" },             \
 784         { KVM_EMUL_INSN_F_CR0_PE,   "prot16" },           \
 785         { KVM_EMUL_INSN_F_CR0_PE                          \
 786           | KVM_EMUL_INSN_F_CS_D,   "prot32" },           \
 787         { KVM_EMUL_INSN_F_CR0_PE                          \
 788           | KVM_EMUL_INSN_F_CS_L,   "prot64" }
 789
 790 #define kei_decode_mode(mode) ({                        \
 791         u8 flags = 0xff;                                \
 792         switch (mode) {                                 \
 793         case X86EMUL_MODE_REAL:                         \
 794                 flags = 0;                              \
 795                 break;                                  \
 796         case X86EMUL_MODE_VM86:                         \
 797                 flags = KVM_EMUL_INSN_F_EFL_VM;         \
 798                 break;                                  \
 799         case X86EMUL_MODE_PROT16:                       \
 800                 flags = KVM_EMUL_INSN_F_CR0_PE;         \
 801                 break;                                  \
 802         case X86EMUL_MODE_PROT32:                       \
 803                 flags = KVM_EMUL_INSN_F_CR0_PE          \
 804                         | KVM_EMUL_INSN_F_CS_D;         \
 805                 break;                                  \
 806         case X86EMUL_MODE_PROT64:                       \
 807                 flags = KVM_EMUL_INSN_F_CR0_PE          \
 808                         | KVM_EMUL_INSN_F_CS_L;         \
 809                 break;                                  \
 810         }                                               \
 811         flags;                                          \
 812         })
 813
 814 TRACE_EVENT(kvm_emulate_insn,
 815         TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed),
 816         TP_ARGS(vcpu, failed),
 817
 818         TP_STRUCT__entry(
 819                 __field(    __u64, rip                       )
 820                 __field(    __u32, csbase                    )
 821                 __field(    __u8,  len                       )
 822                 __array(    __u8,  insn,    15               )
 823                 __field(    __u8,  flags                     )
 824                 __field(    __u8,  failed                    )
 825                 ),
 826
 827         TP_fast_assign(
 828                 __entry->csbase = static_call(kvm_x86_get_segment_base)(vcpu, VCPU_SREG_CS);
 829                 __entry->len = vcpu->arch.emulate_ctxt->fetch.ptr
 830                                - vcpu->arch.emulate_ctxt->fetch.data;
 831                 __entry->rip = vcpu->arch.emulate_ctxt->_eip - __entry->len;
 832                 memcpy(__entry->insn,
 833                        vcpu->arch.emulate_ctxt->fetch.data,
 834                        15);
 835                 __entry->flags = kei_decode_mode(vcpu->arch.emulate_ctxt->mode);
 836                 __entry->failed = failed;
 837                 ),
 838
 839         TP_printk("%x:%llx:%s (%s)%s",
 840                   __entry->csbase, __entry->rip,
 841                   __print_hex(__entry->insn, __entry->len),
 842                   __print_symbolic(__entry->flags,
 843                                    kvm_trace_symbol_emul_flags),
 844                   __entry->failed ? " failed" : ""
 845                 )
 846         );
 847
 848 #define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0)
 849 #define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1)
 850
 851 TRACE_EVENT(
 852         vcpu_match_mmio,
 853         TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match),
 854         TP_ARGS(gva, gpa, write, gpa_match),
 855
 856         TP_STRUCT__entry(
 857                 __field(gva_t, gva)
 858                 __field(gpa_t, gpa)
 859                 __field(bool, write)
 860                 __field(bool, gpa_match)
 861                 ),
 862
 863         TP_fast_assign(
 864                 __entry->gva = gva;
 865                 __entry->gpa = gpa;
 866                 __entry->write = write;
 867                 __entry->gpa_match = gpa_match
 868                 ),
 869
 870         TP_printk("gva %#lx gpa %#llx %s %s", __entry->gva, __entry->gpa,
 871                   __entry->write ? "Write" : "Read",
 872                   __entry->gpa_match ? "GPA" : "GVA")
 873 );
 874
 875 TRACE_EVENT(kvm_write_tsc_offset,
 876         TP_PROTO(unsigned int vcpu_id, __u64 previous_tsc_offset,
 877                  __u64 next_tsc_offset),
 878         TP_ARGS(vcpu_id, previous_tsc_offset, next_tsc_offset),
 879
 880         TP_STRUCT__entry(
 881                 __field( unsigned int,  vcpu_id                         )
 882                 __field(        __u64,  previous_tsc_offset             )
 883                 __field(        __u64,  next_tsc_offset                 )
 884         ),
 885
 886         TP_fast_assign(
 887                 __entry->vcpu_id                = vcpu_id;
 888                 __entry->previous_tsc_offset    = previous_tsc_offset;
 889                 __entry->next_tsc_offset        = next_tsc_offset;
 890         ),
 891
 892         TP_printk("vcpu=%u prev=%llu next=%llu", __entry->vcpu_id,
 893                   __entry->previous_tsc_offset, __entry->next_tsc_offset)
 894 );
 895
 896 #ifdef CONFIG_X86_64
 897
 898 #define host_clocks                                     \
 899         {VDSO_CLOCKMODE_NONE, "none"},                  \
 900         {VDSO_CLOCKMODE_TSC,  "tsc"}                    \
 901
 902 TRACE_EVENT(kvm_update_master_clock,
 903         TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched),
 904         TP_ARGS(use_master_clock, host_clock, offset_matched),
 905
 906         TP_STRUCT__entry(
 907                 __field(                bool,   use_master_clock        )
 908                 __field(        unsigned int,   host_clock              )
 909                 __field(                bool,   offset_matched          )
 910         ),
 911
 912         TP_fast_assign(
 913                 __entry->use_master_clock       = use_master_clock;
 914                 __entry->host_clock             = host_clock;
 915                 __entry->offset_matched         = offset_matched;
 916         ),
 917
 918         TP_printk("masterclock %d hostclock %s offsetmatched %u",
 919                   __entry->use_master_clock,
 920                   __print_symbolic(__entry->host_clock, host_clocks),
 921                   __entry->offset_matched)
 922 );
 923
 924 TRACE_EVENT(kvm_track_tsc,
 925         TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched,
 926                  unsigned int online_vcpus, bool use_master_clock,
 927                  unsigned int host_clock),
 928         TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock,
 929                 host_clock),
 930
 931         TP_STRUCT__entry(
 932                 __field(        unsigned int,   vcpu_id                 )
 933                 __field(        unsigned int,   nr_vcpus_matched_tsc    )
 934                 __field(        unsigned int,   online_vcpus            )
 935                 __field(        bool,           use_master_clock        )
 936                 __field(        unsigned int,   host_clock              )
 937         ),
 938
 939         TP_fast_assign(
 940                 __entry->vcpu_id                = vcpu_id;
 941                 __entry->nr_vcpus_matched_tsc   = nr_matched;
 942                 __entry->online_vcpus           = online_vcpus;
 943                 __entry->use_master_clock       = use_master_clock;
 944                 __entry->host_clock             = host_clock;
 945         ),
 946
 947         TP_printk("vcpu_id %u masterclock %u offsetmatched %u nr_online %u"
 948                   " hostclock %s",
 949                   __entry->vcpu_id, __entry->use_master_clock,
 950                   __entry->nr_vcpus_matched_tsc, __entry->online_vcpus,
 951                   __print_symbolic(__entry->host_clock, host_clocks))
 952 );
 953
 954 #endif /* CONFIG_X86_64 */
 955
 956 /*
 957  * Tracepoint for PML full VMEXIT.
 958  */
 959 TRACE_EVENT(kvm_pml_full,
 960         TP_PROTO(unsigned int vcpu_id),
 961         TP_ARGS(vcpu_id),
 962
 963         TP_STRUCT__entry(
 964                 __field(        unsigned int,   vcpu_id                 )
 965         ),
 966
 967         TP_fast_assign(
 968                 __entry->vcpu_id                = vcpu_id;
 969         ),
 970
 971         TP_printk("vcpu %d: PML full", __entry->vcpu_id)
 972 );
 973
 974 TRACE_EVENT(kvm_ple_window_update,
 975         TP_PROTO(unsigned int vcpu_id, unsigned int new, unsigned int old),
 976         TP_ARGS(vcpu_id, new, old),
 977
 978         TP_STRUCT__entry(
 979                 __field(        unsigned int,   vcpu_id         )
 980                 __field(        unsigned int,       new         )
 981                 __field(        unsigned int,       old         )
 982         ),
 983
 984         TP_fast_assign(
 985                 __entry->vcpu_id        = vcpu_id;
 986                 __entry->new            = new;
 987                 __entry->old            = old;
 988         ),
 989
 990         TP_printk("vcpu %u old %u new %u (%s)",
 991                   __entry->vcpu_id, __entry->old, __entry->new,
 992                   __entry->old < __entry->new ? "growed" : "shrinked")
 993 );
 994
 995 TRACE_EVENT(kvm_pvclock_update,
 996         TP_PROTO(unsigned int vcpu_id, struct pvclock_vcpu_time_info *pvclock),
 997         TP_ARGS(vcpu_id, pvclock),
 998
 999         TP_STRUCT__entry(
1000                 __field(        unsigned int,   vcpu_id                 )
1001                 __field(        __u32,          version                 )
1002                 __field(        __u64,          tsc_timestamp           )
1003                 __field(        __u64,          system_time             )
1004                 __field(        __u32,          tsc_to_system_mul       )
1005                 __field(        __s8,           tsc_shift               )
1006                 __field(        __u8,           flags                   )
1007         ),
1008
1009         TP_fast_assign(
1010                 __entry->vcpu_id           = vcpu_id;
1011                 __entry->version           = pvclock->version;
1012                 __entry->tsc_timestamp     = pvclock->tsc_timestamp;
1013                 __entry->system_time       = pvclock->system_time;
1014                 __entry->tsc_to_system_mul = pvclock->tsc_to_system_mul;
1015                 __entry->tsc_shift         = pvclock->tsc_shift;
1016                 __entry->flags             = pvclock->flags;
1017         ),
1018
1019         TP_printk("vcpu_id %u, pvclock { version %u, tsc_timestamp 0x%llx, "
1020                   "system_time 0x%llx, tsc_to_system_mul 0x%x, tsc_shift %d, "
1021                   "flags 0x%x }",
1022                   __entry->vcpu_id,
1023                   __entry->version,
1024                   __entry->tsc_timestamp,
1025                   __entry->system_time,
1026                   __entry->tsc_to_system_mul,
1027                   __entry->tsc_shift,
1028                   __entry->flags)
1029 );
1030
1031 TRACE_EVENT(kvm_wait_lapic_expire,
1032         TP_PROTO(unsigned int vcpu_id, s64 delta),
1033         TP_ARGS(vcpu_id, delta),
1034
1035         TP_STRUCT__entry(
1036                 __field(        unsigned int,   vcpu_id         )
1037                 __field(        s64,            delta           )
1038         ),
1039
1040         TP_fast_assign(
1041                 __entry->vcpu_id           = vcpu_id;
1042                 __entry->delta             = delta;
1043         ),
1044
1045         TP_printk("vcpu %u: delta %lld (%s)",
1046                   __entry->vcpu_id,
1047                   __entry->delta,
1048                   __entry->delta < 0 ? "early" : "late")
1049 );
1050
1051 TRACE_EVENT(kvm_smm_transition,
1052         TP_PROTO(unsigned int vcpu_id, u64 smbase, bool entering),
1053         TP_ARGS(vcpu_id, smbase, entering),
1054
1055         TP_STRUCT__entry(
1056                 __field(        unsigned int,   vcpu_id         )
1057                 __field(        u64,            smbase          )
1058                 __field(        bool,           entering        )
1059         ),
1060
1061         TP_fast_assign(
1062                 __entry->vcpu_id        = vcpu_id;
1063                 __entry->smbase         = smbase;
1064                 __entry->entering       = entering;
1065         ),
1066
1067         TP_printk("vcpu %u: %s SMM, smbase 0x%llx",
1068                   __entry->vcpu_id,
1069                   __entry->entering ? "entering" : "leaving",
1070                   __entry->smbase)
1071 );
1072
1073 /*
1074  * Tracepoint for VT-d posted-interrupts.
1075  */
1076 TRACE_EVENT(kvm_pi_irte_update,
1077         TP_PROTO(unsigned int host_irq, unsigned int vcpu_id,
1078                  unsigned int gsi, unsigned int gvec,
1079                  u64 pi_desc_addr, bool set),
1080         TP_ARGS(host_irq, vcpu_id, gsi, gvec, pi_desc_addr, set),
1081
1082         TP_STRUCT__entry(
1083                 __field(        unsigned int,   host_irq        )
1084                 __field(        unsigned int,   vcpu_id         )
1085                 __field(        unsigned int,   gsi             )
1086                 __field(        unsigned int,   gvec            )
1087                 __field(        u64,            pi_desc_addr    )
1088                 __field(        bool,           set             )
1089         ),
1090
1091         TP_fast_assign(
1092                 __entry->host_irq       = host_irq;
1093                 __entry->vcpu_id        = vcpu_id;
1094                 __entry->gsi            = gsi;
1095                 __entry->gvec           = gvec;
1096                 __entry->pi_desc_addr   = pi_desc_addr;
1097                 __entry->set            = set;
1098         ),
1099
1100         TP_printk("VT-d PI is %s for irq %u, vcpu %u, gsi: 0x%x, "
1101                   "gvec: 0x%x, pi_desc_addr: 0x%llx",
1102                   __entry->set ? "enabled and being updated" : "disabled",
1103                   __entry->host_irq,
1104                   __entry->vcpu_id,
1105                   __entry->gsi,
1106                   __entry->gvec,
1107                   __entry->pi_desc_addr)
1108 );
1109
1110 /*
1111  * Tracepoint for kvm_hv_notify_acked_sint.
1112  */
1113 TRACE_EVENT(kvm_hv_notify_acked_sint,
1114         TP_PROTO(int vcpu_id, u32 sint),
1115         TP_ARGS(vcpu_id, sint),
1116
1117         TP_STRUCT__entry(
1118                 __field(int, vcpu_id)
1119                 __field(u32, sint)
1120         ),
1121
1122         TP_fast_assign(
1123                 __entry->vcpu_id = vcpu_id;
1124                 __entry->sint = sint;
1125         ),
1126
1127         TP_printk("vcpu_id %d sint %u", __entry->vcpu_id, __entry->sint)
1128 );
1129
1130 /*
1131  * Tracepoint for synic_set_irq.
1132  */
1133 TRACE_EVENT(kvm_hv_synic_set_irq,
1134         TP_PROTO(int vcpu_id, u32 sint, int vector, int ret),
1135         TP_ARGS(vcpu_id, sint, vector, ret),
1136
1137         TP_STRUCT__entry(
1138                 __field(int, vcpu_id)
1139                 __field(u32, sint)
1140                 __field(int, vector)
1141                 __field(int, ret)
1142         ),
1143
1144         TP_fast_assign(
1145                 __entry->vcpu_id = vcpu_id;
1146                 __entry->sint = sint;
1147                 __entry->vector = vector;
1148                 __entry->ret = ret;
1149         ),
1150
1151         TP_printk("vcpu_id %d sint %u vector %d ret %d",
1152                   __entry->vcpu_id, __entry->sint, __entry->vector,
1153                   __entry->ret)
1154 );
1155
1156 /*
1157  * Tracepoint for kvm_hv_synic_send_eoi.
1158  */
1159 TRACE_EVENT(kvm_hv_synic_send_eoi,
1160         TP_PROTO(int vcpu_id, int vector),
1161         TP_ARGS(vcpu_id, vector),
1162
1163         TP_STRUCT__entry(
1164                 __field(int, vcpu_id)
1165                 __field(u32, sint)
1166                 __field(int, vector)
1167                 __field(int, ret)
1168         ),
1169
1170         TP_fast_assign(
1171                 __entry->vcpu_id = vcpu_id;
1172                 __entry->vector = vector;
1173         ),
1174
1175         TP_printk("vcpu_id %d vector %d", __entry->vcpu_id, __entry->vector)
1176 );
1177
1178 /*
1179  * Tracepoint for synic_set_msr.
1180  */
1181 TRACE_EVENT(kvm_hv_synic_set_msr,
1182         TP_PROTO(int vcpu_id, u32 msr, u64 data, bool host),
1183         TP_ARGS(vcpu_id, msr, data, host),
1184
1185         TP_STRUCT__entry(
1186                 __field(int, vcpu_id)
1187                 __field(u32, msr)
1188                 __field(u64, data)
1189                 __field(bool, host)
1190         ),
1191
1192         TP_fast_assign(
1193                 __entry->vcpu_id = vcpu_id;
1194                 __entry->msr = msr;
1195                 __entry->data = data;
1196                 __entry->host = host
1197         ),
1198
1199         TP_printk("vcpu_id %d msr 0x%x data 0x%llx host %d",
1200                   __entry->vcpu_id, __entry->msr, __entry->data, __entry->host)
1201 );
1202
1203 /*
1204  * Tracepoint for stimer_set_config.
1205  */
1206 TRACE_EVENT(kvm_hv_stimer_set_config,
1207         TP_PROTO(int vcpu_id, int timer_index, u64 config, bool host),
1208         TP_ARGS(vcpu_id, timer_index, config, host),
1209
1210         TP_STRUCT__entry(
1211                 __field(int, vcpu_id)
1212                 __field(int, timer_index)
1213                 __field(u64, config)
1214                 __field(bool, host)
1215         ),
1216
1217         TP_fast_assign(
1218                 __entry->vcpu_id = vcpu_id;
1219                 __entry->timer_index = timer_index;
1220                 __entry->config = config;
1221                 __entry->host = host;
1222         ),
1223
1224         TP_printk("vcpu_id %d timer %d config 0x%llx host %d",
1225                   __entry->vcpu_id, __entry->timer_index, __entry->config,
1226                   __entry->host)
1227 );
1228
1229 /*
1230  * Tracepoint for stimer_set_count.
1231  */
1232 TRACE_EVENT(kvm_hv_stimer_set_count,
1233         TP_PROTO(int vcpu_id, int timer_index, u64 count, bool host),
1234         TP_ARGS(vcpu_id, timer_index, count, host),
1235
1236         TP_STRUCT__entry(
1237                 __field(int, vcpu_id)
1238                 __field(int, timer_index)
1239                 __field(u64, count)
1240                 __field(bool, host)
1241         ),
1242
1243         TP_fast_assign(
1244                 __entry->vcpu_id = vcpu_id;
1245                 __entry->timer_index = timer_index;
1246                 __entry->count = count;
1247                 __entry->host = host;
1248         ),
1249
1250         TP_printk("vcpu_id %d timer %d count %llu host %d",
1251                   __entry->vcpu_id, __entry->timer_index, __entry->count,
1252                   __entry->host)
1253 );
1254
1255 /*
1256  * Tracepoint for stimer_start(periodic timer case).
1257  */
1258 TRACE_EVENT(kvm_hv_stimer_start_periodic,
1259         TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 exp_time),
1260         TP_ARGS(vcpu_id, timer_index, time_now, exp_time),
1261
1262         TP_STRUCT__entry(
1263                 __field(int, vcpu_id)
1264                 __field(int, timer_index)
1265                 __field(u64, time_now)
1266                 __field(u64, exp_time)
1267         ),
1268
1269         TP_fast_assign(
1270                 __entry->vcpu_id = vcpu_id;
1271                 __entry->timer_index = timer_index;
1272                 __entry->time_now = time_now;
1273                 __entry->exp_time = exp_time;
1274         ),
1275
1276         TP_printk("vcpu_id %d timer %d time_now %llu exp_time %llu",
1277                   __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1278                   __entry->exp_time)
1279 );
1280
1281 /*
1282  * Tracepoint for stimer_start(one-shot timer case).
1283  */
1284 TRACE_EVENT(kvm_hv_stimer_start_one_shot,
1285         TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 count),
1286         TP_ARGS(vcpu_id, timer_index, time_now, count),
1287
1288         TP_STRUCT__entry(
1289                 __field(int, vcpu_id)
1290                 __field(int, timer_index)
1291                 __field(u64, time_now)
1292                 __field(u64, count)
1293         ),
1294
1295         TP_fast_assign(
1296                 __entry->vcpu_id = vcpu_id;
1297                 __entry->timer_index = timer_index;
1298                 __entry->time_now = time_now;
1299                 __entry->count = count;
1300         ),
1301
1302         TP_printk("vcpu_id %d timer %d time_now %llu count %llu",
1303                   __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1304                   __entry->count)
1305 );
1306
1307 /*
1308  * Tracepoint for stimer_timer_callback.
1309  */
1310 TRACE_EVENT(kvm_hv_stimer_callback,
1311         TP_PROTO(int vcpu_id, int timer_index),
1312         TP_ARGS(vcpu_id, timer_index),
1313
1314         TP_STRUCT__entry(
1315                 __field(int, vcpu_id)
1316                 __field(int, timer_index)
1317         ),
1318
1319         TP_fast_assign(
1320                 __entry->vcpu_id = vcpu_id;
1321                 __entry->timer_index = timer_index;
1322         ),
1323
1324         TP_printk("vcpu_id %d timer %d",
1325                   __entry->vcpu_id, __entry->timer_index)
1326 );
1327
1328 /*
1329  * Tracepoint for stimer_expiration.
1330  */
1331 TRACE_EVENT(kvm_hv_stimer_expiration,
1332         TP_PROTO(int vcpu_id, int timer_index, int direct, int msg_send_result),
1333         TP_ARGS(vcpu_id, timer_index, direct, msg_send_result),
1334
1335         TP_STRUCT__entry(
1336                 __field(int, vcpu_id)
1337                 __field(int, timer_index)
1338                 __field(int, direct)
1339                 __field(int, msg_send_result)
1340         ),
1341
1342         TP_fast_assign(
1343                 __entry->vcpu_id = vcpu_id;
1344                 __entry->timer_index = timer_index;
1345                 __entry->direct = direct;
1346                 __entry->msg_send_result = msg_send_result;
1347         ),
1348
1349         TP_printk("vcpu_id %d timer %d direct %d send result %d",
1350                   __entry->vcpu_id, __entry->timer_index,
1351                   __entry->direct, __entry->msg_send_result)
1352 );
1353
1354 /*
1355  * Tracepoint for stimer_cleanup.
1356  */
1357 TRACE_EVENT(kvm_hv_stimer_cleanup,
1358         TP_PROTO(int vcpu_id, int timer_index),
1359         TP_ARGS(vcpu_id, timer_index),
1360
1361         TP_STRUCT__entry(
1362                 __field(int, vcpu_id)
1363                 __field(int, timer_index)
1364         ),
1365
1366         TP_fast_assign(
1367                 __entry->vcpu_id = vcpu_id;
1368                 __entry->timer_index = timer_index;
1369         ),
1370
1371         TP_printk("vcpu_id %d timer %d",
1372                   __entry->vcpu_id, __entry->timer_index)
1373 );
1374
1375 TRACE_EVENT(kvm_apicv_inhibit_changed,
1376             TP_PROTO(int reason, bool set, unsigned long inhibits),
1377             TP_ARGS(reason, set, inhibits),
1378
1379         TP_STRUCT__entry(
1380                 __field(int, reason)
1381                 __field(bool, set)
1382                 __field(unsigned long, inhibits)
1383         ),
1384
1385         TP_fast_assign(
1386                 __entry->reason = reason;
1387                 __entry->set = set;
1388                 __entry->inhibits = inhibits;
1389         ),
1390
1391         TP_printk("%s reason=%u, inhibits=0x%lx",
1392                   __entry->set ? "set" : "cleared",
1393                   __entry->reason, __entry->inhibits)
1394 );
1395
1396 TRACE_EVENT(kvm_apicv_accept_irq,
1397             TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec),
1398             TP_ARGS(apicid, dm, tm, vec),
1399
1400         TP_STRUCT__entry(
1401                 __field(        __u32,          apicid          )
1402                 __field(        __u16,          dm              )
1403                 __field(        __u16,          tm              )
1404                 __field(        __u8,           vec             )
1405         ),
1406
1407         TP_fast_assign(
1408                 __entry->apicid         = apicid;
1409                 __entry->dm             = dm;
1410                 __entry->tm             = tm;
1411                 __entry->vec            = vec;
1412         ),
1413
1414         TP_printk("apicid %x vec %u (%s|%s)",
1415                   __entry->apicid, __entry->vec,
1416                   __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
1417                   __entry->tm ? "level" : "edge")
1418 );
1419
1420 /*
1421  * Tracepoint for AMD AVIC
1422  */
1423 TRACE_EVENT(kvm_avic_incomplete_ipi,
1424             TP_PROTO(u32 vcpu, u32 icrh, u32 icrl, u32 id, u32 index),
1425             TP_ARGS(vcpu, icrh, icrl, id, index),
1426
1427         TP_STRUCT__entry(
1428                 __field(u32, vcpu)
1429                 __field(u32, icrh)
1430                 __field(u32, icrl)
1431                 __field(u32, id)
1432                 __field(u32, index)
1433         ),
1434
1435         TP_fast_assign(
1436                 __entry->vcpu = vcpu;
1437                 __entry->icrh = icrh;
1438                 __entry->icrl = icrl;
1439                 __entry->id = id;
1440                 __entry->index = index;
1441         ),
1442
1443         TP_printk("vcpu=%u, icrh:icrl=%#010x:%08x, id=%u, index=%u",
1444                   __entry->vcpu, __entry->icrh, __entry->icrl,
1445                   __entry->id, __entry->index)
1446 );
1447
1448 TRACE_EVENT(kvm_avic_unaccelerated_access,
1449             TP_PROTO(u32 vcpu, u32 offset, bool ft, bool rw, u32 vec),
1450             TP_ARGS(vcpu, offset, ft, rw, vec),
1451
1452         TP_STRUCT__entry(
1453                 __field(u32, vcpu)
1454                 __field(u32, offset)
1455                 __field(bool, ft)
1456                 __field(bool, rw)
1457                 __field(u32, vec)
1458         ),
1459
1460         TP_fast_assign(
1461                 __entry->vcpu = vcpu;
1462                 __entry->offset = offset;
1463                 __entry->ft = ft;
1464                 __entry->rw = rw;
1465                 __entry->vec = vec;
1466         ),
1467
1468         TP_printk("vcpu=%u, offset=%#x(%s), %s, %s, vec=%#x",
1469                   __entry->vcpu,
1470                   __entry->offset,
1471                   __print_symbolic(__entry->offset, kvm_trace_symbol_apic),
1472                   __entry->ft ? "trap" : "fault",
1473                   __entry->rw ? "write" : "read",
1474                   __entry->vec)
1475 );
1476
1477 TRACE_EVENT(kvm_avic_ga_log,
1478             TP_PROTO(u32 vmid, u32 vcpuid),
1479             TP_ARGS(vmid, vcpuid),
1480
1481         TP_STRUCT__entry(
1482                 __field(u32, vmid)
1483                 __field(u32, vcpuid)
1484         ),
1485
1486         TP_fast_assign(
1487                 __entry->vmid = vmid;
1488                 __entry->vcpuid = vcpuid;
1489         ),
1490
1491         TP_printk("vmid=%u, vcpuid=%u",
1492                   __entry->vmid, __entry->vcpuid)
1493 );
1494
1495 TRACE_EVENT(kvm_avic_kick_vcpu_slowpath,
1496             TP_PROTO(u32 icrh, u32 icrl, u32 index),
1497             TP_ARGS(icrh, icrl, index),
1498
1499         TP_STRUCT__entry(
1500                 __field(u32, icrh)
1501                 __field(u32, icrl)
1502                 __field(u32, index)
1503         ),
1504
1505         TP_fast_assign(
1506                 __entry->icrh = icrh;
1507                 __entry->icrl = icrl;
1508                 __entry->index = index;
1509         ),
1510
1511         TP_printk("icrh:icrl=%#08x:%08x, index=%u",
1512                   __entry->icrh, __entry->icrl, __entry->index)
1513 );
1514
1515 TRACE_EVENT(kvm_avic_doorbell,
1516             TP_PROTO(u32 vcpuid, u32 apicid),
1517             TP_ARGS(vcpuid, apicid),
1518
1519         TP_STRUCT__entry(
1520                 __field(u32, vcpuid)
1521                 __field(u32, apicid)
1522         ),
1523
1524         TP_fast_assign(
1525                 __entry->vcpuid = vcpuid;
1526                 __entry->apicid = apicid;
1527         ),
1528
1529         TP_printk("vcpuid=%u, apicid=%u",
1530                   __entry->vcpuid, __entry->apicid)
1531 );
1532
1533 TRACE_EVENT(kvm_hv_timer_state,
1534                 TP_PROTO(unsigned int vcpu_id, unsigned int hv_timer_in_use),
1535                 TP_ARGS(vcpu_id, hv_timer_in_use),
1536                 TP_STRUCT__entry(
1537                         __field(unsigned int, vcpu_id)
1538                         __field(unsigned int, hv_timer_in_use)
1539                         ),
1540                 TP_fast_assign(
1541                         __entry->vcpu_id = vcpu_id;
1542                         __entry->hv_timer_in_use = hv_timer_in_use;
1543                         ),
1544                 TP_printk("vcpu_id %x hv_timer %x",
1545                         __entry->vcpu_id,
1546                         __entry->hv_timer_in_use)
1547 );
1548
1549 /*
1550  * Tracepoint for kvm_hv_flush_tlb.
1551  */
1552 TRACE_EVENT(kvm_hv_flush_tlb,
1553         TP_PROTO(u64 processor_mask, u64 address_space, u64 flags, bool guest_mode),
1554         TP_ARGS(processor_mask, address_space, flags, guest_mode),
1555
1556         TP_STRUCT__entry(
1557                 __field(u64, processor_mask)
1558                 __field(u64, address_space)
1559                 __field(u64, flags)
1560                 __field(bool, guest_mode)
1561         ),
1562
1563         TP_fast_assign(
1564                 __entry->processor_mask = processor_mask;
1565                 __entry->address_space = address_space;
1566                 __entry->flags = flags;
1567                 __entry->guest_mode = guest_mode;
1568         ),
1569
1570         TP_printk("processor_mask 0x%llx address_space 0x%llx flags 0x%llx %s",
1571                   __entry->processor_mask, __entry->address_space,
1572                   __entry->flags, __entry->guest_mode ? "(L2)" : "")
1573 );
1574
1575 /*
1576  * Tracepoint for kvm_hv_flush_tlb_ex.
1577  */
1578 TRACE_EVENT(kvm_hv_flush_tlb_ex,
1579         TP_PROTO(u64 valid_bank_mask, u64 format, u64 address_space, u64 flags, bool guest_mode),
1580         TP_ARGS(valid_bank_mask, format, address_space, flags, guest_mode),
1581
1582         TP_STRUCT__entry(
1583                 __field(u64, valid_bank_mask)
1584                 __field(u64, format)
1585                 __field(u64, address_space)
1586                 __field(u64, flags)
1587                 __field(bool, guest_mode)
1588         ),
1589
1590         TP_fast_assign(
1591                 __entry->valid_bank_mask = valid_bank_mask;
1592                 __entry->format = format;
1593                 __entry->address_space = address_space;
1594                 __entry->flags = flags;
1595                 __entry->guest_mode = guest_mode;
1596         ),
1597
1598         TP_printk("valid_bank_mask 0x%llx format 0x%llx "
1599                   "address_space 0x%llx flags 0x%llx %s",
1600                   __entry->valid_bank_mask, __entry->format,
1601                   __entry->address_space, __entry->flags,
1602                   __entry->guest_mode ? "(L2)" : "")
1603 );
1604
1605 /*
1606  * Tracepoints for kvm_hv_send_ipi.
1607  */
1608 TRACE_EVENT(kvm_hv_send_ipi,
1609         TP_PROTO(u32 vector, u64 processor_mask),
1610         TP_ARGS(vector, processor_mask),
1611
1612         TP_STRUCT__entry(
1613                 __field(u32, vector)
1614                 __field(u64, processor_mask)
1615         ),
1616
1617         TP_fast_assign(
1618                 __entry->vector = vector;
1619                 __entry->processor_mask = processor_mask;
1620         ),
1621
1622         TP_printk("vector %x processor_mask 0x%llx",
1623                   __entry->vector, __entry->processor_mask)
1624 );
1625
1626 TRACE_EVENT(kvm_hv_send_ipi_ex,
1627         TP_PROTO(u32 vector, u64 format, u64 valid_bank_mask),
1628         TP_ARGS(vector, format, valid_bank_mask),
1629
1630         TP_STRUCT__entry(
1631                 __field(u32, vector)
1632                 __field(u64, format)
1633                 __field(u64, valid_bank_mask)
1634         ),
1635
1636         TP_fast_assign(
1637                 __entry->vector = vector;
1638                 __entry->format = format;
1639                 __entry->valid_bank_mask = valid_bank_mask;
1640         ),
1641
1642         TP_printk("vector %x format %llx valid_bank_mask 0x%llx",
1643                   __entry->vector, __entry->format,
1644                   __entry->valid_bank_mask)
1645 );
1646
1647 TRACE_EVENT(kvm_pv_tlb_flush,
1648         TP_PROTO(unsigned int vcpu_id, bool need_flush_tlb),
1649         TP_ARGS(vcpu_id, need_flush_tlb),
1650
1651         TP_STRUCT__entry(
1652                 __field(        unsigned int,   vcpu_id         )
1653                 __field(        bool,   need_flush_tlb          )
1654         ),
1655
1656         TP_fast_assign(
1657                 __entry->vcpu_id        = vcpu_id;
1658                 __entry->need_flush_tlb = need_flush_tlb;
1659         ),
1660
1661         TP_printk("vcpu %u need_flush_tlb %s", __entry->vcpu_id,
1662                 __entry->need_flush_tlb ? "true" : "false")
1663 );
1664
1665 /*
1666  * Tracepoint for failed nested VMX VM-Enter.
1667  */
1668 TRACE_EVENT(kvm_nested_vmenter_failed,
1669         TP_PROTO(const char *msg, u32 err),
1670         TP_ARGS(msg, err),
1671
1672         TP_STRUCT__entry(
1673                 __string(msg, msg)
1674                 __field(u32, err)
1675         ),
1676
1677         TP_fast_assign(
1678                 __assign_str(msg, msg);
1679                 __entry->err = err;
1680         ),
1681
1682         TP_printk("%s%s", __get_str(msg), !__entry->err ? "" :
1683                 __print_symbolic(__entry->err, VMX_VMENTER_INSTRUCTION_ERRORS))
1684 );
1685
1686 /*
1687  * Tracepoint for syndbg_set_msr.
1688  */
1689 TRACE_EVENT(kvm_hv_syndbg_set_msr,
1690         TP_PROTO(int vcpu_id, u32 vp_index, u32 msr, u64 data),
1691         TP_ARGS(vcpu_id, vp_index, msr, data),
1692
1693         TP_STRUCT__entry(
1694                 __field(int, vcpu_id)
1695                 __field(u32, vp_index)
1696                 __field(u32, msr)
1697                 __field(u64, data)
1698         ),
1699
1700         TP_fast_assign(
1701                 __entry->vcpu_id = vcpu_id;
1702                 __entry->vp_index = vp_index;
1703                 __entry->msr = msr;
1704                 __entry->data = data;
1705         ),
1706
1707         TP_printk("vcpu_id %d vp_index %u msr 0x%x data 0x%llx",
1708                   __entry->vcpu_id, __entry->vp_index, __entry->msr,
1709                   __entry->data)
1710 );
1711
1712 /*
1713  * Tracepoint for syndbg_get_msr.
1714  */
1715 TRACE_EVENT(kvm_hv_syndbg_get_msr,
1716         TP_PROTO(int vcpu_id, u32 vp_index, u32 msr, u64 data),
1717         TP_ARGS(vcpu_id, vp_index, msr, data),
1718
1719         TP_STRUCT__entry(
1720                 __field(int, vcpu_id)
1721                 __field(u32, vp_index)
1722                 __field(u32, msr)
1723                 __field(u64, data)
1724         ),
1725
1726         TP_fast_assign(
1727                 __entry->vcpu_id = vcpu_id;
1728                 __entry->vp_index = vp_index;
1729                 __entry->msr = msr;
1730                 __entry->data = data;
1731         ),
1732
1733         TP_printk("vcpu_id %d vp_index %u msr 0x%x data 0x%llx",
1734                   __entry->vcpu_id, __entry->vp_index, __entry->msr,
1735                   __entry->data)
1736 );
1737
1738 /*
1739  * Tracepoint for the start of VMGEXIT processing
1740  */
1741 TRACE_EVENT(kvm_vmgexit_enter,
1742         TP_PROTO(unsigned int vcpu_id, struct ghcb *ghcb),
1743         TP_ARGS(vcpu_id, ghcb),
1744
1745         TP_STRUCT__entry(
1746                 __field(unsigned int, vcpu_id)
1747                 __field(u64, exit_reason)
1748                 __field(u64, info1)
1749                 __field(u64, info2)
1750         ),
1751
1752         TP_fast_assign(
1753                 __entry->vcpu_id     = vcpu_id;
1754                 __entry->exit_reason = ghcb->save.sw_exit_code;
1755                 __entry->info1       = ghcb->save.sw_exit_info_1;
1756                 __entry->info2       = ghcb->save.sw_exit_info_2;
1757         ),
1758
1759         TP_printk("vcpu %u, exit_reason %llx, exit_info1 %llx, exit_info2 %llx",
1760                   __entry->vcpu_id, __entry->exit_reason,
1761                   __entry->info1, __entry->info2)
1762 );
1763
1764 /*
1765  * Tracepoint for the end of VMGEXIT processing
1766  */
1767 TRACE_EVENT(kvm_vmgexit_exit,
1768         TP_PROTO(unsigned int vcpu_id, struct ghcb *ghcb),
1769         TP_ARGS(vcpu_id, ghcb),
1770
1771         TP_STRUCT__entry(
1772                 __field(unsigned int, vcpu_id)
1773                 __field(u64, exit_reason)
1774                 __field(u64, info1)
1775                 __field(u64, info2)
1776         ),
1777
1778         TP_fast_assign(
1779                 __entry->vcpu_id     = vcpu_id;
1780                 __entry->exit_reason = ghcb->save.sw_exit_code;
1781                 __entry->info1       = ghcb->save.sw_exit_info_1;
1782                 __entry->info2       = ghcb->save.sw_exit_info_2;
1783         ),
1784
1785         TP_printk("vcpu %u, exit_reason %llx, exit_info1 %llx, exit_info2 %llx",
1786                   __entry->vcpu_id, __entry->exit_reason,
1787                   __entry->info1, __entry->info2)
1788 );
1789
1790 /*
1791  * Tracepoint for the start of VMGEXIT MSR procotol processing
1792  */
1793 TRACE_EVENT(kvm_vmgexit_msr_protocol_enter,
1794         TP_PROTO(unsigned int vcpu_id, u64 ghcb_gpa),
1795         TP_ARGS(vcpu_id, ghcb_gpa),
1796
1797         TP_STRUCT__entry(
1798                 __field(unsigned int, vcpu_id)
1799                 __field(u64, ghcb_gpa)
1800         ),
1801
1802         TP_fast_assign(
1803                 __entry->vcpu_id  = vcpu_id;
1804                 __entry->ghcb_gpa = ghcb_gpa;
1805         ),
1806
1807         TP_printk("vcpu %u, ghcb_gpa %016llx",
1808                   __entry->vcpu_id, __entry->ghcb_gpa)
1809 );
1810
1811 /*
1812  * Tracepoint for the end of VMGEXIT MSR procotol processing
1813  */
1814 TRACE_EVENT(kvm_vmgexit_msr_protocol_exit,
1815         TP_PROTO(unsigned int vcpu_id, u64 ghcb_gpa, int result),
1816         TP_ARGS(vcpu_id, ghcb_gpa, result),
1817
1818         TP_STRUCT__entry(
1819                 __field(unsigned int, vcpu_id)
1820                 __field(u64, ghcb_gpa)
1821                 __field(int, result)
1822         ),
1823
1824         TP_fast_assign(
1825                 __entry->vcpu_id  = vcpu_id;
1826                 __entry->ghcb_gpa = ghcb_gpa;
1827                 __entry->result   = result;
1828         ),
1829
1830         TP_printk("vcpu %u, ghcb_gpa %016llx, result %d",
1831                   __entry->vcpu_id, __entry->ghcb_gpa, __entry->result)
1832 );
1833
1834 #endif /* _TRACE_KVM_H */
1835
1836 #undef TRACE_INCLUDE_PATH
1837 #define TRACE_INCLUDE_PATH ../../arch/x86/kvm
1838 #undef TRACE_INCLUDE_FILE
1839 #define TRACE_INCLUDE_FILE trace
1840
1841 /* This part must be outside protection */
1842 #include <trace/define_trace.h>