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