Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
mshv: Introduce tracing support
Introduces various trace events and use them in the corresponding places
in the driver.
Signed-off-by: Stanislav Kinsburskii <skinsburskii@linux.microsoft.com>
Signed-off-by: Wei Liu <wei.liu@kernel.org>
authored by
Stanislav Kinsburskii
and committed by
Wei Liu
80acc80e
1c80dd81
+629
-15
+1
drivers/hv/Makefile
+1
drivers/hv/Makefile
···
16
16
mshv_root-y := mshv_root_main.o mshv_synic.o mshv_eventfd.o mshv_irq.o \
17
17
mshv_root_hv_call.o mshv_portid_table.o mshv_regions.o
18
18
mshv_root-$(CONFIG_DEBUG_FS) += mshv_debugfs.o
19
+
mshv_root-$(CONFIG_TRACEPOINTS) += mshv_trace.o
19
20
mshv_vtl-y := mshv_vtl_main.o
20
21
21
22
# Code that must be built-in
+14
drivers/hv/mshv_eventfd.c
+14
drivers/hv/mshv_eventfd.c
···
733
733
ret = mshv_register_doorbell(pt->pt_id, ioeventfd_mmio_write,
734
734
(void *)pt, p->iovntfd_addr,
735
735
p->iovntfd_datamatch, doorbell_flags);
736
+
737
+
trace_mshv_assign_ioeventfd(pt->pt_id, p->iovntfd_addr,
738
+
p->iovntfd_length,
739
+
p->iovntfd_datamatch,
740
+
p->iovntfd_wildcard,
741
+
p->iovntfd_eventfd,
742
+
ret);
743
+
736
744
if (ret < 0)
737
745
goto unlock_fail;
738
746
···
787
779
if (!p->iovntfd_wildcard &&
788
780
p->iovntfd_datamatch != args->datamatch)
789
781
continue;
782
+
783
+
trace_mshv_deassign_ioeventfd(pt->pt_id, p->iovntfd_addr,
784
+
p->iovntfd_length,
785
+
p->iovntfd_datamatch,
786
+
p->iovntfd_wildcard,
787
+
p->iovntfd_eventfd);
790
788
791
789
hlist_del_rcu(&p->iovntfd_hnode);
792
790
synchronize_rcu();
+4
drivers/hv/mshv_irq.c
+4
drivers/hv/mshv_irq.c
+1
drivers/hv/mshv_root.h
+1
drivers/hv/mshv_root.h
+17
-5
drivers/hv/mshv_root_hv_call.c
+17
-5
drivers/hv/mshv_root_hv_call.c
···
45
45
struct hv_output_withdraw_memory *output_page;
46
46
struct page *page;
47
47
u16 completed;
48
-
unsigned long remaining = count;
49
-
u64 status;
48
+
u64 status, withdrawn = 0;
50
49
int i;
51
50
unsigned long flags;
52
51
···
54
55
return -ENOMEM;
55
56
output_page = page_address(page);
56
57
57
-
while (remaining) {
58
+
while (withdrawn < count) {
58
59
local_irq_save(flags);
59
60
60
61
input_page = *this_cpu_ptr(hyperv_pcpu_input_arg);
···
62
63
memset(input_page, 0, sizeof(*input_page));
63
64
input_page->partition_id = partition_id;
64
65
status = hv_do_rep_hypercall(HVCALL_WITHDRAW_MEMORY,
65
-
min(remaining, HV_WITHDRAW_BATCH_SIZE),
66
+
min(count - withdrawn, HV_WITHDRAW_BATCH_SIZE),
66
67
0, input_page, output_page);
67
68
68
69
local_irq_restore(flags);
···
78
79
break;
79
80
}
80
81
81
-
remaining -= completed;
82
+
withdrawn += completed;
82
83
}
83
84
free_page((unsigned long)output_page);
85
+
86
+
trace_mshv_hvcall_withdraw_memory(partition_id, withdrawn, status);
84
87
85
88
return hv_result_to_errno(status);
86
89
}
···
127
126
ret = hv_deposit_memory(hv_current_partition_id, status);
128
127
} while (!ret);
129
128
129
+
trace_mshv_hvcall_create_partition(flags, ret ? ret : *partition_id);
130
+
130
131
return ret;
131
132
}
132
133
···
156
153
ret = hv_deposit_memory(partition_id, status);
157
154
} while (!ret);
158
155
156
+
trace_mshv_hvcall_initialize_partition(partition_id, status);
157
+
159
158
return ret;
160
159
}
161
160
···
170
165
status = hv_do_fast_hypercall8(HVCALL_FINALIZE_PARTITION,
171
166
*(u64 *)&input);
172
167
168
+
trace_mshv_hvcall_finalize_partition(partition_id, status);
169
+
173
170
return hv_result_to_errno(status);
174
171
}
175
172
···
182
175
183
176
input.partition_id = partition_id;
184
177
status = hv_do_fast_hypercall8(HVCALL_DELETE_PARTITION, *(u64 *)&input);
178
+
179
+
trace_mshv_hvcall_delete_partition(partition_id, status);
185
180
186
181
return hv_result_to_errno(status);
187
182
}
···
581
572
582
573
ret = hv_deposit_memory(partition_id, status);
583
574
} while (!ret);
575
+
576
+
trace_mshv_hvcall_map_vp_state_page(partition_id, vp_index,
577
+
type, status);
584
578
585
579
return ret;
586
580
}
+68
-10
drivers/hv/mshv_root_main.c
+68
-10
drivers/hv/mshv_root_main.c
···
429
429
status = hv_do_hypercall(HVCALL_DISPATCH_VP, input, output);
430
430
vp->run.flags.root_sched_dispatched = 0;
431
431
432
+
trace_mshv_hvcall_dispatch_vp(vp->vp_partition->pt_id,
433
+
vp->vp_index, flags,
434
+
output->dispatch_state,
435
+
output->dispatch_event,
436
+
#if defined(CONFIG_X86_64)
437
+
vp->vp_register_page->interrupt_vectors.as_uint64,
438
+
#else
439
+
0,
440
+
#endif
441
+
status);
442
+
432
443
*res = *output;
433
444
preempt_enable();
434
445
···
461
450
462
451
ret = mshv_set_vp_registers(vp->vp_index, vp->vp_partition->pt_id,
463
452
1, &explicit_suspend);
453
+
454
+
trace_mshv_vp_clear_explicit_suspend(vp->vp_partition->pt_id,
455
+
vp->vp_index, ret);
464
456
465
457
if (ret)
466
458
vp_err(vp, "Failed to unsuspend\n");
···
507
493
if (ret)
508
494
return -EINTR;
509
495
496
+
trace_mshv_vp_wait_for_hv_kick(vp->vp_partition->pt_id,
497
+
vp->vp_index,
498
+
vp->run.kicked_by_hv,
499
+
mshv_vp_dispatch_thread_blocked(vp),
500
+
mshv_vp_interrupt_pending(vp));
501
+
510
502
vp->run.flags.root_sched_blocked = 0;
511
503
vp->run.kicked_by_hv = 0;
512
504
···
541
521
542
522
if (__xfer_to_guest_mode_work_pending()) {
543
523
ret = xfer_to_guest_mode_handle_work();
524
+
525
+
trace_mshv_xfer_to_guest_mode_work(vp->vp_partition->pt_id,
526
+
vp->vp_index,
527
+
read_thread_flags(),
528
+
ret);
529
+
544
530
if (ret)
545
531
break;
546
532
}
···
707
681
{
708
682
long rc;
709
683
684
+
trace_mshv_run_vp_entry(vp->vp_partition->pt_id, vp->vp_index);
685
+
710
686
do {
711
687
if (hv_scheduler_type == HV_SCHEDULER_TYPE_ROOT)
712
688
rc = mshv_run_vp_with_root_scheduler(vp);
713
689
else
714
690
rc = mshv_run_vp_with_hyp_scheduler(vp);
715
691
} while (rc == 0 && mshv_vp_handle_intercept(vp));
692
+
693
+
trace_mshv_run_vp_exit(vp->vp_partition->pt_id, vp->vp_index,
694
+
vp->vp_intercept_msg_page->header.message_type,
695
+
rc);
716
696
717
697
if (rc)
718
698
return rc;
···
981
949
{
982
950
struct mshv_vp *vp = filp->private_data;
983
951
952
+
trace_mshv_vp_release(vp->vp_partition->pt_id, vp->vp_index);
953
+
984
954
/* Rest of VP cleanup happens in destroy_partition() */
985
955
mshv_partition_put(vp->vp_partition);
986
956
return 0;
···
1155
1121
partition->pt_vp_count++;
1156
1122
partition->pt_vp_array[args.vp_index] = vp;
1157
1123
1158
-
return ret;
1124
+
goto out;
1159
1125
1160
1126
remove_debugfs_vp:
1161
1127
mshv_debugfs_vp_remove(vp);
···
1181
1147
intercept_msg_page, input_vtl_zero);
1182
1148
destroy_vp:
1183
1149
hv_call_delete_vp(partition->pt_id, args.vp_index);
1150
+
out:
1151
+
trace_mshv_create_vp(partition->pt_id, args.vp_index, ret);
1184
1152
return ret;
1185
1153
}
1186
1154
···
1381
1345
region->nr_pages);
1382
1346
break;
1383
1347
}
1348
+
1349
+
trace_mshv_map_user_memory(partition->pt_id, region->start_uaddr,
1350
+
region->start_gfn, region->nr_pages,
1351
+
region->hv_map_flags, ret);
1384
1352
1385
1353
if (ret)
1386
1354
goto errout;
···
1681
1641
if (ret)
1682
1642
vp_err(vp, "failed to suspend\n");
1683
1643
1644
+
trace_mshv_disable_vp_dispatch(vp->vp_partition->pt_id,
1645
+
vp->vp_index, ret);
1646
+
1684
1647
return ret;
1685
1648
}
1686
1649
···
1732
1689
vp->run.kicked_by_hv = 0;
1733
1690
vp_signal_count = atomic64_read(&vp->run.vp_signaled_count);
1734
1691
}
1692
+
1693
+
trace_mshv_drain_vp_signals(vp->vp_partition->pt_id, vp->vp_index);
1735
1694
}
1736
1695
1737
1696
static void drain_all_vps(const struct mshv_partition *partition)
···
1786
1741
"Attempt to destroy partition but refcount > 0\n");
1787
1742
return;
1788
1743
}
1744
+
1745
+
trace_mshv_destroy_partition(partition->pt_id);
1789
1746
1790
1747
if (partition->pt_initialized) {
1791
1748
/*
···
1894
1847
mshv_partition_release(struct inode *inode, struct file *filp)
1895
1848
{
1896
1849
struct mshv_partition *partition = filp->private_data;
1850
+
1851
+
trace_mshv_partition_release(partition->pt_id);
1897
1852
1898
1853
mshv_eventfd_release(partition);
1899
1854
···
2026
1977
struct hv_partition_creation_properties creation_properties;
2027
1978
union hv_partition_isolation_properties isolation_properties;
2028
1979
struct mshv_partition *partition;
1980
+
u64 pt_id = -1;
2029
1981
long ret;
2030
1982
2031
1983
ret = mshv_ioctl_process_pt_flags(user_arg, &creation_flags,
···
2066
2016
ret = hv_call_create_partition(creation_flags,
2067
2017
creation_properties,
2068
2018
isolation_properties,
2069
-
&partition->pt_id);
2019
+
&pt_id);
2070
2020
if (ret)
2071
2021
goto cleanup_irq_srcu;
2022
+
2023
+
partition->pt_id = pt_id;
2072
2024
2073
2025
ret = add_partition(partition);
2074
2026
if (ret)
2075
2027
goto delete_partition;
2076
2028
2077
2029
ret = mshv_init_async_handler(partition);
2078
-
if (!ret) {
2079
-
ret = FD_ADD(O_CLOEXEC, anon_inode_getfile("mshv_partition",
2080
-
&mshv_partition_fops,
2081
-
partition, O_RDWR));
2082
-
if (ret >= 0)
2083
-
return ret;
2084
-
}
2030
+
if (ret)
2031
+
goto remove_partition;
2032
+
2033
+
ret = FD_ADD(O_CLOEXEC, anon_inode_getfile("mshv_partition",
2034
+
&mshv_partition_fops,
2035
+
partition, O_RDWR));
2036
+
if (ret < 0)
2037
+
goto remove_partition;
2038
+
2039
+
goto out;
2040
+
2041
+
remove_partition:
2085
2042
remove_partition(partition);
2086
2043
delete_partition:
2087
2044
hv_call_delete_partition(partition->pt_id);
···
2096
2039
cleanup_srcu_struct(&partition->pt_irq_srcu);
2097
2040
free_partition:
2098
2041
kfree(partition);
2099
-
2042
+
out:
2043
+
trace_mshv_create_partition(pt_id, ret);
2100
2044
return ret;
2101
2045
}
2102
2046
+9
drivers/hv/mshv_trace.c
+9
drivers/hv/mshv_trace.c
+515
drivers/hv/mshv_trace.h
+515
drivers/hv/mshv_trace.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0-only */
2
+
/*
3
+
* Copyright (c) 2026, Microsoft Corporation.
4
+
*
5
+
* Tracepoint declarations for mshv driver.
6
+
*/
7
+
8
+
#undef TRACE_SYSTEM
9
+
#define TRACE_SYSTEM mshv
10
+
11
+
#if !defined(__MSHV_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
12
+
#define _MSHV_TRACE_H_
13
+
14
+
#include <linux/tracepoint.h>
15
+
16
+
#undef TRACE_INCLUDE_PATH
17
+
#define TRACE_INCLUDE_PATH ../../drivers/hv
18
+
19
+
#undef TRACE_INCLUDE_FILE
20
+
#define TRACE_INCLUDE_FILE mshv_trace
21
+
22
+
TRACE_EVENT(mshv_create_partition,
23
+
TP_PROTO(u64 partition_id, int vm_fd),
24
+
TP_ARGS(partition_id, vm_fd),
25
+
TP_STRUCT__entry(
26
+
__field(u64, partition_id)
27
+
__field(int, vm_fd)
28
+
),
29
+
TP_fast_assign(
30
+
__entry->partition_id = partition_id;
31
+
__entry->vm_fd = vm_fd;
32
+
),
33
+
TP_printk("partition_id=%llu vm_fd=%d",
34
+
__entry->partition_id,
35
+
__entry->vm_fd
36
+
)
37
+
);
38
+
39
+
TRACE_EVENT(mshv_hvcall_create_partition,
40
+
TP_PROTO(u64 flags, s64 partition_id),
41
+
TP_ARGS(flags, partition_id),
42
+
TP_STRUCT__entry(
43
+
__field(u64, flags)
44
+
__field(s64, partition_id)
45
+
),
46
+
TP_fast_assign(
47
+
__entry->flags = flags;
48
+
__entry->partition_id = partition_id;
49
+
),
50
+
TP_printk("flags=%#llx partition_id=%lld",
51
+
__entry->flags,
52
+
__entry->partition_id
53
+
)
54
+
);
55
+
56
+
TRACE_EVENT(mshv_hvcall_initialize_partition,
57
+
TP_PROTO(u64 partition_id, u64 status),
58
+
TP_ARGS(partition_id, status),
59
+
TP_STRUCT__entry(
60
+
__field(u64, partition_id)
61
+
__field(u64, status)
62
+
),
63
+
TP_fast_assign(
64
+
__entry->partition_id = partition_id;
65
+
__entry->status = status;
66
+
),
67
+
TP_printk("partition_id=%llu status=%#llx",
68
+
__entry->partition_id,
69
+
__entry->status
70
+
)
71
+
);
72
+
73
+
TRACE_EVENT(mshv_partition_release,
74
+
TP_PROTO(u64 partition_id),
75
+
TP_ARGS(partition_id),
76
+
TP_STRUCT__entry(
77
+
__field(u64, partition_id)
78
+
),
79
+
TP_fast_assign(
80
+
__entry->partition_id = partition_id;
81
+
),
82
+
TP_printk("partition_id=%llu",
83
+
__entry->partition_id
84
+
)
85
+
);
86
+
87
+
TRACE_EVENT(mshv_destroy_partition,
88
+
TP_PROTO(u64 partition_id),
89
+
TP_ARGS(partition_id),
90
+
TP_STRUCT__entry(
91
+
__field(u64, partition_id)
92
+
),
93
+
TP_fast_assign(
94
+
__entry->partition_id = partition_id;
95
+
),
96
+
TP_printk("partition_id=%llu",
97
+
__entry->partition_id
98
+
)
99
+
);
100
+
101
+
TRACE_EVENT(mshv_hvcall_finalize_partition,
102
+
TP_PROTO(u64 partition_id, u64 status),
103
+
TP_ARGS(partition_id, status),
104
+
TP_STRUCT__entry(
105
+
__field(u64, partition_id)
106
+
__field(u64, status)
107
+
),
108
+
TP_fast_assign(
109
+
__entry->partition_id = partition_id;
110
+
__entry->status = status;
111
+
),
112
+
TP_printk("partition_id=%llu status=%#llx ",
113
+
__entry->partition_id,
114
+
__entry->status
115
+
)
116
+
);
117
+
118
+
TRACE_EVENT(mshv_hvcall_withdraw_memory,
119
+
TP_PROTO(u64 partition_id, u64 withdrawn, u64 status),
120
+
TP_ARGS(partition_id, withdrawn, status),
121
+
TP_STRUCT__entry(
122
+
__field(u64, partition_id)
123
+
__field(u64, withdrawn)
124
+
__field(u64, status)
125
+
),
126
+
TP_fast_assign(
127
+
__entry->partition_id = partition_id;
128
+
__entry->withdrawn = withdrawn;
129
+
__entry->status = status;
130
+
),
131
+
TP_printk("partition_id=%llu withdrawn=%llu status=%#llx",
132
+
__entry->partition_id,
133
+
__entry->withdrawn,
134
+
__entry->status
135
+
)
136
+
);
137
+
138
+
TRACE_EVENT(mshv_hvcall_delete_partition,
139
+
TP_PROTO(u64 partition_id, u64 status),
140
+
TP_ARGS(partition_id, status),
141
+
TP_STRUCT__entry(
142
+
__field(u64, partition_id)
143
+
__field(u64, status)
144
+
),
145
+
TP_fast_assign(
146
+
__entry->partition_id = partition_id;
147
+
__entry->status = status;
148
+
),
149
+
TP_printk("partition_id=%llu status=%#llx",
150
+
__entry->partition_id,
151
+
__entry->status
152
+
)
153
+
);
154
+
155
+
TRACE_EVENT(mshv_create_vp,
156
+
TP_PROTO(u64 partition_id, u32 vp_index, long vp_fd),
157
+
TP_ARGS(partition_id, vp_index, vp_fd),
158
+
TP_STRUCT__entry(
159
+
__field(u64, partition_id)
160
+
__field(u32, vp_index)
161
+
__field(long, vp_fd)
162
+
),
163
+
TP_fast_assign(
164
+
__entry->partition_id = partition_id;
165
+
__entry->vp_index = vp_index;
166
+
__entry->vp_fd = vp_fd;
167
+
),
168
+
TP_printk("partition_id=%llu vp_index=%u vp_fd=%ld",
169
+
__entry->partition_id,
170
+
__entry->vp_index,
171
+
__entry->vp_fd
172
+
)
173
+
);
174
+
175
+
TRACE_EVENT(mshv_hvcall_map_vp_state_page,
176
+
TP_PROTO(u64 partition_id, u32 vp_index, u32 page_type, u64 status),
177
+
TP_ARGS(partition_id, vp_index, page_type, status),
178
+
TP_STRUCT__entry(
179
+
__field(u64, partition_id)
180
+
__field(u32, vp_index)
181
+
__field(u32, page_type)
182
+
__field(u64, status)
183
+
),
184
+
TP_fast_assign(
185
+
__entry->partition_id = partition_id;
186
+
__entry->vp_index = vp_index;
187
+
__entry->page_type = page_type;
188
+
__entry->status = status;
189
+
),
190
+
TP_printk("partition_id=%llu vp_index=%u page_type=%u status=%#llx",
191
+
__entry->partition_id,
192
+
__entry->vp_index,
193
+
__entry->page_type,
194
+
__entry->status
195
+
)
196
+
);
197
+
198
+
TRACE_EVENT(mshv_drain_vp_signals,
199
+
TP_PROTO(u64 partition_id, u32 vp_index),
200
+
TP_ARGS(partition_id, vp_index),
201
+
TP_STRUCT__entry(
202
+
__field(u64, partition_id)
203
+
__field(u32, vp_index)
204
+
),
205
+
TP_fast_assign(
206
+
__entry->partition_id = partition_id;
207
+
__entry->vp_index = vp_index;
208
+
),
209
+
TP_printk("partition_id=%llu vp_index=%u",
210
+
__entry->partition_id,
211
+
__entry->vp_index
212
+
)
213
+
);
214
+
215
+
TRACE_EVENT(mshv_disable_vp_dispatch,
216
+
TP_PROTO(u64 partition_id, u32 vp_index, int ret),
217
+
TP_ARGS(partition_id, vp_index, ret),
218
+
TP_STRUCT__entry(
219
+
__field(u64, partition_id)
220
+
__field(u32, vp_index)
221
+
__field(int, ret)
222
+
),
223
+
TP_fast_assign(
224
+
__entry->partition_id = partition_id;
225
+
__entry->vp_index = vp_index;
226
+
__entry->ret = ret;
227
+
),
228
+
TP_printk("partition_id=%llu vp_index=%u ret=%d",
229
+
__entry->partition_id,
230
+
__entry->vp_index,
231
+
__entry->ret
232
+
)
233
+
);
234
+
235
+
TRACE_EVENT(mshv_vp_release,
236
+
TP_PROTO(u64 partition_id, u32 vp_index),
237
+
TP_ARGS(partition_id, vp_index),
238
+
TP_STRUCT__entry(
239
+
__field(u64, partition_id)
240
+
__field(u32, vp_index)
241
+
),
242
+
TP_fast_assign(
243
+
__entry->partition_id = partition_id;
244
+
__entry->vp_index = vp_index;
245
+
),
246
+
TP_printk("partition_id=%llu vp_index=%u",
247
+
__entry->partition_id,
248
+
__entry->vp_index
249
+
)
250
+
);
251
+
252
+
TRACE_EVENT(mshv_run_vp_entry,
253
+
TP_PROTO(u64 partition_id, u32 vp_index),
254
+
TP_ARGS(partition_id, vp_index),
255
+
TP_STRUCT__entry(
256
+
__field(u64, partition_id)
257
+
__field(u32, vp_index)
258
+
),
259
+
TP_fast_assign(
260
+
__entry->partition_id = partition_id;
261
+
__entry->vp_index = vp_index;
262
+
),
263
+
TP_printk("partition_id=%llu vp_index=%u",
264
+
__entry->partition_id,
265
+
__entry->vp_index
266
+
)
267
+
);
268
+
269
+
TRACE_EVENT(mshv_run_vp_exit,
270
+
TP_PROTO(u64 partition_id, u32 vp_index, u64 hv_message_type, long ret),
271
+
TP_ARGS(partition_id, vp_index, hv_message_type, ret),
272
+
TP_STRUCT__entry(
273
+
__field(u64, partition_id)
274
+
__field(u32, vp_index)
275
+
__field(u64, hv_message_type)
276
+
__field(long, ret)
277
+
),
278
+
TP_fast_assign(
279
+
__entry->partition_id = partition_id;
280
+
__entry->vp_index = vp_index;
281
+
__entry->hv_message_type = hv_message_type;
282
+
__entry->ret = ret;
283
+
),
284
+
TP_printk("partition_id=%llu vp_index=%u hv_message_type=%#llx ret=%ld",
285
+
__entry->partition_id,
286
+
__entry->vp_index,
287
+
__entry->hv_message_type,
288
+
__entry->ret
289
+
)
290
+
);
291
+
292
+
TRACE_EVENT(mshv_vp_clear_explicit_suspend,
293
+
TP_PROTO(u64 partition_id, u32 vp_index, int ret),
294
+
TP_ARGS(partition_id, vp_index, ret),
295
+
TP_STRUCT__entry(
296
+
__field(u64, partition_id)
297
+
__field(u32, vp_index)
298
+
__field(int, ret)
299
+
),
300
+
TP_fast_assign(
301
+
__entry->partition_id = partition_id;
302
+
__entry->vp_index = vp_index;
303
+
__entry->ret = ret;
304
+
),
305
+
TP_printk("partition_id=%llu vp_index=%u ret=%d",
306
+
__entry->partition_id,
307
+
__entry->vp_index,
308
+
__entry->ret
309
+
)
310
+
);
311
+
312
+
TRACE_EVENT(mshv_xfer_to_guest_mode_work,
313
+
TP_PROTO(u64 partition_id, u32 vp_index, unsigned long thread_info_flag, long ret),
314
+
TP_ARGS(partition_id, vp_index, thread_info_flag, ret),
315
+
TP_STRUCT__entry(
316
+
__field(u64, partition_id)
317
+
__field(u32, vp_index)
318
+
__field(unsigned long, thread_info_flag)
319
+
__field(long, ret)
320
+
),
321
+
TP_fast_assign(
322
+
__entry->partition_id = partition_id;
323
+
__entry->vp_index = vp_index;
324
+
__entry->thread_info_flag = thread_info_flag;
325
+
__entry->ret = ret;
326
+
),
327
+
TP_printk("partition_id=%llu vp_index=%u thread_info_flag=%#lx ret=%ld",
328
+
__entry->partition_id,
329
+
__entry->vp_index,
330
+
__entry->thread_info_flag,
331
+
__entry->ret
332
+
)
333
+
);
334
+
335
+
TRACE_EVENT(mshv_hvcall_dispatch_vp,
336
+
TP_PROTO(u64 partition_id, u32 vp_index, u32 flags,
337
+
u32 dispatch_state, u32 dispatch_event, u64 irq_vectors, u64 status),
338
+
TP_ARGS(partition_id, vp_index, flags, dispatch_state, dispatch_event, irq_vectors,
339
+
status),
340
+
TP_STRUCT__entry(
341
+
__field(u64, partition_id)
342
+
__field(u32, vp_index)
343
+
__field(u32, flags)
344
+
__field(u32, dispatch_state)
345
+
__field(u32, dispatch_event)
346
+
__field(u64, irq_vectors)
347
+
__field(u64, status)
348
+
),
349
+
TP_fast_assign(
350
+
__entry->partition_id = partition_id;
351
+
__entry->vp_index = vp_index;
352
+
__entry->flags = flags;
353
+
__entry->dispatch_state = dispatch_state;
354
+
__entry->dispatch_event = dispatch_event;
355
+
__entry->irq_vectors = irq_vectors;
356
+
__entry->status = status;
357
+
),
358
+
TP_printk("partition_id=%llu vp_index=%u flags=%#x dispatch_state=%#x dispatch_event=%#x irq_vectors=%#016llx status=%#llx",
359
+
__entry->partition_id,
360
+
__entry->vp_index,
361
+
__entry->flags,
362
+
__entry->dispatch_state,
363
+
__entry->dispatch_event,
364
+
__entry->irq_vectors,
365
+
__entry->status
366
+
)
367
+
);
368
+
369
+
TRACE_EVENT(mshv_update_routing_table,
370
+
TP_PROTO(u64 partition_id, void *old, void *new, u32 numents),
371
+
TP_ARGS(partition_id, old, new, numents),
372
+
TP_STRUCT__entry(
373
+
__field(u64, partition_id)
374
+
__field(struct mshv_girq_routing_table *, old)
375
+
__field(struct mshv_girq_routing_table *, new)
376
+
__field(u32, numents)
377
+
),
378
+
TP_fast_assign(
379
+
__entry->partition_id = partition_id;
380
+
__entry->old = old;
381
+
__entry->new = new;
382
+
__entry->numents = numents;
383
+
),
384
+
TP_printk("partition_id=%llu old=%p new=%p numents=%u",
385
+
__entry->partition_id,
386
+
__entry->old,
387
+
__entry->new,
388
+
__entry->numents
389
+
)
390
+
);
391
+
392
+
TRACE_EVENT(mshv_map_user_memory,
393
+
TP_PROTO(u64 partition_id, u64 start_uaddr, u64 start_gfn, u64 nr_pages, u32 map_flags,
394
+
long ret),
395
+
TP_ARGS(partition_id, start_uaddr, start_gfn, nr_pages, map_flags, ret),
396
+
TP_STRUCT__entry(
397
+
__field(u64, partition_id)
398
+
__field(u64, start_uaddr)
399
+
__field(u64, start_gfn)
400
+
__field(u64, nr_pages)
401
+
__field(u32, map_flags)
402
+
__field(long, ret)
403
+
),
404
+
TP_fast_assign(
405
+
__entry->partition_id = partition_id;
406
+
__entry->start_uaddr = start_uaddr;
407
+
__entry->start_gfn = start_gfn;
408
+
__entry->nr_pages = nr_pages;
409
+
__entry->map_flags = map_flags;
410
+
__entry->ret = ret;
411
+
),
412
+
TP_printk("partition_id=%llu start_uaddr=%#llx start_gfn=%#llx nr_pages=%llu map_flags=%#x ret=%ld",
413
+
__entry->partition_id,
414
+
__entry->start_uaddr,
415
+
__entry->start_gfn,
416
+
__entry->nr_pages,
417
+
__entry->map_flags,
418
+
__entry->ret
419
+
)
420
+
);
421
+
422
+
TRACE_EVENT(mshv_assign_ioeventfd,
423
+
TP_PROTO(u64 partition_id, u64 addr, u64 length, u64 datamatch, bool wildcard,
424
+
void *eventfd, int ret),
425
+
TP_ARGS(partition_id, addr, length, datamatch, wildcard, eventfd, ret),
426
+
TP_STRUCT__entry(
427
+
__field(u64, partition_id)
428
+
__field(u64, addr)
429
+
__field(u64, length)
430
+
__field(u64, datamatch)
431
+
__field(bool, wildcard)
432
+
__field(struct eventfd_ctx *, eventfd)
433
+
__field(int, ret)
434
+
),
435
+
TP_fast_assign(
436
+
__entry->partition_id = partition_id;
437
+
__entry->addr = addr;
438
+
__entry->length = length;
439
+
__entry->datamatch = datamatch;
440
+
__entry->wildcard = wildcard;
441
+
__entry->eventfd = eventfd;
442
+
__entry->ret = ret;
443
+
),
444
+
TP_printk("partition_id=%llu addr=%#016llx length=%#llx datamatch=%#llx wildcard=%d eventfd=%p ret=%d",
445
+
__entry->partition_id,
446
+
__entry->addr,
447
+
__entry->length,
448
+
__entry->datamatch,
449
+
__entry->wildcard,
450
+
__entry->eventfd,
451
+
__entry->ret
452
+
)
453
+
);
454
+
455
+
TRACE_EVENT(mshv_deassign_ioeventfd,
456
+
TP_PROTO(u64 partition_id, u64 addr, u64 length, u64 datamatch, bool wildcard,
457
+
void *eventfd),
458
+
TP_ARGS(partition_id, addr, length, datamatch, wildcard, eventfd),
459
+
TP_STRUCT__entry(
460
+
__field(u64, partition_id)
461
+
__field(u64, addr)
462
+
__field(u64, length)
463
+
__field(u64, datamatch)
464
+
__field(bool, wildcard)
465
+
__field(struct eventfd_ctx *, eventfd)
466
+
),
467
+
TP_fast_assign(
468
+
__entry->partition_id = partition_id;
469
+
__entry->addr = addr;
470
+
__entry->length = length;
471
+
__entry->datamatch = datamatch;
472
+
__entry->wildcard = wildcard;
473
+
__entry->eventfd = eventfd;
474
+
),
475
+
TP_printk("partition_id=%llu addr=%#016llx length=%#llx datamatch=%#llx wildcard=%d eventfd=%p",
476
+
__entry->partition_id,
477
+
__entry->addr,
478
+
__entry->length,
479
+
__entry->datamatch,
480
+
__entry->wildcard,
481
+
__entry->eventfd
482
+
)
483
+
);
484
+
485
+
TRACE_EVENT(mshv_vp_wait_for_hv_kick,
486
+
TP_PROTO(u64 partition_id, u32 vp_index, bool kicked_by_hv, bool blocked,
487
+
bool irq_pending),
488
+
TP_ARGS(partition_id, vp_index, kicked_by_hv, blocked, irq_pending),
489
+
TP_STRUCT__entry(
490
+
__field(u64, partition_id)
491
+
__field(u32, vp_index)
492
+
__field(bool, kicked_by_hv)
493
+
__field(bool, blocked)
494
+
__field(bool, irq_pending)
495
+
),
496
+
TP_fast_assign(
497
+
__entry->partition_id = partition_id;
498
+
__entry->vp_index = vp_index;
499
+
__entry->kicked_by_hv = kicked_by_hv;
500
+
__entry->blocked = blocked;
501
+
__entry->irq_pending = irq_pending;
502
+
),
503
+
TP_printk("partition_id=%llu vp_index=%u kicked_by_hv=%d blocked=%d irq_pending=%d",
504
+
__entry->partition_id,
505
+
__entry->vp_index,
506
+
__entry->kicked_by_hv,
507
+
__entry->blocked,
508
+
__entry->irq_pending
509
+
)
510
+
);
511
+
512
+
#endif /* _MSHV_TRACE_H_ */
513
+
514
+
/* This part must be outside protection */
515
+
#include <trace/define_trace.h>