0001
0002 #if !defined(_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
0003 #define _TRACE_KVM_MAIN_H
0004
0005 #include <linux/tracepoint.h>
0006
0007 #undef TRACE_SYSTEM
0008 #define TRACE_SYSTEM kvm
0009
0010 #define ERSN(x) { KVM_EXIT_##x, "KVM_EXIT_" #x }
0011
0012 #define kvm_trace_exit_reason \
0013 ERSN(UNKNOWN), ERSN(EXCEPTION), ERSN(IO), ERSN(HYPERCALL), \
0014 ERSN(DEBUG), ERSN(HLT), ERSN(MMIO), ERSN(IRQ_WINDOW_OPEN), \
0015 ERSN(SHUTDOWN), ERSN(FAIL_ENTRY), ERSN(INTR), ERSN(SET_TPR), \
0016 ERSN(TPR_ACCESS), ERSN(S390_SIEIC), ERSN(S390_RESET), ERSN(DCR),\
0017 ERSN(NMI), ERSN(INTERNAL_ERROR), ERSN(OSI), ERSN(PAPR_HCALL), \
0018 ERSN(S390_UCONTROL), ERSN(WATCHDOG), ERSN(S390_TSCH), ERSN(EPR),\
0019 ERSN(SYSTEM_EVENT), ERSN(S390_STSI), ERSN(IOAPIC_EOI), \
0020 ERSN(HYPERV), ERSN(ARM_NISV), ERSN(X86_RDMSR), ERSN(X86_WRMSR)
0021
0022 TRACE_EVENT(kvm_userspace_exit,
0023 TP_PROTO(__u32 reason, int errno),
0024 TP_ARGS(reason, errno),
0025
0026 TP_STRUCT__entry(
0027 __field( __u32, reason )
0028 __field( int, errno )
0029 ),
0030
0031 TP_fast_assign(
0032 __entry->reason = reason;
0033 __entry->errno = errno;
0034 ),
0035
0036 TP_printk("reason %s (%d)",
0037 __entry->errno < 0 ?
0038 (__entry->errno == -EINTR ? "restart" : "error") :
0039 __print_symbolic(__entry->reason, kvm_trace_exit_reason),
0040 __entry->errno < 0 ? -__entry->errno : __entry->reason)
0041 );
0042
0043 TRACE_EVENT(kvm_vcpu_wakeup,
0044 TP_PROTO(__u64 ns, bool waited, bool valid),
0045 TP_ARGS(ns, waited, valid),
0046
0047 TP_STRUCT__entry(
0048 __field( __u64, ns )
0049 __field( bool, waited )
0050 __field( bool, valid )
0051 ),
0052
0053 TP_fast_assign(
0054 __entry->ns = ns;
0055 __entry->waited = waited;
0056 __entry->valid = valid;
0057 ),
0058
0059 TP_printk("%s time %lld ns, polling %s",
0060 __entry->waited ? "wait" : "poll",
0061 __entry->ns,
0062 __entry->valid ? "valid" : "invalid")
0063 );
0064
0065 #if defined(CONFIG_HAVE_KVM_IRQFD)
0066 TRACE_EVENT(kvm_set_irq,
0067 TP_PROTO(unsigned int gsi, int level, int irq_source_id),
0068 TP_ARGS(gsi, level, irq_source_id),
0069
0070 TP_STRUCT__entry(
0071 __field( unsigned int, gsi )
0072 __field( int, level )
0073 __field( int, irq_source_id )
0074 ),
0075
0076 TP_fast_assign(
0077 __entry->gsi = gsi;
0078 __entry->level = level;
0079 __entry->irq_source_id = irq_source_id;
0080 ),
0081
0082 TP_printk("gsi %u level %d source %d",
0083 __entry->gsi, __entry->level, __entry->irq_source_id)
0084 );
0085 #endif
0086
0087 #if defined(__KVM_HAVE_IOAPIC)
0088 #define kvm_deliver_mode \
0089 {0x0, "Fixed"}, \
0090 {0x1, "LowPrio"}, \
0091 {0x2, "SMI"}, \
0092 {0x3, "Res3"}, \
0093 {0x4, "NMI"}, \
0094 {0x5, "INIT"}, \
0095 {0x6, "SIPI"}, \
0096 {0x7, "ExtINT"}
0097
0098 TRACE_EVENT(kvm_ioapic_set_irq,
0099 TP_PROTO(__u64 e, int pin, bool coalesced),
0100 TP_ARGS(e, pin, coalesced),
0101
0102 TP_STRUCT__entry(
0103 __field( __u64, e )
0104 __field( int, pin )
0105 __field( bool, coalesced )
0106 ),
0107
0108 TP_fast_assign(
0109 __entry->e = e;
0110 __entry->pin = pin;
0111 __entry->coalesced = coalesced;
0112 ),
0113
0114 TP_printk("pin %u dst %x vec %u (%s|%s|%s%s)%s",
0115 __entry->pin, (u8)(__entry->e >> 56), (u8)__entry->e,
0116 __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
0117 (__entry->e & (1<<11)) ? "logical" : "physical",
0118 (__entry->e & (1<<15)) ? "level" : "edge",
0119 (__entry->e & (1<<16)) ? "|masked" : "",
0120 __entry->coalesced ? " (coalesced)" : "")
0121 );
0122
0123 TRACE_EVENT(kvm_ioapic_delayed_eoi_inj,
0124 TP_PROTO(__u64 e),
0125 TP_ARGS(e),
0126
0127 TP_STRUCT__entry(
0128 __field( __u64, e )
0129 ),
0130
0131 TP_fast_assign(
0132 __entry->e = e;
0133 ),
0134
0135 TP_printk("dst %x vec %u (%s|%s|%s%s)",
0136 (u8)(__entry->e >> 56), (u8)__entry->e,
0137 __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
0138 (__entry->e & (1<<11)) ? "logical" : "physical",
0139 (__entry->e & (1<<15)) ? "level" : "edge",
0140 (__entry->e & (1<<16)) ? "|masked" : "")
0141 );
0142
0143 TRACE_EVENT(kvm_msi_set_irq,
0144 TP_PROTO(__u64 address, __u64 data),
0145 TP_ARGS(address, data),
0146
0147 TP_STRUCT__entry(
0148 __field( __u64, address )
0149 __field( __u64, data )
0150 ),
0151
0152 TP_fast_assign(
0153 __entry->address = address;
0154 __entry->data = data;
0155 ),
0156
0157 TP_printk("dst %llx vec %u (%s|%s|%s%s)",
0158 (u8)(__entry->address >> 12) | ((__entry->address >> 32) & 0xffffff00),
0159 (u8)__entry->data,
0160 __print_symbolic((__entry->data >> 8 & 0x7), kvm_deliver_mode),
0161 (__entry->address & (1<<2)) ? "logical" : "physical",
0162 (__entry->data & (1<<15)) ? "level" : "edge",
0163 (__entry->address & (1<<3)) ? "|rh" : "")
0164 );
0165
0166 #define kvm_irqchips \
0167 {KVM_IRQCHIP_PIC_MASTER, "PIC master"}, \
0168 {KVM_IRQCHIP_PIC_SLAVE, "PIC slave"}, \
0169 {KVM_IRQCHIP_IOAPIC, "IOAPIC"}
0170
0171 #endif
0172
0173 #if defined(CONFIG_HAVE_KVM_IRQFD)
0174
0175 #ifdef kvm_irqchips
0176 #define kvm_ack_irq_string "irqchip %s pin %u"
0177 #define kvm_ack_irq_parm __print_symbolic(__entry->irqchip, kvm_irqchips), __entry->pin
0178 #else
0179 #define kvm_ack_irq_string "irqchip %d pin %u"
0180 #define kvm_ack_irq_parm __entry->irqchip, __entry->pin
0181 #endif
0182
0183 TRACE_EVENT(kvm_ack_irq,
0184 TP_PROTO(unsigned int irqchip, unsigned int pin),
0185 TP_ARGS(irqchip, pin),
0186
0187 TP_STRUCT__entry(
0188 __field( unsigned int, irqchip )
0189 __field( unsigned int, pin )
0190 ),
0191
0192 TP_fast_assign(
0193 __entry->irqchip = irqchip;
0194 __entry->pin = pin;
0195 ),
0196
0197 TP_printk(kvm_ack_irq_string, kvm_ack_irq_parm)
0198 );
0199
0200 #endif
0201
0202
0203
0204 #define KVM_TRACE_MMIO_READ_UNSATISFIED 0
0205 #define KVM_TRACE_MMIO_READ 1
0206 #define KVM_TRACE_MMIO_WRITE 2
0207
0208 #define kvm_trace_symbol_mmio \
0209 { KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \
0210 { KVM_TRACE_MMIO_READ, "read" }, \
0211 { KVM_TRACE_MMIO_WRITE, "write" }
0212
0213 TRACE_EVENT(kvm_mmio,
0214 TP_PROTO(int type, int len, u64 gpa, void *val),
0215 TP_ARGS(type, len, gpa, val),
0216
0217 TP_STRUCT__entry(
0218 __field( u32, type )
0219 __field( u32, len )
0220 __field( u64, gpa )
0221 __field( u64, val )
0222 ),
0223
0224 TP_fast_assign(
0225 __entry->type = type;
0226 __entry->len = len;
0227 __entry->gpa = gpa;
0228 __entry->val = 0;
0229 if (val)
0230 memcpy(&__entry->val, val,
0231 min_t(u32, sizeof(__entry->val), len));
0232 ),
0233
0234 TP_printk("mmio %s len %u gpa 0x%llx val 0x%llx",
0235 __print_symbolic(__entry->type, kvm_trace_symbol_mmio),
0236 __entry->len, __entry->gpa, __entry->val)
0237 );
0238
0239 #define kvm_fpu_load_symbol \
0240 {0, "unload"}, \
0241 {1, "load"}
0242
0243 TRACE_EVENT(kvm_fpu,
0244 TP_PROTO(int load),
0245 TP_ARGS(load),
0246
0247 TP_STRUCT__entry(
0248 __field( u32, load )
0249 ),
0250
0251 TP_fast_assign(
0252 __entry->load = load;
0253 ),
0254
0255 TP_printk("%s", __print_symbolic(__entry->load, kvm_fpu_load_symbol))
0256 );
0257
0258 #ifdef CONFIG_KVM_ASYNC_PF
0259 DECLARE_EVENT_CLASS(kvm_async_get_page_class,
0260
0261 TP_PROTO(u64 gva, u64 gfn),
0262
0263 TP_ARGS(gva, gfn),
0264
0265 TP_STRUCT__entry(
0266 __field(__u64, gva)
0267 __field(u64, gfn)
0268 ),
0269
0270 TP_fast_assign(
0271 __entry->gva = gva;
0272 __entry->gfn = gfn;
0273 ),
0274
0275 TP_printk("gva = %#llx, gfn = %#llx", __entry->gva, __entry->gfn)
0276 );
0277
0278 DEFINE_EVENT(kvm_async_get_page_class, kvm_try_async_get_page,
0279
0280 TP_PROTO(u64 gva, u64 gfn),
0281
0282 TP_ARGS(gva, gfn)
0283 );
0284
0285 DEFINE_EVENT(kvm_async_get_page_class, kvm_async_pf_repeated_fault,
0286
0287 TP_PROTO(u64 gva, u64 gfn),
0288
0289 TP_ARGS(gva, gfn)
0290 );
0291
0292 DECLARE_EVENT_CLASS(kvm_async_pf_nopresent_ready,
0293
0294 TP_PROTO(u64 token, u64 gva),
0295
0296 TP_ARGS(token, gva),
0297
0298 TP_STRUCT__entry(
0299 __field(__u64, token)
0300 __field(__u64, gva)
0301 ),
0302
0303 TP_fast_assign(
0304 __entry->token = token;
0305 __entry->gva = gva;
0306 ),
0307
0308 TP_printk("token %#llx gva %#llx", __entry->token, __entry->gva)
0309
0310 );
0311
0312 DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,
0313
0314 TP_PROTO(u64 token, u64 gva),
0315
0316 TP_ARGS(token, gva)
0317 );
0318
0319 DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,
0320
0321 TP_PROTO(u64 token, u64 gva),
0322
0323 TP_ARGS(token, gva)
0324 );
0325
0326 TRACE_EVENT(
0327 kvm_async_pf_completed,
0328 TP_PROTO(unsigned long address, u64 gva),
0329 TP_ARGS(address, gva),
0330
0331 TP_STRUCT__entry(
0332 __field(unsigned long, address)
0333 __field(u64, gva)
0334 ),
0335
0336 TP_fast_assign(
0337 __entry->address = address;
0338 __entry->gva = gva;
0339 ),
0340
0341 TP_printk("gva %#llx address %#lx", __entry->gva,
0342 __entry->address)
0343 );
0344
0345 #endif
0346
0347 TRACE_EVENT(kvm_halt_poll_ns,
0348 TP_PROTO(bool grow, unsigned int vcpu_id, unsigned int new,
0349 unsigned int old),
0350 TP_ARGS(grow, vcpu_id, new, old),
0351
0352 TP_STRUCT__entry(
0353 __field(bool, grow)
0354 __field(unsigned int, vcpu_id)
0355 __field(unsigned int, new)
0356 __field(unsigned int, old)
0357 ),
0358
0359 TP_fast_assign(
0360 __entry->grow = grow;
0361 __entry->vcpu_id = vcpu_id;
0362 __entry->new = new;
0363 __entry->old = old;
0364 ),
0365
0366 TP_printk("vcpu %u: halt_poll_ns %u (%s %u)",
0367 __entry->vcpu_id,
0368 __entry->new,
0369 __entry->grow ? "grow" : "shrink",
0370 __entry->old)
0371 );
0372
0373 #define trace_kvm_halt_poll_ns_grow(vcpu_id, new, old) \
0374 trace_kvm_halt_poll_ns(true, vcpu_id, new, old)
0375 #define trace_kvm_halt_poll_ns_shrink(vcpu_id, new, old) \
0376 trace_kvm_halt_poll_ns(false, vcpu_id, new, old)
0377
0378 TRACE_EVENT(kvm_dirty_ring_push,
0379 TP_PROTO(struct kvm_dirty_ring *ring, u32 slot, u64 offset),
0380 TP_ARGS(ring, slot, offset),
0381
0382 TP_STRUCT__entry(
0383 __field(int, index)
0384 __field(u32, dirty_index)
0385 __field(u32, reset_index)
0386 __field(u32, slot)
0387 __field(u64, offset)
0388 ),
0389
0390 TP_fast_assign(
0391 __entry->index = ring->index;
0392 __entry->dirty_index = ring->dirty_index;
0393 __entry->reset_index = ring->reset_index;
0394 __entry->slot = slot;
0395 __entry->offset = offset;
0396 ),
0397
0398 TP_printk("ring %d: dirty 0x%x reset 0x%x "
0399 "slot %u offset 0x%llx (used %u)",
0400 __entry->index, __entry->dirty_index,
0401 __entry->reset_index, __entry->slot, __entry->offset,
0402 __entry->dirty_index - __entry->reset_index)
0403 );
0404
0405 TRACE_EVENT(kvm_dirty_ring_reset,
0406 TP_PROTO(struct kvm_dirty_ring *ring),
0407 TP_ARGS(ring),
0408
0409 TP_STRUCT__entry(
0410 __field(int, index)
0411 __field(u32, dirty_index)
0412 __field(u32, reset_index)
0413 ),
0414
0415 TP_fast_assign(
0416 __entry->index = ring->index;
0417 __entry->dirty_index = ring->dirty_index;
0418 __entry->reset_index = ring->reset_index;
0419 ),
0420
0421 TP_printk("ring %d: dirty 0x%x reset 0x%x (used %u)",
0422 __entry->index, __entry->dirty_index, __entry->reset_index,
0423 __entry->dirty_index - __entry->reset_index)
0424 );
0425
0426 TRACE_EVENT(kvm_dirty_ring_exit,
0427 TP_PROTO(struct kvm_vcpu *vcpu),
0428 TP_ARGS(vcpu),
0429
0430 TP_STRUCT__entry(
0431 __field(int, vcpu_id)
0432 ),
0433
0434 TP_fast_assign(
0435 __entry->vcpu_id = vcpu->vcpu_id;
0436 ),
0437
0438 TP_printk("vcpu %d", __entry->vcpu_id)
0439 );
0440
0441 TRACE_EVENT(kvm_unmap_hva_range,
0442 TP_PROTO(unsigned long start, unsigned long end),
0443 TP_ARGS(start, end),
0444
0445 TP_STRUCT__entry(
0446 __field( unsigned long, start )
0447 __field( unsigned long, end )
0448 ),
0449
0450 TP_fast_assign(
0451 __entry->start = start;
0452 __entry->end = end;
0453 ),
0454
0455 TP_printk("mmu notifier unmap range: %#016lx -- %#016lx",
0456 __entry->start, __entry->end)
0457 );
0458
0459 TRACE_EVENT(kvm_set_spte_hva,
0460 TP_PROTO(unsigned long hva),
0461 TP_ARGS(hva),
0462
0463 TP_STRUCT__entry(
0464 __field( unsigned long, hva )
0465 ),
0466
0467 TP_fast_assign(
0468 __entry->hva = hva;
0469 ),
0470
0471 TP_printk("mmu notifier set pte hva: %#016lx", __entry->hva)
0472 );
0473
0474 TRACE_EVENT(kvm_age_hva,
0475 TP_PROTO(unsigned long start, unsigned long end),
0476 TP_ARGS(start, end),
0477
0478 TP_STRUCT__entry(
0479 __field( unsigned long, start )
0480 __field( unsigned long, end )
0481 ),
0482
0483 TP_fast_assign(
0484 __entry->start = start;
0485 __entry->end = end;
0486 ),
0487
0488 TP_printk("mmu notifier age hva: %#016lx -- %#016lx",
0489 __entry->start, __entry->end)
0490 );
0491
0492 TRACE_EVENT(kvm_test_age_hva,
0493 TP_PROTO(unsigned long hva),
0494 TP_ARGS(hva),
0495
0496 TP_STRUCT__entry(
0497 __field( unsigned long, hva )
0498 ),
0499
0500 TP_fast_assign(
0501 __entry->hva = hva;
0502 ),
0503
0504 TP_printk("mmu notifier test age hva: %#016lx", __entry->hva)
0505 );
0506
0507 #endif
0508
0509
0510 #include <trace/define_trace.h>
