Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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
··· 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
··· 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
··· 71 71 mutex_unlock(&partition->pt_irq_lock); 72 72 73 73 synchronize_srcu_expedited(&partition->pt_irq_srcu); 74 + 75 + trace_mshv_update_routing_table(partition->pt_id, 76 + old, new, numents); 77 + 74 78 new = old; 75 79 76 80 out:
+1
drivers/hv/mshv_root.h
··· 17 17 #include <linux/build_bug.h> 18 18 #include <linux/mmu_notifier.h> 19 19 #include <uapi/linux/mshv.h> 20 + #include "mshv_trace.h" 20 21 21 22 /* 22 23 * Hypervisor must be between these version numbers (inclusive)
+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
··· 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
··· 1 + // SPDX-License-Identifier: GPL-2.0 2 + /* 3 + * Copyright (c) 2026, Microsoft Corporation. 4 + * 5 + * Tracepoint definitions for mshv driver. 6 + */ 7 + 8 + #define CREATE_TRACE_POINTS 9 + #include "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>