~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/kvm/trace.h

Version: ~ [ linux-4.17-rc2 ] ~ [ linux-4.16.4 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.36 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.96 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.129 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.51 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.106 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.56 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.101 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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(unsigned int vcpu_id),
 19         TP_ARGS(vcpu_id),
 20 
 21         TP_STRUCT__entry(
 22                 __field(        unsigned int,   vcpu_id         )
 23         ),
 24 
 25         TP_fast_assign(
 26                 __entry->vcpu_id        = vcpu_id;
 27         ),
 28 
 29         TP_printk("vcpu %u", __entry->vcpu_id)
 30 );
 31 
 32 /*
 33  * Tracepoint for hypercall.
 34  */
 35 TRACE_EVENT(kvm_hypercall,
 36         TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1,
 37                  unsigned long a2, unsigned long a3),
 38         TP_ARGS(nr, a0, a1, a2, a3),
 39 
 40         TP_STRUCT__entry(
 41                 __field(        unsigned long,  nr              )
 42                 __field(        unsigned long,  a0              )
 43                 __field(        unsigned long,  a1              )
 44                 __field(        unsigned long,  a2              )
 45                 __field(        unsigned long,  a3              )
 46         ),
 47 
 48         TP_fast_assign(
 49                 __entry->nr             = nr;
 50                 __entry->a0             = a0;
 51                 __entry->a1             = a1;
 52                 __entry->a2             = a2;
 53                 __entry->a3             = a3;
 54         ),
 55 
 56         TP_printk("nr 0x%lx a0 0x%lx a1 0x%lx a2 0x%lx a3 0x%lx",
 57                  __entry->nr, __entry->a0, __entry->a1,  __entry->a2,
 58                  __entry->a3)
 59 );
 60 
 61 /*
 62  * Tracepoint for hypercall.
 63  */
 64 TRACE_EVENT(kvm_hv_hypercall,
 65         TP_PROTO(__u16 code, bool fast, __u16 rep_cnt, __u16 rep_idx,
 66                  __u64 ingpa, __u64 outgpa),
 67         TP_ARGS(code, fast, rep_cnt, rep_idx, ingpa, outgpa),
 68 
 69         TP_STRUCT__entry(
 70                 __field(        __u16,          rep_cnt         )
 71                 __field(        __u16,          rep_idx         )
 72                 __field(        __u64,          ingpa           )
 73                 __field(        __u64,          outgpa          )
 74                 __field(        __u16,          code            )
 75                 __field(        bool,           fast            )
 76         ),
 77 
 78         TP_fast_assign(
 79                 __entry->rep_cnt        = rep_cnt;
 80                 __entry->rep_idx        = rep_idx;
 81                 __entry->ingpa          = ingpa;
 82                 __entry->outgpa         = outgpa;
 83                 __entry->code           = code;
 84                 __entry->fast           = fast;
 85         ),
 86 
 87         TP_printk("code 0x%x %s cnt 0x%x idx 0x%x in 0x%llx out 0x%llx",
 88                   __entry->code, __entry->fast ? "fast" : "slow",
 89                   __entry->rep_cnt, __entry->rep_idx,  __entry->ingpa,
 90                   __entry->outgpa)
 91 );
 92 
 93 /*
 94  * Tracepoint for PIO.
 95  */
 96 
 97 #define KVM_PIO_IN   0
 98 #define KVM_PIO_OUT  1
 99 
100 TRACE_EVENT(kvm_pio,
101         TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
102                  unsigned int count, void *data),
103         TP_ARGS(rw, port, size, count, data),
104 
105         TP_STRUCT__entry(
106                 __field(        unsigned int,   rw              )
107                 __field(        unsigned int,   port            )
108                 __field(        unsigned int,   size            )
109                 __field(        unsigned int,   count           )
110                 __field(        unsigned int,   val             )
111         ),
112 
113         TP_fast_assign(
114                 __entry->rw             = rw;
115                 __entry->port           = port;
116                 __entry->size           = size;
117                 __entry->count          = count;
118                 if (size == 1)
119                         __entry->val    = *(unsigned char *)data;
120                 else if (size == 2)
121                         __entry->val    = *(unsigned short *)data;
122                 else
123                         __entry->val    = *(unsigned int *)data;
124         ),
125 
126         TP_printk("pio_%s at 0x%x size %d count %d val 0x%x %s",
127                   __entry->rw ? "write" : "read",
128                   __entry->port, __entry->size, __entry->count, __entry->val,
129                   __entry->count > 1 ? "(...)" : "")
130 );
131 
132 /*
133  * Tracepoint for fast mmio.
134  */
135 TRACE_EVENT(kvm_fast_mmio,
136         TP_PROTO(u64 gpa),
137         TP_ARGS(gpa),
138 
139         TP_STRUCT__entry(
140                 __field(u64,    gpa)
141         ),
142 
143         TP_fast_assign(
144                 __entry->gpa            = gpa;
145         ),
146 
147         TP_printk("fast mmio at gpa 0x%llx", __entry->gpa)
148 );
149 
150 /*
151  * Tracepoint for cpuid.
152  */
153 TRACE_EVENT(kvm_cpuid,
154         TP_PROTO(unsigned int function, unsigned long rax, unsigned long rbx,
155                  unsigned long rcx, unsigned long rdx, bool found),
156         TP_ARGS(function, rax, rbx, rcx, rdx, found),
157 
158         TP_STRUCT__entry(
159                 __field(        unsigned int,   function        )
160                 __field(        unsigned long,  rax             )
161                 __field(        unsigned long,  rbx             )
162                 __field(        unsigned long,  rcx             )
163                 __field(        unsigned long,  rdx             )
164                 __field(        bool,           found           )
165         ),
166 
167         TP_fast_assign(
168                 __entry->function       = function;
169                 __entry->rax            = rax;
170                 __entry->rbx            = rbx;
171                 __entry->rcx            = rcx;
172                 __entry->rdx            = rdx;
173                 __entry->found          = found;
174         ),
175 
176         TP_printk("func %x rax %lx rbx %lx rcx %lx rdx %lx, cpuid entry %s",
177                   __entry->function, __entry->rax,
178                   __entry->rbx, __entry->rcx, __entry->rdx,
179                   __entry->found ? "found" : "not found")
180 );
181 
182 #define AREG(x) { APIC_##x, "APIC_" #x }
183 
184 #define kvm_trace_symbol_apic                                               \
185         AREG(ID), AREG(LVR), AREG(TASKPRI), AREG(ARBPRI), AREG(PROCPRI),    \
186         AREG(EOI), AREG(RRR), AREG(LDR), AREG(DFR), AREG(SPIV), AREG(ISR),  \
187         AREG(TMR), AREG(IRR), AREG(ESR), AREG(ICR), AREG(ICR2), AREG(LVTT), \
188         AREG(LVTTHMR), AREG(LVTPC), AREG(LVT0), AREG(LVT1), AREG(LVTERR),   \
189         AREG(TMICT), AREG(TMCCT), AREG(TDCR), AREG(SELF_IPI), AREG(EFEAT),  \
190         AREG(ECTRL)
191 /*
192  * Tracepoint for apic access.
193  */
194 TRACE_EVENT(kvm_apic,
195         TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val),
196         TP_ARGS(rw, reg, val),
197 
198         TP_STRUCT__entry(
199                 __field(        unsigned int,   rw              )
200                 __field(        unsigned int,   reg             )
201                 __field(        unsigned int,   val             )
202         ),
203 
204         TP_fast_assign(
205                 __entry->rw             = rw;
206                 __entry->reg            = reg;
207                 __entry->val            = val;
208         ),
209 
210         TP_printk("apic_%s %s = 0x%x",
211                   __entry->rw ? "write" : "read",
212                   __print_symbolic(__entry->reg, kvm_trace_symbol_apic),
213                   __entry->val)
214 );
215 
216 #define trace_kvm_apic_read(reg, val)           trace_kvm_apic(0, reg, val)
217 #define trace_kvm_apic_write(reg, val)          trace_kvm_apic(1, reg, val)
218 
219 #define KVM_ISA_VMX   1
220 #define KVM_ISA_SVM   2
221 
222 /*
223  * Tracepoint for kvm guest exit:
224  */
225 TRACE_EVENT(kvm_exit,
226         TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa),
227         TP_ARGS(exit_reason, vcpu, isa),
228 
229         TP_STRUCT__entry(
230                 __field(        unsigned int,   exit_reason     )
231                 __field(        unsigned long,  guest_rip       )
232                 __field(        u32,            isa             )
233                 __field(        u64,            info1           )
234                 __field(        u64,            info2           )
235         ),
236 
237         TP_fast_assign(
238                 __entry->exit_reason    = exit_reason;
239                 __entry->guest_rip      = kvm_rip_read(vcpu);
240                 __entry->isa            = isa;
241                 kvm_x86_ops->get_exit_info(vcpu, &__entry->info1,
242                                            &__entry->info2);
243         ),
244 
245         TP_printk("reason %s rip 0x%lx info %llx %llx",
246                  (__entry->isa == KVM_ISA_VMX) ?
247                  __print_symbolic(__entry->exit_reason, VMX_EXIT_REASONS) :
248                  __print_symbolic(__entry->exit_reason, SVM_EXIT_REASONS),
249                  __entry->guest_rip, __entry->info1, __entry->info2)
250 );
251 
252 /*
253  * Tracepoint for kvm interrupt injection:
254  */
255 TRACE_EVENT(kvm_inj_virq,
256         TP_PROTO(unsigned int irq),
257         TP_ARGS(irq),
258 
259         TP_STRUCT__entry(
260                 __field(        unsigned int,   irq             )
261         ),
262 
263         TP_fast_assign(
264                 __entry->irq            = irq;
265         ),
266 
267         TP_printk("irq %u", __entry->irq)
268 );
269 
270 #define EXS(x) { x##_VECTOR, "#" #x }
271 
272 #define kvm_trace_sym_exc                                               \
273         EXS(DE), EXS(DB), EXS(BP), EXS(OF), EXS(BR), EXS(UD), EXS(NM),  \
274         EXS(DF), EXS(TS), EXS(NP), EXS(SS), EXS(GP), EXS(PF),           \
275         EXS(MF), EXS(AC), EXS(MC)
276 
277 /*
278  * Tracepoint for kvm interrupt injection:
279  */
280 TRACE_EVENT(kvm_inj_exception,
281         TP_PROTO(unsigned exception, bool has_error, unsigned error_code),
282         TP_ARGS(exception, has_error, error_code),
283 
284         TP_STRUCT__entry(
285                 __field(        u8,     exception       )
286                 __field(        u8,     has_error       )
287                 __field(        u32,    error_code      )
288         ),
289 
290         TP_fast_assign(
291                 __entry->exception      = exception;
292                 __entry->has_error      = has_error;
293                 __entry->error_code     = error_code;
294         ),
295 
296         TP_printk("%s (0x%x)",
297                   __print_symbolic(__entry->exception, kvm_trace_sym_exc),
298                   /* FIXME: don't print error_code if not present */
299                   __entry->has_error ? __entry->error_code : 0)
300 );
301 
302 /*
303  * Tracepoint for page fault.
304  */
305 TRACE_EVENT(kvm_page_fault,
306         TP_PROTO(unsigned long fault_address, unsigned int error_code),
307         TP_ARGS(fault_address, error_code),
308 
309         TP_STRUCT__entry(
310                 __field(        unsigned long,  fault_address   )
311                 __field(        unsigned int,   error_code      )
312         ),
313 
314         TP_fast_assign(
315                 __entry->fault_address  = fault_address;
316                 __entry->error_code     = error_code;
317         ),
318 
319         TP_printk("address %lx error_code %x",
320                   __entry->fault_address, __entry->error_code)
321 );
322 
323 /*
324  * Tracepoint for guest MSR access.
325  */
326 TRACE_EVENT(kvm_msr,
327         TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception),
328         TP_ARGS(write, ecx, data, exception),
329 
330         TP_STRUCT__entry(
331                 __field(        unsigned,       write           )
332                 __field(        u32,            ecx             )
333                 __field(        u64,            data            )
334                 __field(        u8,             exception       )
335         ),
336 
337         TP_fast_assign(
338                 __entry->write          = write;
339                 __entry->ecx            = ecx;
340                 __entry->data           = data;
341                 __entry->exception      = exception;
342         ),
343 
344         TP_printk("msr_%s %x = 0x%llx%s",
345                   __entry->write ? "write" : "read",
346                   __entry->ecx, __entry->data,
347                   __entry->exception ? " (#GP)" : "")
348 );
349 
350 #define trace_kvm_msr_read(ecx, data)      trace_kvm_msr(0, ecx, data, false)
351 #define trace_kvm_msr_write(ecx, data)     trace_kvm_msr(1, ecx, data, false)
352 #define trace_kvm_msr_read_ex(ecx)         trace_kvm_msr(0, ecx, 0, true)
353 #define trace_kvm_msr_write_ex(ecx, data)  trace_kvm_msr(1, ecx, data, true)
354 
355 /*
356  * Tracepoint for guest CR access.
357  */
358 TRACE_EVENT(kvm_cr,
359         TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
360         TP_ARGS(rw, cr, val),
361 
362         TP_STRUCT__entry(
363                 __field(        unsigned int,   rw              )
364                 __field(        unsigned int,   cr              )
365                 __field(        unsigned long,  val             )
366         ),
367 
368         TP_fast_assign(
369                 __entry->rw             = rw;
370                 __entry->cr             = cr;
371                 __entry->val            = val;
372         ),
373 
374         TP_printk("cr_%s %x = 0x%lx",
375                   __entry->rw ? "write" : "read",
376                   __entry->cr, __entry->val)
377 );
378 
379 #define trace_kvm_cr_read(cr, val)              trace_kvm_cr(0, cr, val)
380 #define trace_kvm_cr_write(cr, val)             trace_kvm_cr(1, cr, val)
381 
382 TRACE_EVENT(kvm_pic_set_irq,
383             TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
384             TP_ARGS(chip, pin, elcr, imr, coalesced),
385 
386         TP_STRUCT__entry(
387                 __field(        __u8,           chip            )
388                 __field(        __u8,           pin             )
389                 __field(        __u8,           elcr            )
390                 __field(        __u8,           imr             )
391                 __field(        bool,           coalesced       )
392         ),
393 
394         TP_fast_assign(
395                 __entry->chip           = chip;
396                 __entry->pin            = pin;
397                 __entry->elcr           = elcr;
398                 __entry->imr            = imr;
399                 __entry->coalesced      = coalesced;
400         ),
401 
402         TP_printk("chip %u pin %u (%s%s)%s",
403                   __entry->chip, __entry->pin,
404                   (__entry->elcr & (1 << __entry->pin)) ? "level":"edge",
405                   (__entry->imr & (1 << __entry->pin)) ? "|masked":"",
406                   __entry->coalesced ? " (coalesced)" : "")
407 );
408 
409 #define kvm_apic_dst_shorthand          \
410         {0x0, "dst"},                   \
411         {0x1, "self"},                  \
412         {0x2, "all"},                   \
413         {0x3, "all-but-self"}
414 
415 TRACE_EVENT(kvm_apic_ipi,
416             TP_PROTO(__u32 icr_low, __u32 dest_id),
417             TP_ARGS(icr_low, dest_id),
418 
419         TP_STRUCT__entry(
420                 __field(        __u32,          icr_low         )
421                 __field(        __u32,          dest_id         )
422         ),
423 
424         TP_fast_assign(
425                 __entry->icr_low        = icr_low;
426                 __entry->dest_id        = dest_id;
427         ),
428 
429         TP_printk("dst %x vec %u (%s|%s|%s|%s|%s)",
430                   __entry->dest_id, (u8)__entry->icr_low,
431                   __print_symbolic((__entry->icr_low >> 8 & 0x7),
432                                    kvm_deliver_mode),
433                   (__entry->icr_low & (1<<11)) ? "logical" : "physical",
434                   (__entry->icr_low & (1<<14)) ? "assert" : "de-assert",
435                   (__entry->icr_low & (1<<15)) ? "level" : "edge",
436                   __print_symbolic((__entry->icr_low >> 18 & 0x3),
437                                    kvm_apic_dst_shorthand))
438 );
439 
440 TRACE_EVENT(kvm_apic_accept_irq,
441             TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec),
442             TP_ARGS(apicid, dm, tm, vec),
443 
444         TP_STRUCT__entry(
445                 __field(        __u32,          apicid          )
446                 __field(        __u16,          dm              )
447                 __field(        __u8,           tm              )
448                 __field(        __u8,           vec             )
449         ),
450 
451         TP_fast_assign(
452                 __entry->apicid         = apicid;
453                 __entry->dm             = dm;
454                 __entry->tm             = tm;
455                 __entry->vec            = vec;
456         ),
457 
458         TP_printk("apicid %x vec %u (%s|%s)",
459                   __entry->apicid, __entry->vec,
460                   __print_symbolic((__entry->dm >> 8 & 0x7), kvm_deliver_mode),
461                   __entry->tm ? "level" : "edge")
462 );
463 
464 TRACE_EVENT(kvm_eoi,
465             TP_PROTO(struct kvm_lapic *apic, int vector),
466             TP_ARGS(apic, vector),
467 
468         TP_STRUCT__entry(
469                 __field(        __u32,          apicid          )
470                 __field(        int,            vector          )
471         ),
472 
473         TP_fast_assign(
474                 __entry->apicid         = apic->vcpu->vcpu_id;
475                 __entry->vector         = vector;
476         ),
477 
478         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
479 );
480 
481 TRACE_EVENT(kvm_pv_eoi,
482             TP_PROTO(struct kvm_lapic *apic, int vector),
483             TP_ARGS(apic, vector),
484 
485         TP_STRUCT__entry(
486                 __field(        __u32,          apicid          )
487                 __field(        int,            vector          )
488         ),
489 
490         TP_fast_assign(
491                 __entry->apicid         = apic->vcpu->vcpu_id;
492                 __entry->vector         = vector;
493         ),
494 
495         TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
496 );
497 
498 /*
499  * Tracepoint for nested VMRUN
500  */
501 TRACE_EVENT(kvm_nested_vmrun,
502             TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl,
503                      __u32 event_inj, bool npt),
504             TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, npt),
505 
506         TP_STRUCT__entry(
507                 __field(        __u64,          rip             )
508                 __field(        __u64,          vmcb            )
509                 __field(        __u64,          nested_rip      )
510                 __field(        __u32,          int_ctl         )
511                 __field(        __u32,          event_inj       )
512                 __field(        bool,           npt             )
513         ),
514 
515         TP_fast_assign(
516                 __entry->rip            = rip;
517                 __entry->vmcb           = vmcb;
518                 __entry->nested_rip     = nested_rip;
519                 __entry->int_ctl        = int_ctl;
520                 __entry->event_inj      = event_inj;
521                 __entry->npt            = npt;
522         ),
523 
524         TP_printk("rip: 0x%016llx vmcb: 0x%016llx nrip: 0x%016llx int_ctl: 0x%08x "
525                   "event_inj: 0x%08x npt: %s",
526                 __entry->rip, __entry->vmcb, __entry->nested_rip,
527                 __entry->int_ctl, __entry->event_inj,
528                 __entry->npt ? "on" : "off")
529 );
530 
531 TRACE_EVENT(kvm_nested_intercepts,
532             TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions, __u64 intercept),
533             TP_ARGS(cr_read, cr_write, exceptions, intercept),
534 
535         TP_STRUCT__entry(
536                 __field(        __u16,          cr_read         )
537                 __field(        __u16,          cr_write        )
538                 __field(        __u32,          exceptions      )
539                 __field(        __u64,          intercept       )
540         ),
541 
542         TP_fast_assign(
543                 __entry->cr_read        = cr_read;
544                 __entry->cr_write       = cr_write;
545                 __entry->exceptions     = exceptions;
546                 __entry->intercept      = intercept;
547         ),
548 
549         TP_printk("cr_read: %04x cr_write: %04x excp: %08x intercept: %016llx",
550                 __entry->cr_read, __entry->cr_write, __entry->exceptions,
551                 __entry->intercept)
552 );
553 /*
554  * Tracepoint for #VMEXIT while nested
555  */
556 TRACE_EVENT(kvm_nested_vmexit,
557             TP_PROTO(__u64 rip, __u32 exit_code,
558                      __u64 exit_info1, __u64 exit_info2,
559                      __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
560             TP_ARGS(rip, exit_code, exit_info1, exit_info2,
561                     exit_int_info, exit_int_info_err, isa),
562 
563         TP_STRUCT__entry(
564                 __field(        __u64,          rip                     )
565                 __field(        __u32,          exit_code               )
566                 __field(        __u64,          exit_info1              )
567                 __field(        __u64,          exit_info2              )
568                 __field(        __u32,          exit_int_info           )
569                 __field(        __u32,          exit_int_info_err       )
570                 __field(        __u32,          isa                     )
571         ),
572 
573         TP_fast_assign(
574                 __entry->rip                    = rip;
575                 __entry->exit_code              = exit_code;
576                 __entry->exit_info1             = exit_info1;
577                 __entry->exit_info2             = exit_info2;
578                 __entry->exit_int_info          = exit_int_info;
579                 __entry->exit_int_info_err      = exit_int_info_err;
580                 __entry->isa                    = isa;
581         ),
582         TP_printk("rip: 0x%016llx reason: %s ext_inf1: 0x%016llx "
583                   "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
584                   __entry->rip,
585                  (__entry->isa == KVM_ISA_VMX) ?
586                  __print_symbolic(__entry->exit_code, VMX_EXIT_REASONS) :
587                  __print_symbolic(__entry->exit_code, SVM_EXIT_REASONS),
588                   __entry->exit_info1, __entry->exit_info2,
589                   __entry->exit_int_info, __entry->exit_int_info_err)
590 );
591 
592 /*
593  * Tracepoint for #VMEXIT reinjected to the guest
594  */
595 TRACE_EVENT(kvm_nested_vmexit_inject,
596             TP_PROTO(__u32 exit_code,
597                      __u64 exit_info1, __u64 exit_info2,
598                      __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa),
599             TP_ARGS(exit_code, exit_info1, exit_info2,
600                     exit_int_info, exit_int_info_err, isa),
601 
602         TP_STRUCT__entry(
603                 __field(        __u32,          exit_code               )
604                 __field(        __u64,          exit_info1              )
605                 __field(        __u64,          exit_info2              )
606                 __field(        __u32,          exit_int_info           )
607                 __field(        __u32,          exit_int_info_err       )
608                 __field(        __u32,          isa                     )
609         ),
610 
611         TP_fast_assign(
612                 __entry->exit_code              = exit_code;
613                 __entry->exit_info1             = exit_info1;
614                 __entry->exit_info2             = exit_info2;
615                 __entry->exit_int_info          = exit_int_info;
616                 __entry->exit_int_info_err      = exit_int_info_err;
617                 __entry->isa                    = isa;
618         ),
619 
620         TP_printk("reason: %s ext_inf1: 0x%016llx "
621                   "ext_inf2: 0x%016llx ext_int: 0x%08x ext_int_err: 0x%08x",
622                  (__entry->isa == KVM_ISA_VMX) ?
623                  __print_symbolic(__entry->exit_code, VMX_EXIT_REASONS) :
624                  __print_symbolic(__entry->exit_code, SVM_EXIT_REASONS),
625                 __entry->exit_info1, __entry->exit_info2,
626                 __entry->exit_int_info, __entry->exit_int_info_err)
627 );
628 
629 /*
630  * Tracepoint for nested #vmexit because of interrupt pending
631  */
632 TRACE_EVENT(kvm_nested_intr_vmexit,
633             TP_PROTO(__u64 rip),
634             TP_ARGS(rip),
635 
636         TP_STRUCT__entry(
637                 __field(        __u64,  rip     )
638         ),
639 
640         TP_fast_assign(
641                 __entry->rip    =       rip
642         ),
643 
644         TP_printk("rip: 0x%016llx", __entry->rip)
645 );
646 
647 /*
648  * Tracepoint for nested #vmexit because of interrupt pending
649  */
650 TRACE_EVENT(kvm_invlpga,
651             TP_PROTO(__u64 rip, int asid, u64 address),
652             TP_ARGS(rip, asid, address),
653 
654         TP_STRUCT__entry(
655                 __field(        __u64,  rip     )
656                 __field(        int,    asid    )
657                 __field(        __u64,  address )
658         ),
659 
660         TP_fast_assign(
661                 __entry->rip            =       rip;
662                 __entry->asid           =       asid;
663                 __entry->address        =       address;
664         ),
665 
666         TP_printk("rip: 0x%016llx asid: %d address: 0x%016llx",
667                   __entry->rip, __entry->asid, __entry->address)
668 );
669 
670 /*
671  * Tracepoint for nested #vmexit because of interrupt pending
672  */
673 TRACE_EVENT(kvm_skinit,
674             TP_PROTO(__u64 rip, __u32 slb),
675             TP_ARGS(rip, slb),
676 
677         TP_STRUCT__entry(
678                 __field(        __u64,  rip     )
679                 __field(        __u32,  slb     )
680         ),
681 
682         TP_fast_assign(
683                 __entry->rip            =       rip;
684                 __entry->slb            =       slb;
685         ),
686 
687         TP_printk("rip: 0x%016llx slb: 0x%08x",
688                   __entry->rip, __entry->slb)
689 );
690 
691 #define KVM_EMUL_INSN_F_CR0_PE (1 << 0)
692 #define KVM_EMUL_INSN_F_EFL_VM (1 << 1)
693 #define KVM_EMUL_INSN_F_CS_D   (1 << 2)
694 #define KVM_EMUL_INSN_F_CS_L   (1 << 3)
695 
696 #define kvm_trace_symbol_emul_flags                       \
697         { 0,                        "real" },             \
698         { KVM_EMUL_INSN_F_CR0_PE                          \
699           | KVM_EMUL_INSN_F_EFL_VM, "vm16" },             \
700         { KVM_EMUL_INSN_F_CR0_PE,   "prot16" },           \
701         { KVM_EMUL_INSN_F_CR0_PE                          \
702           | KVM_EMUL_INSN_F_CS_D,   "prot32" },           \
703         { KVM_EMUL_INSN_F_CR0_PE                          \
704           | KVM_EMUL_INSN_F_CS_L,   "prot64" }
705 
706 #define kei_decode_mode(mode) ({                        \
707         u8 flags = 0xff;                                \
708         switch (mode) {                                 \
709         case X86EMUL_MODE_REAL:                         \
710                 flags = 0;                              \
711                 break;                                  \
712         case X86EMUL_MODE_VM86:                         \
713                 flags = KVM_EMUL_INSN_F_EFL_VM;         \
714                 break;                                  \
715         case X86EMUL_MODE_PROT16:                       \
716                 flags = KVM_EMUL_INSN_F_CR0_PE;         \
717                 break;                                  \
718         case X86EMUL_MODE_PROT32:                       \
719                 flags = KVM_EMUL_INSN_F_CR0_PE          \
720                         | KVM_EMUL_INSN_F_CS_D;         \
721                 break;                                  \
722         case X86EMUL_MODE_PROT64:                       \
723                 flags = KVM_EMUL_INSN_F_CR0_PE          \
724                         | KVM_EMUL_INSN_F_CS_L;         \
725                 break;                                  \
726         }                                               \
727         flags;                                          \
728         })
729 
730 TRACE_EVENT(kvm_emulate_insn,
731         TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed),
732         TP_ARGS(vcpu, failed),
733 
734         TP_STRUCT__entry(
735                 __field(    __u64, rip                       )
736                 __field(    __u32, csbase                    )
737                 __field(    __u8,  len                       )
738                 __array(    __u8,  insn,    15               )
739                 __field(    __u8,  flags                     )
740                 __field(    __u8,  failed                    )
741                 ),
742 
743         TP_fast_assign(
744                 __entry->csbase = kvm_x86_ops->get_segment_base(vcpu, VCPU_SREG_CS);
745                 __entry->len = vcpu->arch.emulate_ctxt.fetch.ptr
746                                - vcpu->arch.emulate_ctxt.fetch.data;
747                 __entry->rip = vcpu->arch.emulate_ctxt._eip - __entry->len;
748                 memcpy(__entry->insn,
749                        vcpu->arch.emulate_ctxt.fetch.data,
750                        15);
751                 __entry->flags = kei_decode_mode(vcpu->arch.emulate_ctxt.mode);
752                 __entry->failed = failed;
753                 ),
754 
755         TP_printk("%x:%llx:%s (%s)%s",
756                   __entry->csbase, __entry->rip,
757                   __print_hex(__entry->insn, __entry->len),
758                   __print_symbolic(__entry->flags,
759                                    kvm_trace_symbol_emul_flags),
760                   __entry->failed ? " failed" : ""
761                 )
762         );
763 
764 #define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0)
765 #define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1)
766 
767 TRACE_EVENT(
768         vcpu_match_mmio,
769         TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match),
770         TP_ARGS(gva, gpa, write, gpa_match),
771 
772         TP_STRUCT__entry(
773                 __field(gva_t, gva)
774                 __field(gpa_t, gpa)
775                 __field(bool, write)
776                 __field(bool, gpa_match)
777                 ),
778 
779         TP_fast_assign(
780                 __entry->gva = gva;
781                 __entry->gpa = gpa;
782                 __entry->write = write;
783                 __entry->gpa_match = gpa_match
784                 ),
785 
786         TP_printk("gva %#lx gpa %#llx %s %s", __entry->gva, __entry->gpa,
787                   __entry->write ? "Write" : "Read",
788                   __entry->gpa_match ? "GPA" : "GVA")
789 );
790 
791 TRACE_EVENT(kvm_write_tsc_offset,
792         TP_PROTO(unsigned int vcpu_id, __u64 previous_tsc_offset,
793                  __u64 next_tsc_offset),
794         TP_ARGS(vcpu_id, previous_tsc_offset, next_tsc_offset),
795 
796         TP_STRUCT__entry(
797                 __field( unsigned int,  vcpu_id                         )
798                 __field(        __u64,  previous_tsc_offset             )
799                 __field(        __u64,  next_tsc_offset                 )
800         ),
801 
802         TP_fast_assign(
803                 __entry->vcpu_id                = vcpu_id;
804                 __entry->previous_tsc_offset    = previous_tsc_offset;
805                 __entry->next_tsc_offset        = next_tsc_offset;
806         ),
807 
808         TP_printk("vcpu=%u prev=%llu next=%llu", __entry->vcpu_id,
809                   __entry->previous_tsc_offset, __entry->next_tsc_offset)
810 );
811 
812 #ifdef CONFIG_X86_64
813 
814 #define host_clocks                                     \
815         {VCLOCK_NONE, "none"},                          \
816         {VCLOCK_TSC,  "tsc"}                            \
817 
818 TRACE_EVENT(kvm_update_master_clock,
819         TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched),
820         TP_ARGS(use_master_clock, host_clock, offset_matched),
821 
822         TP_STRUCT__entry(
823                 __field(                bool,   use_master_clock        )
824                 __field(        unsigned int,   host_clock              )
825                 __field(                bool,   offset_matched          )
826         ),
827 
828         TP_fast_assign(
829                 __entry->use_master_clock       = use_master_clock;
830                 __entry->host_clock             = host_clock;
831                 __entry->offset_matched         = offset_matched;
832         ),
833 
834         TP_printk("masterclock %d hostclock %s offsetmatched %u",
835                   __entry->use_master_clock,
836                   __print_symbolic(__entry->host_clock, host_clocks),
837                   __entry->offset_matched)
838 );
839 
840 TRACE_EVENT(kvm_track_tsc,
841         TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched,
842                  unsigned int online_vcpus, bool use_master_clock,
843                  unsigned int host_clock),
844         TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock,
845                 host_clock),
846 
847         TP_STRUCT__entry(
848                 __field(        unsigned int,   vcpu_id                 )
849                 __field(        unsigned int,   nr_vcpus_matched_tsc    )
850                 __field(        unsigned int,   online_vcpus            )
851                 __field(        bool,           use_master_clock        )
852                 __field(        unsigned int,   host_clock              )
853         ),
854 
855         TP_fast_assign(
856                 __entry->vcpu_id                = vcpu_id;
857                 __entry->nr_vcpus_matched_tsc   = nr_matched;
858                 __entry->online_vcpus           = online_vcpus;
859                 __entry->use_master_clock       = use_master_clock;
860                 __entry->host_clock             = host_clock;
861         ),
862 
863         TP_printk("vcpu_id %u masterclock %u offsetmatched %u nr_online %u"
864                   " hostclock %s",
865                   __entry->vcpu_id, __entry->use_master_clock,
866                   __entry->nr_vcpus_matched_tsc, __entry->online_vcpus,
867                   __print_symbolic(__entry->host_clock, host_clocks))
868 );
869 
870 #endif /* CONFIG_X86_64 */
871 
872 /*
873  * Tracepoint for PML full VMEXIT.
874  */
875 TRACE_EVENT(kvm_pml_full,
876         TP_PROTO(unsigned int vcpu_id),
877         TP_ARGS(vcpu_id),
878 
879         TP_STRUCT__entry(
880                 __field(        unsigned int,   vcpu_id                 )
881         ),
882 
883         TP_fast_assign(
884                 __entry->vcpu_id                = vcpu_id;
885         ),
886 
887         TP_printk("vcpu %d: PML full", __entry->vcpu_id)
888 );
889 
890 TRACE_EVENT(kvm_ple_window,
891         TP_PROTO(bool grow, unsigned int vcpu_id, int new, int old),
892         TP_ARGS(grow, vcpu_id, new, old),
893 
894         TP_STRUCT__entry(
895                 __field(                bool,      grow         )
896                 __field(        unsigned int,   vcpu_id         )
897                 __field(                 int,       new         )
898                 __field(                 int,       old         )
899         ),
900 
901         TP_fast_assign(
902                 __entry->grow           = grow;
903                 __entry->vcpu_id        = vcpu_id;
904                 __entry->new            = new;
905                 __entry->old            = old;
906         ),
907 
908         TP_printk("vcpu %u: ple_window %d (%s %d)",
909                   __entry->vcpu_id,
910                   __entry->new,
911                   __entry->grow ? "grow" : "shrink",
912                   __entry->old)
913 );
914 
915 #define trace_kvm_ple_window_grow(vcpu_id, new, old) \
916         trace_kvm_ple_window(true, vcpu_id, new, old)
917 #define trace_kvm_ple_window_shrink(vcpu_id, new, old) \
918         trace_kvm_ple_window(false, vcpu_id, new, old)
919 
920 TRACE_EVENT(kvm_pvclock_update,
921         TP_PROTO(unsigned int vcpu_id, struct pvclock_vcpu_time_info *pvclock),
922         TP_ARGS(vcpu_id, pvclock),
923 
924         TP_STRUCT__entry(
925                 __field(        unsigned int,   vcpu_id                 )
926                 __field(        __u32,          version                 )
927                 __field(        __u64,          tsc_timestamp           )
928                 __field(        __u64,          system_time             )
929                 __field(        __u32,          tsc_to_system_mul       )
930                 __field(        __s8,           tsc_shift               )
931                 __field(        __u8,           flags                   )
932         ),
933 
934         TP_fast_assign(
935                 __entry->vcpu_id           = vcpu_id;
936                 __entry->version           = pvclock->version;
937                 __entry->tsc_timestamp     = pvclock->tsc_timestamp;
938                 __entry->system_time       = pvclock->system_time;
939                 __entry->tsc_to_system_mul = pvclock->tsc_to_system_mul;
940                 __entry->tsc_shift         = pvclock->tsc_shift;
941                 __entry->flags             = pvclock->flags;
942         ),
943 
944         TP_printk("vcpu_id %u, pvclock { version %u, tsc_timestamp 0x%llx, "
945                   "system_time 0x%llx, tsc_to_system_mul 0x%x, tsc_shift %d, "
946                   "flags 0x%x }",
947                   __entry->vcpu_id,
948                   __entry->version,
949                   __entry->tsc_timestamp,
950                   __entry->system_time,
951                   __entry->tsc_to_system_mul,
952                   __entry->tsc_shift,
953                   __entry->flags)
954 );
955 
956 TRACE_EVENT(kvm_wait_lapic_expire,
957         TP_PROTO(unsigned int vcpu_id, s64 delta),
958         TP_ARGS(vcpu_id, delta),
959 
960         TP_STRUCT__entry(
961                 __field(        unsigned int,   vcpu_id         )
962                 __field(        s64,            delta           )
963         ),
964 
965         TP_fast_assign(
966                 __entry->vcpu_id           = vcpu_id;
967                 __entry->delta             = delta;
968         ),
969 
970         TP_printk("vcpu %u: delta %lld (%s)",
971                   __entry->vcpu_id,
972                   __entry->delta,
973                   __entry->delta < 0 ? "early" : "late")
974 );
975 
976 TRACE_EVENT(kvm_enter_smm,
977         TP_PROTO(unsigned int vcpu_id, u64 smbase, bool entering),
978         TP_ARGS(vcpu_id, smbase, entering),
979 
980         TP_STRUCT__entry(
981                 __field(        unsigned int,   vcpu_id         )
982                 __field(        u64,            smbase          )
983                 __field(        bool,           entering        )
984         ),
985 
986         TP_fast_assign(
987                 __entry->vcpu_id        = vcpu_id;
988                 __entry->smbase         = smbase;
989                 __entry->entering       = entering;
990         ),
991 
992         TP_printk("vcpu %u: %s SMM, smbase 0x%llx",
993                   __entry->vcpu_id,
994                   __entry->entering ? "entering" : "leaving",
995                   __entry->smbase)
996 );
997 
998 /*
999  * Tracepoint for VT-d posted-interrupts.
1000  */
1001 TRACE_EVENT(kvm_pi_irte_update,
1002         TP_PROTO(unsigned int host_irq, unsigned int vcpu_id,
1003                  unsigned int gsi, unsigned int gvec,
1004                  u64 pi_desc_addr, bool set),
1005         TP_ARGS(host_irq, vcpu_id, gsi, gvec, pi_desc_addr, set),
1006 
1007         TP_STRUCT__entry(
1008                 __field(        unsigned int,   host_irq        )
1009                 __field(        unsigned int,   vcpu_id         )
1010                 __field(        unsigned int,   gsi             )
1011                 __field(        unsigned int,   gvec            )
1012                 __field(        u64,            pi_desc_addr    )
1013                 __field(        bool,           set             )
1014         ),
1015 
1016         TP_fast_assign(
1017                 __entry->host_irq       = host_irq;
1018                 __entry->vcpu_id        = vcpu_id;
1019                 __entry->gsi            = gsi;
1020                 __entry->gvec           = gvec;
1021                 __entry->pi_desc_addr   = pi_desc_addr;
1022                 __entry->set            = set;
1023         ),
1024 
1025         TP_printk("VT-d PI is %s for irq %u, vcpu %u, gsi: 0x%x, "
1026                   "gvec: 0x%x, pi_desc_addr: 0x%llx",
1027                   __entry->set ? "enabled and being updated" : "disabled",
1028                   __entry->host_irq,
1029                   __entry->vcpu_id,
1030                   __entry->gsi,
1031                   __entry->gvec,
1032                   __entry->pi_desc_addr)
1033 );
1034 
1035 /*
1036  * Tracepoint for kvm_hv_notify_acked_sint.
1037  */
1038 TRACE_EVENT(kvm_hv_notify_acked_sint,
1039         TP_PROTO(int vcpu_id, u32 sint),
1040         TP_ARGS(vcpu_id, sint),
1041 
1042         TP_STRUCT__entry(
1043                 __field(int, vcpu_id)
1044                 __field(u32, sint)
1045         ),
1046 
1047         TP_fast_assign(
1048                 __entry->vcpu_id = vcpu_id;
1049                 __entry->sint = sint;
1050         ),
1051 
1052         TP_printk("vcpu_id %d sint %u", __entry->vcpu_id, __entry->sint)
1053 );
1054 
1055 /*
1056  * Tracepoint for synic_set_irq.
1057  */
1058 TRACE_EVENT(kvm_hv_synic_set_irq,
1059         TP_PROTO(int vcpu_id, u32 sint, int vector, int ret),
1060         TP_ARGS(vcpu_id, sint, vector, ret),
1061 
1062         TP_STRUCT__entry(
1063                 __field(int, vcpu_id)
1064                 __field(u32, sint)
1065                 __field(int, vector)
1066                 __field(int, ret)
1067         ),
1068 
1069         TP_fast_assign(
1070                 __entry->vcpu_id = vcpu_id;
1071                 __entry->sint = sint;
1072                 __entry->vector = vector;
1073                 __entry->ret = ret;
1074         ),
1075 
1076         TP_printk("vcpu_id %d sint %u vector %d ret %d",
1077                   __entry->vcpu_id, __entry->sint, __entry->vector,
1078                   __entry->ret)
1079 );
1080 
1081 /*
1082  * Tracepoint for kvm_hv_synic_send_eoi.
1083  */
1084 TRACE_EVENT(kvm_hv_synic_send_eoi,
1085         TP_PROTO(int vcpu_id, int vector),
1086         TP_ARGS(vcpu_id, vector),
1087 
1088         TP_STRUCT__entry(
1089                 __field(int, vcpu_id)
1090                 __field(u32, sint)
1091                 __field(int, vector)
1092                 __field(int, ret)
1093         ),
1094 
1095         TP_fast_assign(
1096                 __entry->vcpu_id = vcpu_id;
1097                 __entry->vector = vector;
1098         ),
1099 
1100         TP_printk("vcpu_id %d vector %d", __entry->vcpu_id, __entry->vector)
1101 );
1102 
1103 /*
1104  * Tracepoint for synic_set_msr.
1105  */
1106 TRACE_EVENT(kvm_hv_synic_set_msr,
1107         TP_PROTO(int vcpu_id, u32 msr, u64 data, bool host),
1108         TP_ARGS(vcpu_id, msr, data, host),
1109 
1110         TP_STRUCT__entry(
1111                 __field(int, vcpu_id)
1112                 __field(u32, msr)
1113                 __field(u64, data)
1114                 __field(bool, host)
1115         ),
1116 
1117         TP_fast_assign(
1118                 __entry->vcpu_id = vcpu_id;
1119                 __entry->msr = msr;
1120                 __entry->data = data;
1121                 __entry->host = host
1122         ),
1123 
1124         TP_printk("vcpu_id %d msr 0x%x data 0x%llx host %d",
1125                   __entry->vcpu_id, __entry->msr, __entry->data, __entry->host)
1126 );
1127 
1128 /*
1129  * Tracepoint for stimer_set_config.
1130  */
1131 TRACE_EVENT(kvm_hv_stimer_set_config,
1132         TP_PROTO(int vcpu_id, int timer_index, u64 config, bool host),
1133         TP_ARGS(vcpu_id, timer_index, config, host),
1134 
1135         TP_STRUCT__entry(
1136                 __field(int, vcpu_id)
1137                 __field(int, timer_index)
1138                 __field(u64, config)
1139                 __field(bool, host)
1140         ),
1141 
1142         TP_fast_assign(
1143                 __entry->vcpu_id = vcpu_id;
1144                 __entry->timer_index = timer_index;
1145                 __entry->config = config;
1146                 __entry->host = host;
1147         ),
1148 
1149         TP_printk("vcpu_id %d timer %d config 0x%llx host %d",
1150                   __entry->vcpu_id, __entry->timer_index, __entry->config,
1151                   __entry->host)
1152 );
1153 
1154 /*
1155  * Tracepoint for stimer_set_count.
1156  */
1157 TRACE_EVENT(kvm_hv_stimer_set_count,
1158         TP_PROTO(int vcpu_id, int timer_index, u64 count, bool host),
1159         TP_ARGS(vcpu_id, timer_index, count, host),
1160 
1161         TP_STRUCT__entry(
1162                 __field(int, vcpu_id)
1163                 __field(int, timer_index)
1164                 __field(u64, count)
1165                 __field(bool, host)
1166         ),
1167 
1168         TP_fast_assign(
1169                 __entry->vcpu_id = vcpu_id;
1170                 __entry->timer_index = timer_index;
1171                 __entry->count = count;
1172                 __entry->host = host;
1173         ),
1174 
1175         TP_printk("vcpu_id %d timer %d count %llu host %d",
1176                   __entry->vcpu_id, __entry->timer_index, __entry->count,
1177                   __entry->host)
1178 );
1179 
1180 /*
1181  * Tracepoint for stimer_start(periodic timer case).
1182  */
1183 TRACE_EVENT(kvm_hv_stimer_start_periodic,
1184         TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 exp_time),
1185         TP_ARGS(vcpu_id, timer_index, time_now, exp_time),
1186 
1187         TP_STRUCT__entry(
1188                 __field(int, vcpu_id)
1189                 __field(int, timer_index)
1190                 __field(u64, time_now)
1191                 __field(u64, exp_time)
1192         ),
1193 
1194         TP_fast_assign(
1195                 __entry->vcpu_id = vcpu_id;
1196                 __entry->timer_index = timer_index;
1197                 __entry->time_now = time_now;
1198                 __entry->exp_time = exp_time;
1199         ),
1200 
1201         TP_printk("vcpu_id %d timer %d time_now %llu exp_time %llu",
1202                   __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1203                   __entry->exp_time)
1204 );
1205 
1206 /*
1207  * Tracepoint for stimer_start(one-shot timer case).
1208  */
1209 TRACE_EVENT(kvm_hv_stimer_start_one_shot,
1210         TP_PROTO(int vcpu_id, int timer_index, u64 time_now, u64 count),
1211         TP_ARGS(vcpu_id, timer_index, time_now, count),
1212 
1213         TP_STRUCT__entry(
1214                 __field(int, vcpu_id)
1215                 __field(int, timer_index)
1216                 __field(u64, time_now)
1217                 __field(u64, count)
1218         ),
1219 
1220         TP_fast_assign(
1221                 __entry->vcpu_id = vcpu_id;
1222                 __entry->timer_index = timer_index;
1223                 __entry->time_now = time_now;
1224                 __entry->count = count;
1225         ),
1226 
1227         TP_printk("vcpu_id %d timer %d time_now %llu count %llu",
1228                   __entry->vcpu_id, __entry->timer_index, __entry->time_now,
1229                   __entry->count)
1230 );
1231 
1232 /*
1233  * Tracepoint for stimer_timer_callback.
1234  */
1235 TRACE_EVENT(kvm_hv_stimer_callback,
1236         TP_PROTO(int vcpu_id, int timer_index),
1237         TP_ARGS(vcpu_id, timer_index),
1238 
1239         TP_STRUCT__entry(
1240                 __field(int, vcpu_id)
1241                 __field(int, timer_index)
1242         ),
1243 
1244         TP_fast_assign(
1245                 __entry->vcpu_id = vcpu_id;
1246                 __entry->timer_index = timer_index;
1247         ),
1248 
1249         TP_printk("vcpu_id %d timer %d",
1250                   __entry->vcpu_id, __entry->timer_index)
1251 );
1252 
1253 /*
1254  * Tracepoint for stimer_expiration.
1255  */
1256 TRACE_EVENT(kvm_hv_stimer_expiration,
1257         TP_PROTO(int vcpu_id, int timer_index, int msg_send_result),
1258         TP_ARGS(vcpu_id, timer_index, msg_send_result),
1259 
1260         TP_STRUCT__entry(
1261                 __field(int, vcpu_id)
1262                 __field(int, timer_index)
1263                 __field(int, msg_send_result)
1264         ),
1265 
1266         TP_fast_assign(
1267                 __entry->vcpu_id = vcpu_id;
1268                 __entry->timer_index = timer_index;
1269                 __entry->msg_send_result = msg_send_result;
1270         ),
1271 
1272         TP_printk("vcpu_id %d timer %d msg send result %d",
1273                   __entry->vcpu_id, __entry->timer_index,
1274                   __entry->msg_send_result)
1275 );
1276 
1277 /*
1278  * Tracepoint for stimer_cleanup.
1279  */
1280 TRACE_EVENT(kvm_hv_stimer_cleanup,
1281         TP_PROTO(int vcpu_id, int timer_index),
1282         TP_ARGS(vcpu_id, timer_index),
1283 
1284         TP_STRUCT__entry(
1285                 __field(int, vcpu_id)
1286                 __field(int, timer_index)
1287         ),
1288 
1289         TP_fast_assign(
1290                 __entry->vcpu_id = vcpu_id;
1291                 __entry->timer_index = timer_index;
1292         ),
1293 
1294         TP_printk("vcpu_id %d timer %d",
1295                   __entry->vcpu_id, __entry->timer_index)
1296 );
1297 
1298 /*
1299  * Tracepoint for AMD AVIC
1300  */
1301 TRACE_EVENT(kvm_avic_incomplete_ipi,
1302             TP_PROTO(u32 vcpu, u32 icrh, u32 icrl, u32 id, u32 index),
1303             TP_ARGS(vcpu, icrh, icrl, id, index),
1304 
1305         TP_STRUCT__entry(
1306                 __field(u32, vcpu)
1307                 __field(u32, icrh)
1308                 __field(u32, icrl)
1309                 __field(u32, id)
1310                 __field(u32, index)
1311         ),
1312 
1313         TP_fast_assign(
1314                 __entry->vcpu = vcpu;
1315                 __entry->icrh = icrh;
1316                 __entry->icrl = icrl;
1317                 __entry->id = id;
1318                 __entry->index = index;
1319         ),
1320 
1321         TP_printk("vcpu=%u, icrh:icrl=%#010x:%08x, id=%u, index=%u\n",
1322                   __entry->vcpu, __entry->icrh, __entry->icrl,
1323                   __entry->id, __entry->index)
1324 );
1325 
1326 TRACE_EVENT(kvm_avic_unaccelerated_access,
1327             TP_PROTO(u32 vcpu, u32 offset, bool ft, bool rw, u32 vec),
1328             TP_ARGS(vcpu, offset, ft, rw, vec),
1329 
1330         TP_STRUCT__entry(
1331                 __field(u32, vcpu)
1332                 __field(u32, offset)
1333                 __field(bool, ft)
1334                 __field(bool, rw)
1335                 __field(u32, vec)
1336         ),
1337 
1338         TP_fast_assign(
1339                 __entry->vcpu = vcpu;
1340                 __entry->offset = offset;
1341                 __entry->ft = ft;
1342                 __entry->rw = rw;
1343                 __entry->vec = vec;
1344         ),
1345 
1346         TP_printk("vcpu=%u, offset=%#x(%s), %s, %s, vec=%#x\n",
1347                   __entry->vcpu,
1348                   __entry->offset,
1349                   __print_symbolic(__entry->offset, kvm_trace_symbol_apic),
1350                   __entry->ft ? "trap" : "fault",
1351                   __entry->rw ? "write" : "read",
1352                   __entry->vec)
1353 );
1354 
1355 TRACE_EVENT(kvm_hv_timer_state,
1356                 TP_PROTO(unsigned int vcpu_id, unsigned int hv_timer_in_use),
1357                 TP_ARGS(vcpu_id, hv_timer_in_use),
1358                 TP_STRUCT__entry(
1359                         __field(unsigned int, vcpu_id)
1360                         __field(unsigned int, hv_timer_in_use)
1361                         ),
1362                 TP_fast_assign(
1363                         __entry->vcpu_id = vcpu_id;
1364                         __entry->hv_timer_in_use = hv_timer_in_use;
1365                         ),
1366                 TP_printk("vcpu_id %x hv_timer %x\n",
1367                         __entry->vcpu_id,
1368                         __entry->hv_timer_in_use)
1369 );
1370 #endif /* _TRACE_KVM_H */
1371 
1372 #undef TRACE_INCLUDE_PATH
1373 #define TRACE_INCLUDE_PATH arch/x86/kvm
1374 #undef TRACE_INCLUDE_FILE
1375 #define TRACE_INCLUDE_FILE trace
1376 
1377 /* This part must be outside protection */
1378 #include <trace/define_trace.h>
1379 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp