drivers/staging/lttng/instrumentation/events/lttng-module/arch/x86/kvm/trace.h

   1 #if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
   2 #define _TRACE_KVM_H
   3
   4 #include <linux/tracepoint.h>
   5 #include <asm/vmx.h>
   6 #include <asm/svm.h>
   7 #include <asm/clocksource.h>
   8 #include <linux/version.h>
   9 #include <../arch/x86/kvm/lapic.h>
  10 #include <../arch/x86/kvm/kvm_cache_regs.h>
  11
  12 #undef TRACE_SYSTEM
  13 #define TRACE_SYSTEM kvm
  14
  15 /*
  16  * Tracepoint for guest mode entry.
  17  */
  18 TRACE_EVENT(kvm_entry,
  19         TP_PROTO(unsigned int vcpu_id),
  20         TP_ARGS(vcpu_id),
  21
  22         TP_STRUCT__entry(
  23                 __field(        unsigned int,   vcpu_id         )
  24         ),
  25
  26         TP_fast_assign(
  27                 tp_assign(vcpu_id, vcpu_id)
  28         ),
  29
  30         TP_printk("vcpu %u", __entry->vcpu_id)
  31 )
  32
  33 /*
  34  * Tracepoint for hypercall.
  35  */
  36 TRACE_EVENT(kvm_hypercall,
  37         TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1,
  38                  unsigned long a2, unsigned long a3),
  39         TP_ARGS(nr, a0, a1, a2, a3),
  40
  41         TP_STRUCT__entry(
  42                 __field(        unsigned long,  nr              )
  43                 __field(        unsigned long,  a0              )
  44                 __field(        unsigned long,  a1              )
  45                 __field(        unsigned long,  a2              )
  46                 __field(        unsigned long,  a3              )
  47         ),
  48
  49         TP_fast_assign(
  50                 tp_assign(nr, nr)
  51                 tp_assign(a0, a0)
  52                 tp_assign(a1, a1)
  53                 tp_assign(a2, a2)
  54                 tp_assign(a3, a3)
  55         ),
  56
  57         TP_printk("nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx",
  58                  __entry->nr, __entry->a0, __entry->a1,  __entry->a2,
  59                  __entry->a3)
  60 )
  61
  62 /*
  63  * Tracepoint for hypercall.
  64  */
  65 TRACE_EVENT(kvm_hv_hypercall,
  66         TP_PROTO(__u16 code, bool fast, __u16 rep_cnt, __u16 rep_idx,
  67                  __u64 ingpa, __u64 outgpa),
  68         TP_ARGS(code, fast, rep_cnt, rep_idx, ingpa, outgpa),
  69
  70         TP_STRUCT__entry(
  71                 __field(        __u16,          rep_cnt         )
  72                 __field(        __u16,          rep_idx         )
  73                 __field(        __u64,          ingpa           )
  74                 __field(        __u64,          outgpa          )
  75                 __field(        __u16,          code            )
  76                 __field(        bool,           fast            )
  77         ),
  78
  79         TP_fast_assign(
  80                 tp_assign(rep_cnt, rep_cnt)
  81                 tp_assign(rep_idx, rep_idx)
  82                 tp_assign(ingpa, ingpa)
  83                 tp_assign(outgpa, outgpa)
  84                 tp_assign(code, code)
  85                 tp_assign(fast, fast)
  86         ),
  87
  88         TP_printk("code 0x%x %s cnt 0x%x idx 0x%x in 0x%llx out 0x%llx",
  89                   __entry->code, __entry->fast ? "fast" : "slow",
  90                   __entry->rep_cnt, __entry->rep_idx,  __entry->ingpa,
  91                   __entry->outgpa)
  92 )
  93
  94 /*
  95  * Tracepoint for PIO.
  96  */
  97 TRACE_EVENT(kvm_pio,
  98         TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
  99                  unsigned int count),
 100         TP_ARGS(rw, port, size, count),
 101
 102         TP_STRUCT__entry(
 103                 __field(        unsigned int,   rw              )
 104                 __field(        unsigned int,   port            )
 105                 __field(        unsigned int,   size            )
 106                 __field(        unsigned int,   count           )
 107         ),
 108
 109         TP_fast_assign(
 110                 tp_assign(rw, rw)
 111                 tp_assign(port, port)
 112                 tp_assign(size, size)
 113                 tp_assign(count, count)
 114         ),
 115
 116         TP_printk("pio_%s at 0x%x size %d count %d",
 117                   __entry->rw ? "write" : "read",
 118                   __entry->port, __entry->size, __entry->count)
 119 )
 120
 121 /*
 122  * Tracepoint for cpuid.
 123  */
 124 TRACE_EVENT(kvm_cpuid,
 125         TP_PROTO(unsigned int function, unsigned long rax, unsigned long rbx,
 126                  unsigned long rcx, unsigned long rdx),
 127         TP_ARGS(function, rax, rbx, rcx, rdx),
 128
 129         TP_STRUCT__entry(
 130                 __field(        unsigned int,   function        )
 131                 __field(        unsigned long,  rax             )
 132                 __field(        unsigned long,  rbx             )
 133                 __field(        unsigned long,  rcx             )
 134                 __field(        unsigned long,  rdx             )
 135         ),
 136
 137         TP_fast_assign(
 138                 tp_assign(function, function)
 139                 tp_assign(rax, rax)
 140                 tp_assign(rbx, rbx)
 141                 tp_assign(rcx, rcx)
 142                 tp_assign(rdx, rdx)
 143         ),
 144
 145         TP_printk("func %x rax %lx rbx %lx rcx %lx rdx %lx",
 146                   __entry->function, __entry->rax,
 147                   __entry->rbx, __entry->rcx, __entry->rdx)
 148 )
 149
 150 #define AREG(x) { APIC_##x, "APIC_" #x }
 151
 152 #define kvm_trace_symbol_apic                                               \
 153         AREG(ID), AREG(LVR), AREG(TASKPRI), AREG(ARBPRI), AREG(PROCPRI),    \
 154         AREG(EOI), AREG(RRR), AREG(LDR), AREG(DFR), AREG(SPIV), AREG(ISR),  \
 155         AREG(TMR), AREG(IRR), AREG(ESR), AREG(ICR), AREG(ICR2), AREG(LVTT), \
 156         AREG(LVTTHMR), AREG(LVTPC), AREG(LVT0), AREG(LVT1), AREG(LVTERR),   \
 157         AREG(TMICT), AREG(TMCCT), AREG(TDCR), AREG(SELF_IPI), AREG(EFEAT),  \
 158         AREG(ECTRL)
 159 /*
 160  * Tracepoint for apic access.
 161  */
 162 TRACE_EVENT(kvm_apic,
 163         TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val),
 164         TP_ARGS(rw, reg, val),
 165
 166         TP_STRUCT__entry(
 167                 __field(        unsigned int,   rw              )
 168                 __field(        unsigned int,   reg             )
 169                 __field(        unsigned int,   val             )
 170         ),
 171
 172         TP_fast_assign(
 173                 tp_assign(rw, rw)
 174                 tp_assign(reg, reg)
 175                 tp_assign(val, val)
 176         ),
 177
 178         TP_printk("apic_%s %s = 0x%x",
 179                   __entry->rw ? "write" : "read",
 180                   __print_symbolic(__entry->reg, kvm_trace_symbol_apic),
 181                   __entry->val)
 182 )
 183
 184 #define trace_kvm_apic_read(reg, val)           trace_kvm_apic(0, reg, val)
 185 #define trace_kvm_apic_write(reg, val)          trace_kvm_apic(1, reg, val)
 186
 187 #define KVM_ISA_VMX   1
 188 #define KVM_ISA_SVM   2
 189
 190 /*
 191  * Tracepoint for kvm guest exit:
 192  */
 193 TRACE_EVENT(kvm_exit,
 194         TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa, u64 info1, u64 info2),
 195         TP_ARGS(exit_reason, vcpu, isa, info1, info2),
 196
 197         TP_STRUCT__entry(
 198                 __field(        unsigned int,   exit_reason     )
 199                 __field(        unsigned long,  guest_rip       )
 200                 __field(        u32,            isa             )
 201                 __field(        u64,            info1           )
 202                 __field(        u64,            info2           )
 203         ),
 204
 205         TP_fast_assign(
 206                 tp_assign(exit_reason, exit_reason)
 207                 tp_assign(guest_rip, kvm_rip_read(vcpu))
 208                 tp_assign(isa, isa)
 209     kvm_x86_ops->get_exit_info(vcpu, &info1,
 210               &info2);
 211     tp_assign(info1, info1)
 212     tp_assign(info2, info2)
 213         ),
 214
 215         TP_printk("reason %s rip  info %llx %llx",
 216                  (__entry->isa == KVM_ISA_VMX) ?
 217                  __print_symbolic(__entry->exit_reason, VMX_EXIT_REASONS) :
 218                  __print_symbolic(__entry->exit_reason, SVM_EXIT_REASONS),
 219                 /* __entry->guest_rip,*/ __entry->info1, __entry->info2)
 220 )
 221
 222 /*
 223  * Tracepoint for kvm interrupt injection:
 224  */
 225 TRACE_EVENT(kvm_inj_virq,
 226         TP_PROTO(unsigned int irq),
 227         TP_ARGS(irq),
 228
 229         TP_STRUCT__entry(
 230                 __field(        unsigned int,   irq             )
 231         ),
 232
 233         TP_fast_assign(
 234                 tp_assign(irq, irq)
 235         ),
 236
 237         TP_printk("irq %u", __entry->irq)
 238 )
 239
 240 #define EXS(x) { x##_VECTOR, "#" #x }
 241
 242 #define kvm_trace_sym_exc                                               \
 243         EXS(DE), EXS(DB), EXS(BP), EXS(OF), EXS(BR), EXS(UD), EXS(NM),  \
 244         EXS(DF), EXS(TS), EXS(NP), EXS(SS), EXS(GP), EXS(PF),           \
 245         EXS(MF), EXS(MC)
 246
 247 /*
 248  * Tracepoint for kvm interrupt injection:
 249  */
 250 TRACE_EVENT(kvm_inj_exception,
 251         TP_PROTO(unsigned exception, bool has_error, unsigned error_code),
 252         TP_ARGS(exception, has_error, error_code),
 253
 254         TP_STRUCT__entry(
 255                 __field(        u8,     exception       )
 256                 __field(        u8,     has_error       )
 257                 __field(        u32,    error_code      )
 258         ),
 259
 260         TP_fast_assign(
 261                 tp_assign(exception, exception)
 262                 tp_assign(has_error, has_error)
 263                 tp_assign(error_code, error_code)
 264         ),
 265
 266         TP_printk("%s (0x%x)",
 267                   __print_symbolic(__entry->exception, kvm_trace_sym_exc),
 268                   /* FIXME: don't print error_code if not present */
 269                   __entry->has_error ? __entry->error_code : 0)
 270 )
 271
 272 /*
 273  * Tracepoint for page fault.
 274  */
 275 TRACE_EVENT(kvm_page_fault,
 276         TP_PROTO(unsigned long fault_address, unsigned int error_code),
 277         TP_ARGS(fault_address, error_code),
 278
 279         TP_STRUCT__entry(
 280                 __field(        unsigned long,  fault_address   )
 281                 __field(        unsigned int,   error_code      )
 282         ),
 283
 284         TP_fast_assign(
 285                 tp_assign(fault_address, fault_address)
 286                 tp_assign(error_code, error_code)
 287         ),
 288
 289         TP_printk("address %lx error_code %x",
 290                   __entry->fault_address, __entry->error_code)
 291 )
 292
 293 /*
 294  * Tracepoint for guest MSR access.
 295  */
 296 TRACE_EVENT(kvm_msr,
 297         TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception),
 298         TP_ARGS(write, ecx, data, exception),
 299
 300         TP_STRUCT__entry(
 301                 __field(        unsigned,       write           )
 302                 __field(        u32,            ecx             )
 303                 __field(        u64,            data            )
 304                 __field(        u8,             exception       )
 305         ),
 306
 307         TP_fast_assign(
 308                 tp_assign(write, write)
 309                 tp_assign(ecx, ecx)
 310                 tp_assign(data, data)
 311                 tp_assign(exception, exception)
 312         ),
 313
 314         TP_printk("msr_%s %x = 0x%llx%s",
 315                   __entry->write ? "write" : "read",
 316                   __entry->ecx, __entry->data,
 317                   __entry->exception ? " (#GP)" : "")
 318 )
 319
 320 #define trace_kvm_msr_read(ecx, data)      trace_kvm_msr(0, ecx, data, false)
 321 #define trace_kvm_msr_write(ecx, data)     trace_kvm_msr(1, ecx, data, false)
 322 #define trace_kvm_msr_read_ex(ecx)         trace_kvm_msr(0, ecx, 0, true)
 323 #define trace_kvm_msr_write_ex(ecx, data)  trace_kvm_msr(1, ecx, data, true)
 324
 325 /*
 326  * Tracepoint for guest CR access.
 327  */
 328 TRACE_EVENT(kvm_cr,
 329         TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
 330         TP_ARGS(rw, cr, val),
 331
 332         TP_STRUCT__entry(
 333                 __field(        unsigned int,   rw              )
 334                 __field(        unsigned int,   cr              )
 335                 __field(        unsigned long,  val             )
 336         ),
 337
 338         TP_fast_assign(
 339                 tp_assign(rw, rw)
 340                 tp_assign(cr, cr)
 341                 tp_assign(val, val)
 342         ),
 343
 344         TP_printk("cr_%s %x = 0x%lx",
 345                   __entry->rw ? "write" : "read",
 346                   __entry->cr, __entry->val)
 347 )
 348
 349 #define trace_kvm_cr_read(cr, val)              trace_kvm_cr(0, cr, val)
 350 #define trace_kvm_cr_write(cr, val)             trace_kvm_cr(1, cr, val)
 351
 352 TRACE_EVENT(kvm_pic_set_irq,
 353             TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
 354             TP_ARGS(chip, pin, elcr, imr, coalesced),
 355
 356         TP_STRUCT__entry(
 357                 __field(        __u8,           chip            )
 358                 __field(        __u8,           pin             )
 359                 __field(        __u8,           elcr            )
 360                 __field(        __u8,           imr             )
 361                 __field(        bool,           coalesced       )
 362         ),
 363
 364         TP_fast_assign(
 365                 tp_assign(chip, chip)
 366                 tp_assign(pin, pin)
 367                 tp_assign(elcr, elcr)
 368                 tp_assign(imr, imr)
 369                 tp_assign(coalesced, coalesced)
 370         ),
 371
 372         TP_printk("chip %u pin %u (%s%s)%s",
 373                   __entry->chip, __entry->pin,
 374                   (__entry->elcr & (1 << __entry->pin)) ? "level":"edge",
 375                   (__entry->imr & (1 << __entry->pin)) ? "|masked":"",
 376                   __entry->coalesced ? " (coalesced)" : "")
 377 )
 378
 379 #define kvm_apic_dst_shorthand          \
 380         {0x0, "dst"},                   \
 381         {0x1, "self"},                  \
 382         {0x2, "all"},                   \
 383         {0x3, "all-but-self"}
 384
 385 TRACE_EVENT(kvm_apic_ipi,
 386             TP_PROTO(__u32 icr_low, __u32 dest_id),
 387             TP_ARGS(icr_low, dest_id),
 388
 389         TP_STRUCT__entry(
 390                 __field(        __u32,          icr_low         )
 391                 __field(        __u32,          dest_id         )
 392         ),
 393
 394         TP_fast_assign(
 395                 tp_assign(icr_low, icr_low)
 396                 tp_assign(dest_id, dest_id)
 397         ),
 398
 399         TP_printk("dst %x vec %u (%s|%s|%s|%s|%s)",
 400                   __entry->dest_id, (u8)__entry->icr_low,
 401                   __print_symbolic((__entry->icr_low >> 8 & 0x7),
 402                                    kvm_deliver_mode),
 403                   (__entry->icr_low & (1<<11)) ? "logical" : "physical",
 404                   (__entry->icr_low & (1<<14)) ? "assert" : "de-assert",
 405                   (__entry->icr_low & (1<<15)) ? "level" : "edge",
 406                   __print_symbolic((__entry->icr_low >> 18 & 0x3),
 407                                    kvm_apic_dst_shorthand))
 408 )
 409
 410 TRACE_EVENT(kvm_apic_accept_irq,
 411             TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec, bool coalesced),
 412             TP_ARGS(apicid, dm, tm, vec, coalesced),
 413
 414         TP_STRUCT__entry(
 415                 __field(        __u32,          apicid          )
 416                 __field(        __u16,          dm              )
 417                 __field(        __u8,           tm              )
 418                 __field(        __u8,           vec             )
 419                 __field(        bool,           coalesced       )
 420         ),
 421
 422         TP_fast_assign(
 423                 tp_assign(apicid, apicid)
 424                 tp_assign(dm, dm)
 425                 tp_assign(tm, tm)
 426                 tp_assign(vec, vec)
 427                 tp_assign(coalesced, coalesced)
 428         ),
 429
 430         TP_printk("apicid %x vec %u (%s|%s)%s",
 431                   __entry->apicid, __entry->vec,
 432                   __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
 433                   __entry->tm ? "level" : "edge",
 434                   __entry->coalesced ? " (coalesced)" : "")
 435 )
 436
 437 TRACE_EVENT(kvm_eoi,
 438             TP_PROTO(struct kvm_lapic *apic, int vector),
 439             TP_ARGS(apic, vector),
 440
 441         TP_STRUCT__entry(
 442                 __field(        __u32,          apicid          )
 443                 __field(        int,            vector          )
 444         ),
 445
 446         TP_fast_assign(
 447                 tp_assign(apicid, apic->vcpu->vcpu_id)
 448                 tp_assign(vector, vector)
 449         ),
 450
 451         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
 452 )
 453
 454 TRACE_EVENT(kvm_pv_eoi,
 455             TP_PROTO(struct kvm_lapic *apic, int vector),
 456             TP_ARGS(apic, vector),
 457
 458         TP_STRUCT__entry(
 459                 __field(        __u32,          apicid          )
 460                 __field(        int,            vector          )
 461         ),
 462
 463         TP_fast_assign(
 464                 tp_assign(apicid, apic->vcpu->vcpu_id)
 465                 tp_assign(vector, vector)
 466         ),
 467
 468         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
 469 )
 470
 471 /*
 472  * Tracepoint for nested VMRUN
 473  */
 474 TRACE_EVENT(kvm_nested_vmrun,
 475             TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl,
 476                      __u32 event_inj, bool npt),
 477             TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, npt),
 478
 479         TP_STRUCT__entry(
 480                 __field(        __u64,          rip             )
 481                 __field(        __u64,          vmcb            )
 482                 __field(        __u64,          nested_rip      )
 483                 __field(        __u32,          int_ctl         )
 484                 __field(        __u32,          event_inj       )
 485                 __field(        bool,           npt             )
 486         ),
 487
 488         TP_fast_assign(
 489                 tp_assign(rip, rip)
 490                 tp_assign(vmcb, vmcb)
 491                 tp_assign(nested_rip, nested_rip)
 492                 tp_assign(int_ctl, int_ctl)
 493                 tp_assign(event_inj, event_inj)
 494                 tp_assign(npt, npt)
 495         ),
 496
 497         TP_printk("rip: 0x%016llx vmcb: 0x%016llx nrip: 0x%016llx int_ctl: 0x%08x "
 498                   "event_inj: 0x%08x npt: %s",
 499                 __entry->rip, __entry->vmcb, __entry->nested_rip,
 500                 __entry->int_ctl, __entry->event_inj,
 501                 __entry->npt ? "on" : "off")
 502 )
 503
 504 TRACE_EVENT(kvm_nested_intercepts,
 505             TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions, __u64 intercept),
 506             TP_ARGS(cr_read, cr_write, exceptions, intercept),
 507
 508         TP_STRUCT__entry(
 509                 __field(        __u16,          cr_read         )
 510                 __field(        __u16,          cr_write        )
 511                 __field(        __u32,          exceptions      )
 512                 __field(        __u64,          intercept       )
 513         ),
 514
 515         TP_fast_assign(
 516                 tp_assign(cr_read, cr_read)
 517                 tp_assign(cr_write, cr_write)
 518                 tp_assign(exceptions, exceptions)
 519                 tp_assign(intercept, intercept)
 520         ),
 521
 522         TP_printk("cr_read: %04x cr_write: %04x excp: %08x intercept: %016llx",
 523                 __entry->cr_read, __entry->cr_write, __entry->exceptions,
 524                 __entry->intercept)
 525 )
 526 /*
 527  * Tracepoint for #VMEXIT while nested
 528  */
 529 TRACE_EVENT(kvm_nested_vmexit,
 530             TP_PROTO(__u64 rip, __u32 exit_code,
 531                      __u64 exit_info1, __u64 exit_info2,
 532                      __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
 533             TP_ARGS(rip, exit_code, exit_info1, exit_info2,
 534                     exit_int_info, exit_int_info_err, isa),
 535
 536         TP_STRUCT__entry(
 537                 __field(        __u64,          rip                     )
 538                 __field(        __u32,          exit_code               )
 539                 __field(        __u64,          exit_info1              )
 540                 __field(        __u64,          exit_info2              )
 541                 __field(        __u32,          exit_int_info           )
 542                 __field(        __u32,          exit_int_info_err       )
 543                 __field(        __u32,          isa                     )
 544         ),
 545
 546         TP_fast_assign(
 547                 tp_assign(rip, rip)
 548                 tp_assign(exit_code, exit_code)
 549                 tp_assign(exit_info1, exit_info1)
 550                 tp_assign(exit_info2, exit_info2)
 551                 tp_assign(exit_int_info, exit_int_info)
 552                 tp_assign(exit_int_info_err, exit_int_info_err)
 553                 tp_assign(isa, isa)
 554         ),
 555         TP_printk("rip: 0x%016llx reason: %s ext_inf1: 0x%016llx "
 556                   "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
 557                   __entry->rip,
 558                  (__entry->isa == KVM_ISA_VMX) ?
 559                  __print_symbolic(__entry->exit_code, VMX_EXIT_REASONS) :
 560                  __print_symbolic(__entry->exit_code, SVM_EXIT_REASONS),
 561                   __entry->exit_info1, __entry->exit_info2,
 562                   __entry->exit_int_info, __entry->exit_int_info_err)
 563 )
 564
 565 /*
 566  * Tracepoint for #VMEXIT reinjected to the guest
 567  */
 568 TRACE_EVENT(kvm_nested_vmexit_inject,
 569             TP_PROTO(__u32 exit_code,
 570                      __u64 exit_info1, __u64 exit_info2,
 571                      __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
 572             TP_ARGS(exit_code, exit_info1, exit_info2,
 573                     exit_int_info, exit_int_info_err, isa),
 574
 575         TP_STRUCT__entry(
 576                 __field(        __u32,          exit_code               )
 577                 __field(        __u64,          exit_info1              )
 578                 __field(        __u64,          exit_info2              )
 579                 __field(        __u32,          exit_int_info           )
 580                 __field(        __u32,          exit_int_info_err       )
 581                 __field(        __u32,          isa                     )
 582         ),
 583
 584         TP_fast_assign(
 585                 tp_assign(exit_code, exit_code)
 586                 tp_assign(exit_info1, exit_info1)
 587                 tp_assign(exit_info2, exit_info2)
 588                 tp_assign(exit_int_info, exit_int_info)
 589                 tp_assign(exit_int_info_err, exit_int_info_err)
 590                 tp_assign(isa, isa)
 591         ),
 592
 593         TP_printk("reason: %s ext_inf1: 0x%016llx "
 594                   "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
 595                  (__entry->isa == KVM_ISA_VMX) ?
 596                  __print_symbolic(__entry->exit_code, VMX_EXIT_REASONS) :
 597                  __print_symbolic(__entry->exit_code, SVM_EXIT_REASONS),
 598                 __entry->exit_info1, __entry->exit_info2,
 599                 __entry->exit_int_info, __entry->exit_int_info_err)
 600 )
 601
 602 /*
 603  * Tracepoint for nested #vmexit because of interrupt pending
 604  */
 605 TRACE_EVENT(kvm_nested_intr_vmexit,
 606             TP_PROTO(__u64 rip),
 607             TP_ARGS(rip),
 608
 609         TP_STRUCT__entry(
 610                 __field(        __u64,  rip     )
 611         ),
 612
 613         TP_fast_assign(
 614                 tp_assign(rip,  rip)
 615         ),
 616
 617         TP_printk("rip: 0x%016llx", __entry->rip)
 618 )
 619
 620 /*
 621  * Tracepoint for nested #vmexit because of interrupt pending
 622  */
 623 TRACE_EVENT(kvm_invlpga,
 624             TP_PROTO(__u64 rip, int asid, u64 address),
 625             TP_ARGS(rip, asid, address),
 626
 627         TP_STRUCT__entry(
 628                 __field(        __u64,  rip     )
 629                 __field(        int,    asid    )
 630                 __field(        __u64,  address )
 631         ),
 632
 633         TP_fast_assign(
 634                 tp_assign(rip,  rip)
 635                 tp_assign(asid, asid)
 636                 tp_assign(address,      address)
 637         ),
 638
 639         TP_printk("rip: 0x%016llx asid: %d address: 0x%016llx",
 640                   __entry->rip, __entry->asid, __entry->address)
 641 )
 642
 643 /*
 644  * Tracepoint for nested #vmexit because of interrupt pending
 645  */
 646 TRACE_EVENT(kvm_skinit,
 647             TP_PROTO(__u64 rip, __u32 slb),
 648             TP_ARGS(rip, slb),
 649
 650         TP_STRUCT__entry(
 651                 __field(        __u64,  rip     )
 652                 __field(        __u32,  slb     )
 653         ),
 654
 655         TP_fast_assign(
 656                 tp_assign(rip,  rip)
 657                 tp_assign(slb,  slb)
 658         ),
 659
 660         TP_printk("rip: 0x%016llx slb: 0x%08x",
 661                   __entry->rip, __entry->slb)
 662 )
 663
 664 #define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
 665 #define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
 666 #define KVM_EMUL_INSN_F_CS_D   (1 << 2)
 667 #define KVM_EMUL_INSN_F_CS_L   (1 << 3)
 668
 669 #define kvm_trace_symbol_emul_flags                       \
 670         { 0,                        "real" },             \
 671         { KVM_EMUL_INSN_F_CR0_PE                          \
 672           | KVM_EMUL_INSN_F_EFL_VM, "vm16" },             \
 673         { KVM_EMUL_INSN_F_CR0_PE,   "prot16" },           \
 674         { KVM_EMUL_INSN_F_CR0_PE                          \
 675           | KVM_EMUL_INSN_F_CS_D,   "prot32" },           \
 676         { KVM_EMUL_INSN_F_CR0_PE                          \
 677           | KVM_EMUL_INSN_F_CS_L,   "prot64" }
 678
 679 #define kei_decode_mode(mode) ({                        \
 680         u8 flags = 0xff;                                \
 681         switch (mode) {                                 \
 682         case X86EMUL_MODE_REAL:                         \
 683                 flags = 0;                              \
 684                 break;                                  \
 685         case X86EMUL_MODE_VM86:                         \
 686                 flags = KVM_EMUL_INSN_F_EFL_VM;         \
 687                 break;                                  \
 688         case X86EMUL_MODE_PROT16:                       \
 689                 flags = KVM_EMUL_INSN_F_CR0_PE;         \
 690                 break;                                  \
 691         case X86EMUL_MODE_PROT32:                       \
 692                 flags = KVM_EMUL_INSN_F_CR0_PE          \
 693                         | KVM_EMUL_INSN_F_CS_D;         \
 694                 break;                                  \
 695         case X86EMUL_MODE_PROT64:                       \
 696                 flags = KVM_EMUL_INSN_F_CR0_PE          \
 697                         | KVM_EMUL_INSN_F_CS_L;         \
 698                 break;                                  \
 699         }                                               \
 700         flags;                                          \
 701         })
 702
 703 TRACE_EVENT(kvm_emulate_insn,
 704         TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed),
 705         TP_ARGS(vcpu, failed),
 706
 707         TP_STRUCT__entry(
 708                 __field(    __u64, rip                       )
 709                 __field(    __u32, csbase                    )
 710                 __field(    __u8,  len                       )
 711                 __array(    __u8,  insn,    15               )
 712                 __field(    __u8,  flags                     )
 713                 __field(    __u8,  failed                    )
 714                 ),
 715
 716         TP_fast_assign(
 717                 tp_assign(rip, vcpu->arch.emulate_ctxt.fetch.start)
 718           tp_assign(csbase, kvm_x86_ops->get_segment_base(vcpu, VCPU_SREG_CS))
 719                 tp_assign(len, vcpu->arch.emulate_ctxt._eip
 720                                - vcpu->arch.emulate_ctxt.fetch.start)
 721                 tp_memcpy(insn,
 722                        vcpu->arch.emulate_ctxt.fetch.data,
 723                        15)
 724                 tp_assign(flags, kei_decode_mode(vcpu->arch.emulate_ctxt.mode))
 725                 tp_assign(failed, failed)
 726                 ),
 727
 728         TP_printk("%x:%llx:%s (%s)%s",
 729                   __entry->csbase, __entry->rip,
 730                   __print_hex(__entry->insn, __entry->len),
 731                   __print_symbolic(__entry->flags,
 732                                    kvm_trace_symbol_emul_flags),
 733                   __entry->failed ? " failed" : ""
 734                 )
 735         )
 736
 737 #define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0)
 738 #define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1)
 739
 740 TRACE_EVENT(
 741         vcpu_match_mmio,
 742         TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match),
 743         TP_ARGS(gva, gpa, write, gpa_match),
 744
 745         TP_STRUCT__entry(
 746                 __field(gva_t, gva)
 747                 __field(gpa_t, gpa)
 748                 __field(bool, write)
 749                 __field(bool, gpa_match)
 750                 ),
 751
 752         TP_fast_assign(
 753                 tp_assign(gva, gva)
 754                 tp_assign(gpa, gpa)
 755                 tp_assign(write, write)
 756                 tp_assign(gpa_match, gpa_match)
 757                 ),
 758
 759         TP_printk("gva %#lx gpa %#llx %s %s", __entry->gva, __entry->gpa,
 760                   __entry->write ? "Write" : "Read",
 761                   __entry->gpa_match ? "GPA" : "GVA")
 762 )
 763
 764 #ifdef CONFIG_X86_64
 765
 766 #define host_clocks                                     \
 767         {VCLOCK_NONE, "none"},                          \
 768         {VCLOCK_TSC,  "tsc"},                           \
 769         {VCLOCK_HPET, "hpet"}                           \
 770
 771 TRACE_EVENT(kvm_update_master_clock,
 772         TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched),
 773         TP_ARGS(use_master_clock, host_clock, offset_matched),
 774
 775         TP_STRUCT__entry(
 776                 __field(                bool,   use_master_clock        )
 777                 __field(        unsigned int,   host_clock              )
 778                 __field(                bool,   offset_matched          )
 779         ),
 780
 781         TP_fast_assign(
 782                 tp_assign(use_master_clock, use_master_clock)
 783                 tp_assign(host_clock, host_clock)
 784                 tp_assign(offset_matched, offset_matched)
 785         ),
 786
 787         TP_printk("masterclock %d hostclock %s offsetmatched %u",
 788                   __entry->use_master_clock,
 789                   __print_symbolic(__entry->host_clock, host_clocks),
 790                   __entry->offset_matched)
 791 )
 792
 793 TRACE_EVENT(kvm_track_tsc,
 794         TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched,
 795                  unsigned int online_vcpus, bool use_master_clock,
 796                  unsigned int host_clock),
 797         TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock,
 798                 host_clock),
 799
 800         TP_STRUCT__entry(
 801                 __field(        unsigned int,   vcpu_id                 )
 802                 __field(        unsigned int,   nr_vcpus_matched_tsc    )
 803                 __field(        unsigned int,   online_vcpus            )
 804                 __field(        bool,           use_master_clock        )
 805                 __field(        unsigned int,   host_clock              )
 806         ),
 807
 808         TP_fast_assign(
 809                 tp_assign(vcpu_id, vcpu_id)
 810                 tp_assign(nr_vcpus_matched_tsc, nr_matched)
 811                 tp_assign(online_vcpus, online_vcpus)
 812                 tp_assign(use_master_clock, use_master_clock)
 813                 tp_assign(host_clock, host_clock)
 814         ),
 815
 816         TP_printk("vcpu_id %u masterclock %u offsetmatched %u nr_online %u"
 817                   " hostclock %s",
 818                   __entry->vcpu_id, __entry->use_master_clock,
 819                   __entry->nr_vcpus_matched_tsc, __entry->online_vcpus,
 820                   __print_symbolic(__entry->host_clock, host_clocks))
 821 )
 822
 823 #endif /* CONFIG_X86_64 */
 824
 825 #endif /* _TRACE_KVM_H */
 826
 827 #undef TRACE_INCLUDE_PATH
 828 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module/arch/x86/kvm
 829 #undef TRACE_INCLUDE_FILE
 830 #define TRACE_INCLUDE_FILE trace
 831
 832 /* This part must be outside protection */
 833 #include "../../../../../../probes/define_trace.h"