[deliverable/linux.git] / arch / s390 / kvm / trace.h

#if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_KVM_H

#include <linux/tracepoint.h>
#include <asm/sie.h>
#include <asm/debug.h>
#include <asm/dis.h>

#undef TRACE_SYSTEM
#define TRACE_SYSTEM kvm
#define TRACE_INCLUDE_PATH .
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE trace

/*
 * Helpers for vcpu-specific tracepoints containing the same information
 * as s390dbf VCPU_EVENTs.
 */
#define VCPU_PROTO_COMMON struct kvm_vcpu *vcpu
#define VCPU_ARGS_COMMON vcpu
#define VCPU_FIELD_COMMON __field(int, id)			\
	__field(unsigned long, pswmask)				\
	__field(unsigned long, pswaddr)
#define VCPU_ASSIGN_COMMON do {						\
	__entry->id = vcpu->vcpu_id;					\
	__entry->pswmask = vcpu->arch.sie_block->gpsw.mask;		\
	__entry->pswaddr = vcpu->arch.sie_block->gpsw.addr;		\
	} while (0);
#define VCPU_TP_PRINTK(p_str, p_args...)				\
	TP_printk("%02d[%016lx-%016lx]: " p_str, __entry->id,		\
		  __entry->pswmask, __entry->pswaddr, p_args)

TRACE_EVENT(kvm_s390_skey_related_inst,
	    TP_PROTO(VCPU_PROTO_COMMON),
	    TP_ARGS(VCPU_ARGS_COMMON),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    ),
	    VCPU_TP_PRINTK("%s", "first instruction related to skeys on vcpu")
	);

TRACE_EVENT(kvm_s390_major_guest_pfault,
	    TP_PROTO(VCPU_PROTO_COMMON),
	    TP_ARGS(VCPU_ARGS_COMMON),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    ),
	    VCPU_TP_PRINTK("%s", "major fault, maybe applicable for pfault")
	);

TRACE_EVENT(kvm_s390_pfault_init,
	    TP_PROTO(VCPU_PROTO_COMMON, long pfault_token),
	    TP_ARGS(VCPU_ARGS_COMMON, pfault_token),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(long, pfault_token)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->pfault_token = pfault_token;
		    ),
	    VCPU_TP_PRINTK("init pfault token %ld", __entry->pfault_token)
	);

TRACE_EVENT(kvm_s390_pfault_done,
	    TP_PROTO(VCPU_PROTO_COMMON, long pfault_token),
	    TP_ARGS(VCPU_ARGS_COMMON, pfault_token),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(long, pfault_token)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->pfault_token = pfault_token;
		    ),
	    VCPU_TP_PRINTK("done pfault token %ld", __entry->pfault_token)
	);

/*
 * Tracepoints for SIE entry and exit.
 */
TRACE_EVENT(kvm_s390_sie_enter,
	    TP_PROTO(VCPU_PROTO_COMMON, int cpuflags),
	    TP_ARGS(VCPU_ARGS_COMMON, cpuflags),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(int, cpuflags)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->cpuflags = cpuflags;
		    ),

	    VCPU_TP_PRINTK("entering sie flags %x", __entry->cpuflags)
	);

TRACE_EVENT(kvm_s390_sie_fault,
	    TP_PROTO(VCPU_PROTO_COMMON),
	    TP_ARGS(VCPU_ARGS_COMMON),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    ),

	    VCPU_TP_PRINTK("%s", "fault in sie instruction")
	);

TRACE_EVENT(kvm_s390_sie_exit,
	    TP_PROTO(VCPU_PROTO_COMMON, u8 icptcode),
	    TP_ARGS(VCPU_ARGS_COMMON, icptcode),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(u8, icptcode)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->icptcode = icptcode;
		    ),

	    VCPU_TP_PRINTK("exit sie icptcode %d (%s)", __entry->icptcode,
			   __print_symbolic(__entry->icptcode,
					    sie_intercept_code))
	);

/*
 * Trace point for intercepted instructions.
 */
TRACE_EVENT(kvm_s390_intercept_instruction,
	    TP_PROTO(VCPU_PROTO_COMMON, __u16 ipa, __u32 ipb),
	    TP_ARGS(VCPU_ARGS_COMMON, ipa, ipb),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(__u64, instruction)
		    __field(char, insn[8])
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->instruction = ((__u64)ipa << 48) |
		    ((__u64)ipb << 16);
		    ),

	    VCPU_TP_PRINTK("intercepted instruction %016llx (%s)",
			   __entry->instruction,
			   insn_to_mnemonic((unsigned char *)
					    &__entry->instruction,
					 __entry->insn, sizeof(__entry->insn)) ?
			   "unknown" : __entry->insn)
	);

/*
 * Trace point for intercepted program interruptions.
 */
TRACE_EVENT(kvm_s390_intercept_prog,
	    TP_PROTO(VCPU_PROTO_COMMON, __u16 code),
	    TP_ARGS(VCPU_ARGS_COMMON, code),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(__u16, code)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->code = code;
		    ),

	    VCPU_TP_PRINTK("intercepted program interruption %04x",
			   __entry->code)
	);

/*
 * Trace point for validity intercepts.
 */
TRACE_EVENT(kvm_s390_intercept_validity,
	    TP_PROTO(VCPU_PROTO_COMMON, __u16 viwhy),
	    TP_ARGS(VCPU_ARGS_COMMON, viwhy),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(__u16, viwhy)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->viwhy = viwhy;
		    ),

	    VCPU_TP_PRINTK("got validity intercept %04x", __entry->viwhy)
	);

/*
 * Trace points for instructions that are of special interest.
 */

TRACE_EVENT(kvm_s390_handle_sigp,
	    TP_PROTO(VCPU_PROTO_COMMON, __u8 order_code, __u16 cpu_addr, \
		     __u32 parameter),
	    TP_ARGS(VCPU_ARGS_COMMON, order_code, cpu_addr, parameter),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(__u8, order_code)
		    __field(__u16, cpu_addr)
		    __field(__u32, parameter)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->order_code = order_code;
		    __entry->cpu_addr = cpu_addr;
		    __entry->parameter = parameter;
		    ),

	    VCPU_TP_PRINTK("handle sigp order %02x (%s), cpu address %04x, " \
			   "parameter %08x", __entry->order_code,
			   __print_symbolic(__entry->order_code,
					    sigp_order_codes),
			   __entry->cpu_addr, __entry->parameter)
	);

TRACE_EVENT(kvm_s390_handle_diag,
	    TP_PROTO(VCPU_PROTO_COMMON, __u16 code),
	    TP_ARGS(VCPU_ARGS_COMMON, code),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(__u16, code)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->code = code;
		    ),

	    VCPU_TP_PRINTK("handle diagnose call %04x (%s)", __entry->code,
			   __print_symbolic(__entry->code, diagnose_codes))
	);

TRACE_EVENT(kvm_s390_handle_lctl,
	    TP_PROTO(VCPU_PROTO_COMMON, int g, int reg1, int reg3, u64 addr),
	    TP_ARGS(VCPU_ARGS_COMMON, g, reg1, reg3, addr),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(int, g)
		    __field(int, reg1)
		    __field(int, reg3)
		    __field(u64, addr)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->g = g;
		    __entry->reg1 = reg1;
		    __entry->reg3 = reg3;
		    __entry->addr = addr;
		    ),

	    VCPU_TP_PRINTK("%s: loading cr %x-%x from %016llx",
			   __entry->g ? "lctlg" : "lctl",
			   __entry->reg1, __entry->reg3, __entry->addr)
	);

TRACE_EVENT(kvm_s390_handle_stctl,
	    TP_PROTO(VCPU_PROTO_COMMON, int g, int reg1, int reg3, u64 addr),
	    TP_ARGS(VCPU_ARGS_COMMON, g, reg1, reg3, addr),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(int, g)
		    __field(int, reg1)
		    __field(int, reg3)
		    __field(u64, addr)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->g = g;
		    __entry->reg1 = reg1;
		    __entry->reg3 = reg3;
		    __entry->addr = addr;
		    ),

	    VCPU_TP_PRINTK("%s: storing cr %x-%x to %016llx",
			   __entry->g ? "stctg" : "stctl",
			   __entry->reg1, __entry->reg3, __entry->addr)
	);

TRACE_EVENT(kvm_s390_handle_prefix,
	    TP_PROTO(VCPU_PROTO_COMMON, int set, u32 address),
	    TP_ARGS(VCPU_ARGS_COMMON, set, address),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(int, set)
		    __field(u32, address)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->set = set;
		    __entry->address = address;
		    ),

	    VCPU_TP_PRINTK("%s prefix to %08x",
			   __entry->set ? "setting" : "storing",
			   __entry->address)
	);

TRACE_EVENT(kvm_s390_handle_stap,
	    TP_PROTO(VCPU_PROTO_COMMON, u64 address),
	    TP_ARGS(VCPU_ARGS_COMMON, address),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(u64, address)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->address = address;
		    ),

	    VCPU_TP_PRINTK("storing cpu address to %016llx",
			   __entry->address)
	);

TRACE_EVENT(kvm_s390_handle_stfl,
	    TP_PROTO(VCPU_PROTO_COMMON, unsigned int facility_list),
	    TP_ARGS(VCPU_ARGS_COMMON, facility_list),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(unsigned int, facility_list)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->facility_list = facility_list;
		    ),

	    VCPU_TP_PRINTK("store facility list value %08x",
			   __entry->facility_list)
	);

TRACE_EVENT(kvm_s390_handle_stsi,
	    TP_PROTO(VCPU_PROTO_COMMON, int fc, int sel1, int sel2, u64 addr),
	    TP_ARGS(VCPU_ARGS_COMMON, fc, sel1, sel2, addr),

	    TP_STRUCT__entry(
		    VCPU_FIELD_COMMON
		    __field(int, fc)
		    __field(int, sel1)
		    __field(int, sel2)
		    __field(u64, addr)
		    ),

	    TP_fast_assign(
		    VCPU_ASSIGN_COMMON
		    __entry->fc = fc;
		    __entry->sel1 = sel1;
		    __entry->sel2 = sel2;
		    __entry->addr = addr;
		    ),

	    VCPU_TP_PRINTK("STSI %d.%d.%d information stored to %016llx",
			   __entry->fc, __entry->sel1, __entry->sel2,
			   __entry->addr)
	);

#endif /* _TRACE_KVM_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
5786fffa CH	1	#if !defined(_TRACE_KVM_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	#define _TRACE_KVM_H
	3
	4	#include <linux/tracepoint.h>
6de1bf88	5	#include <asm/sie.h>
5786fffa	6	#include <asm/debug.h>
0f20822a	7	#include <asm/dis.h>
5786fffa CH	8
	9	#undef TRACE_SYSTEM
	10	#define TRACE_SYSTEM kvm
	11	#define TRACE_INCLUDE_PATH .
	12	#undef TRACE_INCLUDE_FILE
	13	#define TRACE_INCLUDE_FILE trace
	14
	15	/*
	16	* Helpers for vcpu-specific tracepoints containing the same information
	17	* as s390dbf VCPU_EVENTs.
	18	*/
	19	#define VCPU_PROTO_COMMON struct kvm_vcpu *vcpu
	20	#define VCPU_ARGS_COMMON vcpu
	21	#define VCPU_FIELD_COMMON __field(int, id) \
	22	__field(unsigned long, pswmask) \
	23	__field(unsigned long, pswaddr)
	24	#define VCPU_ASSIGN_COMMON do { \
	25	__entry->id = vcpu->vcpu_id; \
	26	__entry->pswmask = vcpu->arch.sie_block->gpsw.mask; \
	27	__entry->pswaddr = vcpu->arch.sie_block->gpsw.addr; \
	28	} while (0);
	29	#define VCPU_TP_PRINTK(p_str, p_args...) \
	30	TP_printk("%02d[%016lx-%016lx]: " p_str, __entry->id, \
	31	__entry->pswmask, __entry->pswaddr, p_args)
	32
693ffc08 DD	33	TRACE_EVENT(kvm_s390_skey_related_inst,
	34	TP_PROTO(VCPU_PROTO_COMMON),
	35	TP_ARGS(VCPU_ARGS_COMMON),
	36
	37	TP_STRUCT__entry(
	38	VCPU_FIELD_COMMON
	39	),
	40
	41	TP_fast_assign(
	42	VCPU_ASSIGN_COMMON
	43	),
	44	VCPU_TP_PRINTK("%s", "first instruction related to skeys on vcpu")
	45	);
	46
3c038e6b DD	47	TRACE_EVENT(kvm_s390_major_guest_pfault,
	48	TP_PROTO(VCPU_PROTO_COMMON),
	49	TP_ARGS(VCPU_ARGS_COMMON),
	50
	51	TP_STRUCT__entry(
	52	VCPU_FIELD_COMMON
	53	),
	54
	55	TP_fast_assign(
	56	VCPU_ASSIGN_COMMON
	57	),
	58	VCPU_TP_PRINTK("%s", "major fault, maybe applicable for pfault")
	59	);
	60
	61	TRACE_EVENT(kvm_s390_pfault_init,
	62	TP_PROTO(VCPU_PROTO_COMMON, long pfault_token),
	63	TP_ARGS(VCPU_ARGS_COMMON, pfault_token),
	64
	65	TP_STRUCT__entry(
	66	VCPU_FIELD_COMMON
	67	__field(long, pfault_token)
	68	),
	69
	70	TP_fast_assign(
	71	VCPU_ASSIGN_COMMON
	72	__entry->pfault_token = pfault_token;
	73	),
	74	VCPU_TP_PRINTK("init pfault token %ld", __entry->pfault_token)
	75	);
	76
	77	TRACE_EVENT(kvm_s390_pfault_done,
	78	TP_PROTO(VCPU_PROTO_COMMON, long pfault_token),
	79	TP_ARGS(VCPU_ARGS_COMMON, pfault_token),
	80
	81	TP_STRUCT__entry(
	82	VCPU_FIELD_COMMON
	83	__field(long, pfault_token)
	84	),
	85
	86	TP_fast_assign(
	87	VCPU_ASSIGN_COMMON
	88	__entry->pfault_token = pfault_token;
	89	),
	90	VCPU_TP_PRINTK("done pfault token %ld", __entry->pfault_token)
	91	);
	92
5786fffa CH	93	/*
	94	* Tracepoints for SIE entry and exit.
	95	*/
	96	TRACE_EVENT(kvm_s390_sie_enter,
	97	TP_PROTO(VCPU_PROTO_COMMON, int cpuflags),
	98	TP_ARGS(VCPU_ARGS_COMMON, cpuflags),
	99
	100	TP_STRUCT__entry(
	101	VCPU_FIELD_COMMON
	102	__field(int, cpuflags)
	103	),
	104
	105	TP_fast_assign(
	106	VCPU_ASSIGN_COMMON
	107	__entry->cpuflags = cpuflags;
	108	),
	109
	110	VCPU_TP_PRINTK("entering sie flags %x", __entry->cpuflags)
	111	);
	112
	113	TRACE_EVENT(kvm_s390_sie_fault,
	114	TP_PROTO(VCPU_PROTO_COMMON),
	115	TP_ARGS(VCPU_ARGS_COMMON),
	116
	117	TP_STRUCT__entry(
	118	VCPU_FIELD_COMMON
	119	),
	120
	121	TP_fast_assign(
	122	VCPU_ASSIGN_COMMON
	123	),
	124
	125	VCPU_TP_PRINTK("%s", "fault in sie instruction")
	126	);
	127
5786fffa CH	128	TRACE_EVENT(kvm_s390_sie_exit,
	129	TP_PROTO(VCPU_PROTO_COMMON, u8 icptcode),
	130	TP_ARGS(VCPU_ARGS_COMMON, icptcode),
	131
	132	TP_STRUCT__entry(
	133	VCPU_FIELD_COMMON
	134	__field(u8, icptcode)
	135	),
	136
	137	TP_fast_assign(
	138	VCPU_ASSIGN_COMMON
	139	__entry->icptcode = icptcode;
	140	),
	141
	142	VCPU_TP_PRINTK("exit sie icptcode %d (%s)", __entry->icptcode,
	143	__print_symbolic(__entry->icptcode,
	144	sie_intercept_code))
	145	);
	146
	147	/*
	148	* Trace point for intercepted instructions.
	149	*/
	150	TRACE_EVENT(kvm_s390_intercept_instruction,
	151	TP_PROTO(VCPU_PROTO_COMMON, __u16 ipa, __u32 ipb),
	152	TP_ARGS(VCPU_ARGS_COMMON, ipa, ipb),
	153
	154	TP_STRUCT__entry(
	155	VCPU_FIELD_COMMON
	156	__field(__u64, instruction)
	157	__field(char, insn[8])
	158	),
	159
	160	TP_fast_assign(
	161	VCPU_ASSIGN_COMMON
	162	__entry->instruction = ((__u64)ipa << 48) \|
	163	((__u64)ipb << 16);
	164	),
	165
	166	VCPU_TP_PRINTK("intercepted instruction %016llx (%s)",
	167	__entry->instruction,
	168	insn_to_mnemonic((unsigned char *)
	169	&__entry->instruction,
0bcc94ba	170	__entry->insn, sizeof(__entry->insn)) ?
5786fffa CH	171	"unknown" : __entry->insn)
	172	);
	173
	174	/*
	175	* Trace point for intercepted program interruptions.
	176	*/
	177	TRACE_EVENT(kvm_s390_intercept_prog,
	178	TP_PROTO(VCPU_PROTO_COMMON, __u16 code),
	179	TP_ARGS(VCPU_ARGS_COMMON, code),
	180
	181	TP_STRUCT__entry(
	182	VCPU_FIELD_COMMON
	183	__field(__u16, code)
	184	),
	185
	186	TP_fast_assign(
	187	VCPU_ASSIGN_COMMON
	188	__entry->code = code;
	189	),
	190
	191	VCPU_TP_PRINTK("intercepted program interruption %04x",
	192	__entry->code)
	193	);
	194
	195	/*
	196	* Trace point for validity intercepts.
	197	*/
	198	TRACE_EVENT(kvm_s390_intercept_validity,
	199	TP_PROTO(VCPU_PROTO_COMMON, __u16 viwhy),
	200	TP_ARGS(VCPU_ARGS_COMMON, viwhy),
	201
	202	TP_STRUCT__entry(
	203	VCPU_FIELD_COMMON
	204	__field(__u16, viwhy)
	205	),
	206
	207	TP_fast_assign(
	208	VCPU_ASSIGN_COMMON
	209	__entry->viwhy = viwhy;
	210	),
	211
	212	VCPU_TP_PRINTK("got validity intercept %04x", __entry->viwhy)
	213	);
	214
	215	/*
	216	* Trace points for instructions that are of special interest.
	217	*/
	218
5786fffa CH	219	TRACE_EVENT(kvm_s390_handle_sigp,
	220	TP_PROTO(VCPU_PROTO_COMMON, __u8 order_code, __u16 cpu_addr, \
	221	__u32 parameter),
	222	TP_ARGS(VCPU_ARGS_COMMON, order_code, cpu_addr, parameter),
	223
	224	TP_STRUCT__entry(
	225	VCPU_FIELD_COMMON
	226	__field(__u8, order_code)
	227	__field(__u16, cpu_addr)
	228	__field(__u32, parameter)
	229	),
	230
	231	TP_fast_assign(
	232	VCPU_ASSIGN_COMMON
	233	__entry->order_code = order_code;
	234	__entry->cpu_addr = cpu_addr;
	235	__entry->parameter = parameter;
	236	),
	237
	238	VCPU_TP_PRINTK("handle sigp order %02x (%s), cpu address %04x, " \
	239	"parameter %08x", __entry->order_code,
	240	__print_symbolic(__entry->order_code,
	241	sigp_order_codes),
	242	__entry->cpu_addr, __entry->parameter)
	243	);
	244
5786fffa CH	245	TRACE_EVENT(kvm_s390_handle_diag,
	246	TP_PROTO(VCPU_PROTO_COMMON, __u16 code),
	247	TP_ARGS(VCPU_ARGS_COMMON, code),
	248
	249	TP_STRUCT__entry(
	250	VCPU_FIELD_COMMON
	251	__field(__u16, code)
	252	),
	253
	254	TP_fast_assign(
	255	VCPU_ASSIGN_COMMON
	256	__entry->code = code;
	257	),
	258
	259	VCPU_TP_PRINTK("handle diagnose call %04x (%s)", __entry->code,
	260	__print_symbolic(__entry->code, diagnose_codes))
	261	);
	262
	263	TRACE_EVENT(kvm_s390_handle_lctl,
	264	TP_PROTO(VCPU_PROTO_COMMON, int g, int reg1, int reg3, u64 addr),
	265	TP_ARGS(VCPU_ARGS_COMMON, g, reg1, reg3, addr),
	266
	267	TP_STRUCT__entry(
	268	VCPU_FIELD_COMMON
	269	__field(int, g)
	270	__field(int, reg1)
	271	__field(int, reg3)
	272	__field(u64, addr)
	273	),
	274
	275	TP_fast_assign(
	276	VCPU_ASSIGN_COMMON
	277	__entry->g = g;
	278	__entry->reg1 = reg1;
	279	__entry->reg3 = reg3;
	280	__entry->addr = addr;
	281	),
	282
	283	VCPU_TP_PRINTK("%s: loading cr %x-%x from %016llx",
	284	__entry->g ? "lctlg" : "lctl",
	285	__entry->reg1, __entry->reg3, __entry->addr)
aba07508 DH	286	);
	287
	288	TRACE_EVENT(kvm_s390_handle_stctl,
	289	TP_PROTO(VCPU_PROTO_COMMON, int g, int reg1, int reg3, u64 addr),
	290	TP_ARGS(VCPU_ARGS_COMMON, g, reg1, reg3, addr),
	291
	292	TP_STRUCT__entry(
	293	VCPU_FIELD_COMMON
	294	__field(int, g)
	295	__field(int, reg1)
	296	__field(int, reg3)
	297	__field(u64, addr)
	298	),
	299
	300	TP_fast_assign(
	301	VCPU_ASSIGN_COMMON
	302	__entry->g = g;
	303	__entry->reg1 = reg1;
	304	__entry->reg3 = reg3;
	305	__entry->addr = addr;
	306	),
	307
	308	VCPU_TP_PRINTK("%s: storing cr %x-%x to %016llx",
	309	__entry->g ? "stctg" : "stctl",
	310	__entry->reg1, __entry->reg3, __entry->addr)
5786fffa CH	311	);
	312
	313	TRACE_EVENT(kvm_s390_handle_prefix,
	314	TP_PROTO(VCPU_PROTO_COMMON, int set, u32 address),
	315	TP_ARGS(VCPU_ARGS_COMMON, set, address),
	316
	317	TP_STRUCT__entry(
	318	VCPU_FIELD_COMMON
	319	__field(int, set)
	320	__field(u32, address)
	321	),
	322
	323	TP_fast_assign(
	324	VCPU_ASSIGN_COMMON
	325	__entry->set = set;
	326	__entry->address = address;
	327	),
	328
	329	VCPU_TP_PRINTK("%s prefix to %08x",
	330	__entry->set ? "setting" : "storing",
	331	__entry->address)
	332	);
	333
	334	TRACE_EVENT(kvm_s390_handle_stap,
	335	TP_PROTO(VCPU_PROTO_COMMON, u64 address),
	336	TP_ARGS(VCPU_ARGS_COMMON, address),
	337
	338	TP_STRUCT__entry(
	339	VCPU_FIELD_COMMON
	340	__field(u64, address)
	341	),
	342
	343	TP_fast_assign(
	344	VCPU_ASSIGN_COMMON
	345	__entry->address = address;
	346	),
	347
	348	VCPU_TP_PRINTK("storing cpu address to %016llx",
	349	__entry->address)
	350	);
	351
	352	TRACE_EVENT(kvm_s390_handle_stfl,
	353	TP_PROTO(VCPU_PROTO_COMMON, unsigned int facility_list),
	354	TP_ARGS(VCPU_ARGS_COMMON, facility_list),
	355
	356	TP_STRUCT__entry(
	357	VCPU_FIELD_COMMON
	358	__field(unsigned int, facility_list)
	359	),
	360
	361	TP_fast_assign(
	362	VCPU_ASSIGN_COMMON
	363	__entry->facility_list = facility_list;
	364	),
	365
	366	VCPU_TP_PRINTK("store facility list value %08x",
	367	__entry->facility_list)
	368	);
	369
	370	TRACE_EVENT(kvm_s390_handle_stsi,
	371	TP_PROTO(VCPU_PROTO_COMMON, int fc, int sel1, int sel2, u64 addr),
	372	TP_ARGS(VCPU_ARGS_COMMON, fc, sel1, sel2, addr),
	373
	374	TP_STRUCT__entry(
375	VCPU_FIELD_COMMON
376	__field(int, fc)
377	__field(int, sel1)
378	__field(int, sel2)
379	__field(u64, addr)
380	),
381
382	TP_fast_assign(
383	VCPU_ASSIGN_COMMON
384	__entry->fc = fc;
385	__entry->sel1 = sel1;
386	__entry->sel2 = sel2;
387	__entry->addr = addr;
388	),
389
390	VCPU_TP_PRINTK("STSI %d.%d.%d information stored to %016llx",
391	__entry->fc, __entry->sel1, __entry->sel2,
392	__entry->addr)
393	);
394
395	#endif /* _TRACE_KVM_H */
396
397	/* This part must be outside protection */
398	#include <trace/define_trace.h>