[linux-2.6-block.git] / drivers / hv / hv_trace.h

/* SPDX-License-Identifier: GPL-2.0 */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM hyperv

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

#include <linux/tracepoint.h>

DECLARE_EVENT_CLASS(vmbus_hdr_msg,
	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	TP_ARGS(hdr),
	TP_STRUCT__entry(__field(unsigned int, msgtype)),
	TP_fast_assign(__entry->msgtype = hdr->msgtype;),
	TP_printk("msgtype=%u", __entry->msgtype)
);

DEFINE_EVENT(vmbus_hdr_msg, vmbus_on_msg_dpc,
	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	TP_ARGS(hdr)
);

DEFINE_EVENT(vmbus_hdr_msg, vmbus_on_message,
	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	TP_ARGS(hdr)
);

TRACE_EVENT(vmbus_onoffer,
	    TP_PROTO(const struct vmbus_channel_offer_channel *offer),
	    TP_ARGS(offer),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u8, monitorid)
		    __field(u16, is_ddc_int)
		    __field(u32, connection_id)
		    __array(char, if_type, 16)
		    __array(char, if_instance, 16)
		    __field(u16, chn_flags)
		    __field(u16, mmio_mb)
		    __field(u16, sub_idx)
		    ),
	    TP_fast_assign(__entry->child_relid = offer->child_relid;
			   __entry->monitorid = offer->monitorid;
			   __entry->is_ddc_int = offer->is_dedicated_interrupt;
			   __entry->connection_id = offer->connection_id;
			   export_guid(__entry->if_type, &offer->offer.if_type);
			   export_guid(__entry->if_instance, &offer->offer.if_instance);
			   __entry->chn_flags = offer->offer.chn_flags;
			   __entry->mmio_mb = offer->offer.mmio_megabytes;
			   __entry->sub_idx = offer->offer.sub_channel_index;
		    ),
	    TP_printk("child_relid 0x%x, monitorid 0x%x, is_dedicated %d, "
		      "connection_id 0x%x, if_type %pUl, if_instance %pUl, "
		      "chn_flags 0x%x, mmio_megabytes %d, sub_channel_index %d",
		      __entry->child_relid, __entry->monitorid,
		      __entry->is_ddc_int, __entry->connection_id,
		      __entry->if_type, __entry->if_instance,
		      __entry->chn_flags, __entry->mmio_mb,
		      __entry->sub_idx
		    )
	);

TRACE_EVENT(vmbus_onoffer_rescind,
	    TP_PROTO(const struct vmbus_channel_rescind_offer *offer),
	    TP_ARGS(offer),
	    TP_STRUCT__entry(__field(u32, child_relid)),
	    TP_fast_assign(__entry->child_relid = offer->child_relid),
	    TP_printk("child_relid 0x%x", __entry->child_relid)
	);

TRACE_EVENT(vmbus_onopen_result,
	    TP_PROTO(const struct vmbus_channel_open_result *result),
	    TP_ARGS(result),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, openid)
		    __field(u32, status)
		    ),
	    TP_fast_assign(__entry->child_relid = result->child_relid;
			   __entry->openid = result->openid;
			   __entry->status = result->status;
		    ),
	    TP_printk("child_relid 0x%x, openid %d, status %d",
		      __entry->child_relid,  __entry->openid,  __entry->status
		    )
	);

TRACE_EVENT(vmbus_ongpadl_created,
	    TP_PROTO(const struct vmbus_channel_gpadl_created *gpadlcreated),
	    TP_ARGS(gpadlcreated),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, gpadl)
		    __field(u32, status)
		    ),
	    TP_fast_assign(__entry->child_relid = gpadlcreated->child_relid;
			   __entry->gpadl = gpadlcreated->gpadl;
			   __entry->status = gpadlcreated->creation_status;
		    ),
	    TP_printk("child_relid 0x%x, gpadl 0x%x, creation_status %d",
		      __entry->child_relid,  __entry->gpadl,  __entry->status
		    )
	);

TRACE_EVENT(vmbus_ongpadl_torndown,
	    TP_PROTO(const struct vmbus_channel_gpadl_torndown *gpadltorndown),
	    TP_ARGS(gpadltorndown),
	    TP_STRUCT__entry(__field(u32, gpadl)),
	    TP_fast_assign(__entry->gpadl = gpadltorndown->gpadl),
	    TP_printk("gpadl 0x%x", __entry->gpadl)
	);

TRACE_EVENT(vmbus_onversion_response,
	    TP_PROTO(const struct vmbus_channel_version_response *response),
	    TP_ARGS(response),
	    TP_STRUCT__entry(
		    __field(u8, ver)
		    ),
	    TP_fast_assign(__entry->ver = response->version_supported;
		    ),
	    TP_printk("version_supported %d", __entry->ver)
	);

TRACE_EVENT(vmbus_request_offers,
	    TP_PROTO(int ret),
	    TP_ARGS(ret),
	    TP_STRUCT__entry(__field(int, ret)),
	    TP_fast_assign(__entry->ret = ret),
	    TP_printk("sending ret %d", __entry->ret)
	);

TRACE_EVENT(vmbus_open,
	    TP_PROTO(const struct vmbus_channel_open_channel *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, openid)
		    __field(u32, gpadlhandle)
		    __field(u32, target_vp)
		    __field(u32, offset)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->openid = msg->openid;
		    __entry->gpadlhandle = msg->ringbuffer_gpadlhandle;
		    __entry->target_vp = msg->target_vp;
		    __entry->offset = msg->downstream_ringbuffer_pageoffset;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending child_relid 0x%x, openid %d, "
		      "gpadlhandle 0x%x, target_vp 0x%x, offset 0x%x, ret %d",
		      __entry->child_relid,  __entry->openid,
		      __entry->gpadlhandle, __entry->target_vp,
		      __entry->offset, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_close_internal,
	    TP_PROTO(const struct vmbus_channel_close_channel *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending child_relid 0x%x, ret %d", __entry->child_relid,
		    __entry->ret)
	);

TRACE_EVENT(vmbus_establish_gpadl_header,
	    TP_PROTO(const struct vmbus_channel_gpadl_header *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, gpadl)
		    __field(u16, range_buflen)
		    __field(u16, rangecount)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->gpadl = msg->gpadl;
		    __entry->range_buflen = msg->range_buflen;
		    __entry->rangecount = msg->rangecount;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending child_relid 0x%x, gpadl 0x%x, range_buflen %d "
		      "rangecount %d, ret %d",
		      __entry->child_relid, __entry->gpadl,
		      __entry->range_buflen, __entry->rangecount, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_establish_gpadl_body,
	    TP_PROTO(const struct vmbus_channel_gpadl_body *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, msgnumber)
		    __field(u32, gpadl)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->msgnumber = msg->msgnumber;
		    __entry->gpadl = msg->gpadl;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending msgnumber %d, gpadl 0x%x, ret %d",
		      __entry->msgnumber, __entry->gpadl, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_teardown_gpadl,
	    TP_PROTO(const struct vmbus_channel_gpadl_teardown *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, gpadl)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->gpadl = msg->gpadl;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending child_relid 0x%x, gpadl 0x%x, ret %d",
		      __entry->child_relid, __entry->gpadl, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_negotiate_version,
	    TP_PROTO(const struct vmbus_channel_initiate_contact *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, ver)
		    __field(u32, target_vcpu)
		    __field(int, ret)
		    __field(u64, int_page)
		    __field(u64, mon_page1)
		    __field(u64, mon_page2)
		    ),
	    TP_fast_assign(
		    __entry->ver = msg->vmbus_version_requested;
		    __entry->target_vcpu = msg->target_vcpu;
		    __entry->int_page = msg->interrupt_page;
		    __entry->mon_page1 = msg->monitor_page1;
		    __entry->mon_page2 = msg->monitor_page2;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending vmbus_version_requested %d, target_vcpu 0x%x, "
		      "pages %llx:%llx:%llx, ret %d",
		      __entry->ver, __entry->target_vcpu, __entry->int_page,
		      __entry->mon_page1, __entry->mon_page2, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_release_relid,
	    TP_PROTO(const struct vmbus_channel_relid_released *msg, int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->ret = ret;
		    ),
	    TP_printk("sending child_relid 0x%x, ret %d",
		      __entry->child_relid, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_send_tl_connect_request,
	    TP_PROTO(const struct vmbus_channel_tl_connect_request *msg,
		     int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __array(char, guest_id, 16)
		    __array(char, host_id, 16)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    export_guid(__entry->guest_id, &msg->guest_endpoint_id);
		    export_guid(__entry->host_id, &msg->host_service_id);
		    __entry->ret = ret;
		    ),
	    TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "
		      "ret %d",
		      __entry->guest_id, __entry->host_id, __entry->ret
		    )
	);

TRACE_EVENT(vmbus_send_modifychannel,
	    TP_PROTO(const struct vmbus_channel_modifychannel *msg,
		     int ret),
	    TP_ARGS(msg, ret),
	    TP_STRUCT__entry(
		    __field(u32, child_relid)
		    __field(u32, target_vp)
		    __field(int, ret)
		    ),
	    TP_fast_assign(
		    __entry->child_relid = msg->child_relid;
		    __entry->target_vp = msg->target_vp;
		    __entry->ret = ret;
		    ),
	    TP_printk("binding child_relid 0x%x to target_vp 0x%x, ret %d",
		      __entry->child_relid, __entry->target_vp, __entry->ret
		    )
	);

DECLARE_EVENT_CLASS(vmbus_channel,
	TP_PROTO(const struct vmbus_channel *channel),
	TP_ARGS(channel),
	TP_STRUCT__entry(__field(u32, relid)),
	TP_fast_assign(__entry->relid = channel->offermsg.child_relid),
	TP_printk("relid 0x%x", __entry->relid)
);

DEFINE_EVENT(vmbus_channel, vmbus_chan_sched,
	    TP_PROTO(const struct vmbus_channel *channel),
	    TP_ARGS(channel)
);

DEFINE_EVENT(vmbus_channel, vmbus_setevent,
	    TP_PROTO(const struct vmbus_channel *channel),
	    TP_ARGS(channel)
);

DEFINE_EVENT(vmbus_channel, vmbus_on_event,
	    TP_PROTO(const struct vmbus_channel *channel),
	    TP_ARGS(channel)
);

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE hv_trace
#endif /* _HV_TRACE_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
61e0f391	1	/* SPDX-License-Identifier: GPL-2.0 */
76241271	2
c9fe0f8f VK	3	#undef TRACE_SYSTEM
	4	#define TRACE_SYSTEM hyperv
	5
	6	#if !defined(_HV_TRACE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	7	#define _HV_TRACE_H
	8
	9	#include <linux/tracepoint.h>
	10
	11	DECLARE_EVENT_CLASS(vmbus_hdr_msg,
	12	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	13	TP_ARGS(hdr),
	14	TP_STRUCT__entry(__field(unsigned int, msgtype)),
	15	TP_fast_assign(__entry->msgtype = hdr->msgtype;),
	16	TP_printk("msgtype=%u", __entry->msgtype)
	17	);
	18
	19	DEFINE_EVENT(vmbus_hdr_msg, vmbus_on_msg_dpc,
	20	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	21	TP_ARGS(hdr)
	22	);
	23
716fa52f VK	24	DEFINE_EVENT(vmbus_hdr_msg, vmbus_on_message,
	25	TP_PROTO(const struct vmbus_channel_message_header *hdr),
	26	TP_ARGS(hdr)
	27	);
	28
03b81e66 VK	29	TRACE_EVENT(vmbus_onoffer,
	30	TP_PROTO(const struct vmbus_channel_offer_channel *offer),
	31	TP_ARGS(offer),
	32	TP_STRUCT__entry(
	33	__field(u32, child_relid)
	34	__field(u8, monitorid)
	35	__field(u16, is_ddc_int)
	36	__field(u32, connection_id)
	37	__array(char, if_type, 16)
	38	__array(char, if_instance, 16)
	39	__field(u16, chn_flags)
	40	__field(u16, mmio_mb)
	41	__field(u16, sub_idx)
	42	),
	43	TP_fast_assign(__entry->child_relid = offer->child_relid;
	44	__entry->monitorid = offer->monitorid;
	45	__entry->is_ddc_int = offer->is_dedicated_interrupt;
	46	__entry->connection_id = offer->connection_id;
69f57058 AS	47	export_guid(__entry->if_type, &offer->offer.if_type);
69f57058 AS	48	export_guid(__entry->if_instance, &offer->offer.if_instance);
03b81e66 VK	49	__entry->chn_flags = offer->offer.chn_flags;
	50	__entry->mmio_mb = offer->offer.mmio_megabytes;
	51	__entry->sub_idx = offer->offer.sub_channel_index;
	52	),
	53	TP_printk("child_relid 0x%x, monitorid 0x%x, is_dedicated %d, "
	54	"connection_id 0x%x, if_type %pUl, if_instance %pUl, "
	55	"chn_flags 0x%x, mmio_megabytes %d, sub_channel_index %d",
	56	__entry->child_relid, __entry->monitorid,
	57	__entry->is_ddc_int, __entry->connection_id,
	58	__entry->if_type, __entry->if_instance,
	59	__entry->chn_flags, __entry->mmio_mb,
	60	__entry->sub_idx
	61	)
	62	);
	63
5175167c VK	64	TRACE_EVENT(vmbus_onoffer_rescind,
	65	TP_PROTO(const struct vmbus_channel_rescind_offer *offer),
	66	TP_ARGS(offer),
	67	TP_STRUCT__entry(__field(u32, child_relid)),
	68	TP_fast_assign(__entry->child_relid = offer->child_relid),
	69	TP_printk("child_relid 0x%x", __entry->child_relid)
	70	);
	71
9f23ce1a VK	72	TRACE_EVENT(vmbus_onopen_result,
	73	TP_PROTO(const struct vmbus_channel_open_result *result),
	74	TP_ARGS(result),
	75	TP_STRUCT__entry(
	76	__field(u32, child_relid)
	77	__field(u32, openid)
	78	__field(u32, status)
	79	),
	80	TP_fast_assign(__entry->child_relid = result->child_relid;
	81	__entry->openid = result->openid;
	82	__entry->status = result->status;
	83	),
	84	TP_printk("child_relid 0x%x, openid %d, status %d",
	85	__entry->child_relid, __entry->openid, __entry->status
	86	)
	87	);
	88
a13bf0ea VK	89	TRACE_EVENT(vmbus_ongpadl_created,
	90	TP_PROTO(const struct vmbus_channel_gpadl_created *gpadlcreated),
	91	TP_ARGS(gpadlcreated),
	92	TP_STRUCT__entry(
	93	__field(u32, child_relid)
	94	__field(u32, gpadl)
	95	__field(u32, status)
	96	),
	97	TP_fast_assign(__entry->child_relid = gpadlcreated->child_relid;
	98	__entry->gpadl = gpadlcreated->gpadl;
	99	__entry->status = gpadlcreated->creation_status;
	100	),
	101	TP_printk("child_relid 0x%x, gpadl 0x%x, creation_status %d",
	102	__entry->child_relid, __entry->gpadl, __entry->status
	103	)
	104	);
	105
602a8c52 VK	106	TRACE_EVENT(vmbus_ongpadl_torndown,
	107	TP_PROTO(const struct vmbus_channel_gpadl_torndown *gpadltorndown),
	108	TP_ARGS(gpadltorndown),
	109	TP_STRUCT__entry(__field(u32, gpadl)),
	110	TP_fast_assign(__entry->gpadl = gpadltorndown->gpadl),
	111	TP_printk("gpadl 0x%x", __entry->gpadl)
	112	);
	113
c7924fb0 VK	114	TRACE_EVENT(vmbus_onversion_response,
	115	TP_PROTO(const struct vmbus_channel_version_response *response),
	116	TP_ARGS(response),
	117	TP_STRUCT__entry(
	118	__field(u8, ver)
	119	),
	120	TP_fast_assign(__entry->ver = response->version_supported;
	121	),
	122	TP_printk("version_supported %d", __entry->ver)
	123	);
	124
d6706e63 VK	125	TRACE_EVENT(vmbus_request_offers,
	126	TP_PROTO(int ret),
	127	TP_ARGS(ret),
	128	TP_STRUCT__entry(__field(int, ret)),
	129	TP_fast_assign(__entry->ret = ret),
	130	TP_printk("sending ret %d", __entry->ret)
	131	);
	132
9202d771 VK	133	TRACE_EVENT(vmbus_open,
	134	TP_PROTO(const struct vmbus_channel_open_channel *msg, int ret),
	135	TP_ARGS(msg, ret),
	136	TP_STRUCT__entry(
	137	__field(u32, child_relid)
	138	__field(u32, openid)
	139	__field(u32, gpadlhandle)
	140	__field(u32, target_vp)
	141	__field(u32, offset)
	142	__field(int, ret)
	143	),
	144	TP_fast_assign(
	145	__entry->child_relid = msg->child_relid;
	146	__entry->openid = msg->openid;
	147	__entry->gpadlhandle = msg->ringbuffer_gpadlhandle;
	148	__entry->target_vp = msg->target_vp;
	149	__entry->offset = msg->downstream_ringbuffer_pageoffset;
	150	__entry->ret = ret;
	151	),
	152	TP_printk("sending child_relid 0x%x, openid %d, "
	153	"gpadlhandle 0x%x, target_vp 0x%x, offset 0x%x, ret %d",
	154	__entry->child_relid, __entry->openid,
	155	__entry->gpadlhandle, __entry->target_vp,
	156	__entry->offset, __entry->ret
	157	)
	158	);
	159
633b005d VK	160	TRACE_EVENT(vmbus_close_internal,
	161	TP_PROTO(const struct vmbus_channel_close_channel *msg, int ret),
	162	TP_ARGS(msg, ret),
	163	TP_STRUCT__entry(
	164	__field(u32, child_relid)
	165	__field(int, ret)
	166	),
	167	TP_fast_assign(
	168	__entry->child_relid = msg->child_relid;
	169	__entry->ret = ret;
	170	),
	171	TP_printk("sending child_relid 0x%x, ret %d", __entry->child_relid,
	172	__entry->ret)
	173	);
	174
69edbd5f VK	175	TRACE_EVENT(vmbus_establish_gpadl_header,
	176	TP_PROTO(const struct vmbus_channel_gpadl_header *msg, int ret),
	177	TP_ARGS(msg, ret),
	178	TP_STRUCT__entry(
	179	__field(u32, child_relid)
	180	__field(u32, gpadl)
	181	__field(u16, range_buflen)
	182	__field(u16, rangecount)
	183	__field(int, ret)
	184	),
	185	TP_fast_assign(
	186	__entry->child_relid = msg->child_relid;
	187	__entry->gpadl = msg->gpadl;
	188	__entry->range_buflen = msg->range_buflen;
	189	__entry->rangecount = msg->rangecount;
	190	__entry->ret = ret;
	191	),
	192	TP_printk("sending child_relid 0x%x, gpadl 0x%x, range_buflen %d "
	193	"rangecount %d, ret %d",
	194	__entry->child_relid, __entry->gpadl,
	195	__entry->range_buflen, __entry->rangecount, __entry->ret
	196	)
	197	);
	198
	199	TRACE_EVENT(vmbus_establish_gpadl_body,
	200	TP_PROTO(const struct vmbus_channel_gpadl_body *msg, int ret),
	201	TP_ARGS(msg, ret),
	202	TP_STRUCT__entry(
	203	__field(u32, msgnumber)
	204	__field(u32, gpadl)
	205	__field(int, ret)
	206	),
	207	TP_fast_assign(
	208	__entry->msgnumber = msg->msgnumber;
	209	__entry->gpadl = msg->gpadl;
	210	__entry->ret = ret;
	211	),
	212	TP_printk("sending msgnumber %d, gpadl 0x%x, ret %d",
	213	__entry->msgnumber, __entry->gpadl, __entry->ret
	214	)
	215	);
	216
09cdf8f8 VK	217	TRACE_EVENT(vmbus_teardown_gpadl,
	218	TP_PROTO(const struct vmbus_channel_gpadl_teardown *msg, int ret),
	219	TP_ARGS(msg, ret),
	220	TP_STRUCT__entry(
	221	__field(u32, child_relid)
	222	__field(u32, gpadl)
	223	__field(int, ret)
	224	),
	225	TP_fast_assign(
	226	__entry->child_relid = msg->child_relid;
	227	__entry->gpadl = msg->gpadl;
	228	__entry->ret = ret;
	229	),
	230	TP_printk("sending child_relid 0x%x, gpadl 0x%x, ret %d",
	231	__entry->child_relid, __entry->gpadl, __entry->ret
	232	)
	233	);
	234
034ebf55 VK	235	TRACE_EVENT(vmbus_negotiate_version,
	236	TP_PROTO(const struct vmbus_channel_initiate_contact *msg, int ret),
	237	TP_ARGS(msg, ret),
	238	TP_STRUCT__entry(
	239	__field(u32, ver)
	240	__field(u32, target_vcpu)
	241	__field(int, ret)
	242	__field(u64, int_page)
	243	__field(u64, mon_page1)
	244	__field(u64, mon_page2)
	245	),
	246	TP_fast_assign(
	247	__entry->ver = msg->vmbus_version_requested;
	248	__entry->target_vcpu = msg->target_vcpu;
	249	__entry->int_page = msg->interrupt_page;
	250	__entry->mon_page1 = msg->monitor_page1;
	251	__entry->mon_page2 = msg->monitor_page2;
	252	__entry->ret = ret;
	253	),
	254	TP_printk("sending vmbus_version_requested %d, target_vcpu 0x%x, "
	255	"pages %llx:%llx:%llx, ret %d",
	256	__entry->ver, __entry->target_vcpu, __entry->int_page,
	257	__entry->mon_page1, __entry->mon_page2, __entry->ret
	258	)
	259	);
	260
259cc665 VK	261	TRACE_EVENT(vmbus_release_relid,
	262	TP_PROTO(const struct vmbus_channel_relid_released *msg, int ret),
	263	TP_ARGS(msg, ret),
	264	TP_STRUCT__entry(
	265	__field(u32, child_relid)
	266	__field(int, ret)
	267	),
	268	TP_fast_assign(
	269	__entry->child_relid = msg->child_relid;
	270	__entry->ret = ret;
	271	),
	272	TP_printk("sending child_relid 0x%x, ret %d",
	273	__entry->child_relid, __entry->ret
	274	)
	275	);
	276
98f31a00 VK	277	TRACE_EVENT(vmbus_send_tl_connect_request,
	278	TP_PROTO(const struct vmbus_channel_tl_connect_request *msg,
	279	int ret),
	280	TP_ARGS(msg, ret),
	281	TP_STRUCT__entry(
	282	__array(char, guest_id, 16)
	283	__array(char, host_id, 16)
	284	__field(int, ret)
	285	),
	286	TP_fast_assign(
1d3c9c07 AS	287	export_guid(__entry->guest_id, &msg->guest_endpoint_id);
1d3c9c07 AS	288	export_guid(__entry->host_id, &msg->host_service_id);
98f31a00 VK	289	__entry->ret = ret;
	290	),
	291	TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "
	292	"ret %d",
	293	__entry->guest_id, __entry->host_id, __entry->ret
	294	)
	295	);
	296
75278105 APM	297	TRACE_EVENT(vmbus_send_modifychannel,
	298	TP_PROTO(const struct vmbus_channel_modifychannel *msg,
	299	int ret),
	300	TP_ARGS(msg, ret),
	301	TP_STRUCT__entry(
	302	__field(u32, child_relid)
	303	__field(u32, target_vp)
	304	__field(int, ret)
	305	),
	306	TP_fast_assign(
	307	__entry->child_relid = msg->child_relid;
	308	__entry->target_vp = msg->target_vp;
	309	__entry->ret = ret;
	310	),
	311	TP_printk("binding child_relid 0x%x to target_vp 0x%x, ret %d",
	312	__entry->child_relid, __entry->target_vp, __entry->ret
	313	)
	314	);
	315
991f8f1c VK	316	DECLARE_EVENT_CLASS(vmbus_channel,
	317	TP_PROTO(const struct vmbus_channel *channel),
	318	TP_ARGS(channel),
	319	TP_STRUCT__entry(__field(u32, relid)),
	320	TP_fast_assign(__entry->relid = channel->offermsg.child_relid),
	321	TP_printk("relid 0x%x", __entry->relid)
	322	);
	323
	324	DEFINE_EVENT(vmbus_channel, vmbus_chan_sched,
	325	TP_PROTO(const struct vmbus_channel *channel),
	326	TP_ARGS(channel)
	327	);
	328
	329	DEFINE_EVENT(vmbus_channel, vmbus_setevent,
	330	TP_PROTO(const struct vmbus_channel *channel),
	331	TP_ARGS(channel)
	332	);
	333
	334	DEFINE_EVENT(vmbus_channel, vmbus_on_event,
	335	TP_PROTO(const struct vmbus_channel *channel),
	336	TP_ARGS(channel)
	337	);
	338
c9fe0f8f VK	339	#undef TRACE_INCLUDE_PATH
	340	#define TRACE_INCLUDE_PATH .
	341	#undef TRACE_INCLUDE_FILE
	342	#define TRACE_INCLUDE_FILE hv_trace
	343	#endif /* _HV_TRACE_H */
	344
	345	/* This part must be outside protection */
	346	#include <trace/define_trace.h>