1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #undef TRACE_SYSTEM 3 #define TRACE_SYSTEM fs_dax 4 5 #if !defined(_TRACE_FS_DAX_H) || defined(TRACE_HEADER_MULTI_READ) 6 #define _TRACE_FS_DAX_H 7 8 #include <linux/tracepoint.h> 9 10 DECLARE_EVENT_CLASS(dax_pmd_fault_class, 11 TP_PROTO(struct inode *inode, struct vm_fault *vmf, 12 pgoff_t max_pgoff, int result), 13 TP_ARGS(inode, vmf, max_pgoff, result), 14 TP_STRUCT__entry( 15 __field(unsigned long, ino) 16 __field(unsigned long, vm_start) 17 __field(unsigned long, vm_end) 18 __field(unsigned long, vm_flags) 19 __field(unsigned long, address) 20 __field(pgoff_t, pgoff) 21 __field(pgoff_t, max_pgoff) 22 __field(dev_t, dev) 23 __field(unsigned int, flags) 24 __field(int, result) 25 ), 26 TP_fast_assign( 27 __entry->dev = inode->i_sb->s_dev; 28 __entry->ino = inode->i_ino; 29 __entry->vm_start = vmf->vma->vm_start; 30 __entry->vm_end = vmf->vma->vm_end; 31 __entry->vm_flags = vmf->vma->vm_flags; 32 __entry->address = vmf->address; 33 __entry->flags = vmf->flags; 34 __entry->pgoff = vmf->pgoff; 35 __entry->max_pgoff = max_pgoff; 36 __entry->result = result; 37 ), 38 TP_printk("dev %d:%d ino %#lx %s %s address %#lx vm_start " 39 "%#lx vm_end %#lx pgoff %#lx max_pgoff %#lx %s", 40 MAJOR(__entry->dev), 41 MINOR(__entry->dev), 42 __entry->ino, 43 __entry->vm_flags & VM_SHARED ? "shared" : "private", 44 __print_flags(__entry->flags, "|", FAULT_FLAG_TRACE), 45 __entry->address, 46 __entry->vm_start, 47 __entry->vm_end, 48 __entry->pgoff, 49 __entry->max_pgoff, 50 __print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE) 51 ) 52 ) 53 54 #define DEFINE_PMD_FAULT_EVENT(name) \ 55 DEFINE_EVENT(dax_pmd_fault_class, name, \ 56 TP_PROTO(struct inode *inode, struct vm_fault *vmf, \ 57 pgoff_t max_pgoff, int result), \ 58 TP_ARGS(inode, vmf, max_pgoff, result)) 59 60 DEFINE_PMD_FAULT_EVENT(dax_pmd_fault); 61 DEFINE_PMD_FAULT_EVENT(dax_pmd_fault_done); 62 63 DECLARE_EVENT_CLASS(dax_pmd_load_hole_class, 64 TP_PROTO(struct inode *inode, struct vm_fault *vmf, 65 struct page *zero_page, 66 void *radix_entry), 67 TP_ARGS(inode, vmf, zero_page, radix_entry), 68 TP_STRUCT__entry( 69 __field(unsigned long, ino) 70 __field(unsigned long, vm_flags) 71 __field(unsigned long, address) 72 __field(struct page *, zero_page) 73 __field(void *, radix_entry) 74 __field(dev_t, dev) 75 ), 76 TP_fast_assign( 77 __entry->dev = inode->i_sb->s_dev; 78 __entry->ino = inode->i_ino; 79 __entry->vm_flags = vmf->vma->vm_flags; 80 __entry->address = vmf->address; 81 __entry->zero_page = zero_page; 82 __entry->radix_entry = radix_entry; 83 ), 84 TP_printk("dev %d:%d ino %#lx %s address %#lx zero_page %p " 85 "radix_entry %#lx", 86 MAJOR(__entry->dev), 87 MINOR(__entry->dev), 88 __entry->ino, 89 __entry->vm_flags & VM_SHARED ? "shared" : "private", 90 __entry->address, 91 __entry->zero_page, 92 (unsigned long)__entry->radix_entry 93 ) 94 ) 95 96 #define DEFINE_PMD_LOAD_HOLE_EVENT(name) \ 97 DEFINE_EVENT(dax_pmd_load_hole_class, name, \ 98 TP_PROTO(struct inode *inode, struct vm_fault *vmf, \ 99 struct page *zero_page, void *radix_entry), \ 100 TP_ARGS(inode, vmf, zero_page, radix_entry)) 101 102 DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole); 103 DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole_fallback); 104 105 DECLARE_EVENT_CLASS(dax_pmd_insert_mapping_class, 106 TP_PROTO(struct inode *inode, struct vm_fault *vmf, 107 long length, pfn_t pfn, void *radix_entry), 108 TP_ARGS(inode, vmf, length, pfn, radix_entry), 109 TP_STRUCT__entry( 110 __field(unsigned long, ino) 111 __field(unsigned long, vm_flags) 112 __field(unsigned long, address) 113 __field(long, length) 114 __field(u64, pfn_val) 115 __field(void *, radix_entry) 116 __field(dev_t, dev) 117 __field(int, write) 118 ), 119 TP_fast_assign( 120 __entry->dev = inode->i_sb->s_dev; 121 __entry->ino = inode->i_ino; 122 __entry->vm_flags = vmf->vma->vm_flags; 123 __entry->address = vmf->address; 124 __entry->write = vmf->flags & FAULT_FLAG_WRITE; 125 __entry->length = length; 126 __entry->pfn_val = pfn.val; 127 __entry->radix_entry = radix_entry; 128 ), 129 TP_printk("dev %d:%d ino %#lx %s %s address %#lx length %#lx " 130 "pfn %#llx %s radix_entry %#lx", 131 MAJOR(__entry->dev), 132 MINOR(__entry->dev), 133 __entry->ino, 134 __entry->vm_flags & VM_SHARED ? "shared" : "private", 135 __entry->write ? "write" : "read", 136 __entry->address, 137 __entry->length, 138 __entry->pfn_val & ~PFN_FLAGS_MASK, 139 __print_flags_u64(__entry->pfn_val & PFN_FLAGS_MASK, "|", 140 PFN_FLAGS_TRACE), 141 (unsigned long)__entry->radix_entry 142 ) 143 ) 144 145 #define DEFINE_PMD_INSERT_MAPPING_EVENT(name) \ 146 DEFINE_EVENT(dax_pmd_insert_mapping_class, name, \ 147 TP_PROTO(struct inode *inode, struct vm_fault *vmf, \ 148 long length, pfn_t pfn, void *radix_entry), \ 149 TP_ARGS(inode, vmf, length, pfn, radix_entry)) 150 151 DEFINE_PMD_INSERT_MAPPING_EVENT(dax_pmd_insert_mapping); 152 DEFINE_PMD_INSERT_MAPPING_EVENT(dax_pmd_insert_mapping_fallback); 153 154 DECLARE_EVENT_CLASS(dax_pte_fault_class, 155 TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result), 156 TP_ARGS(inode, vmf, result), 157 TP_STRUCT__entry( 158 __field(unsigned long, ino) 159 __field(unsigned long, vm_flags) 160 __field(unsigned long, address) 161 __field(pgoff_t, pgoff) 162 __field(dev_t, dev) 163 __field(unsigned int, flags) 164 __field(int, result) 165 ), 166 TP_fast_assign( 167 __entry->dev = inode->i_sb->s_dev; 168 __entry->ino = inode->i_ino; 169 __entry->vm_flags = vmf->vma->vm_flags; 170 __entry->address = vmf->address; 171 __entry->flags = vmf->flags; 172 __entry->pgoff = vmf->pgoff; 173 __entry->result = result; 174 ), 175 TP_printk("dev %d:%d ino %#lx %s %s address %#lx pgoff %#lx %s", 176 MAJOR(__entry->dev), 177 MINOR(__entry->dev), 178 __entry->ino, 179 __entry->vm_flags & VM_SHARED ? "shared" : "private", 180 __print_flags(__entry->flags, "|", FAULT_FLAG_TRACE), 181 __entry->address, 182 __entry->pgoff, 183 __print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE) 184 ) 185 ) 186 187 #define DEFINE_PTE_FAULT_EVENT(name) \ 188 DEFINE_EVENT(dax_pte_fault_class, name, \ 189 TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result), \ 190 TP_ARGS(inode, vmf, result)) 191 192 DEFINE_PTE_FAULT_EVENT(dax_pte_fault); 193 DEFINE_PTE_FAULT_EVENT(dax_pte_fault_done); 194 DEFINE_PTE_FAULT_EVENT(dax_load_hole); 195 196 TRACE_EVENT(dax_insert_mapping, 197 TP_PROTO(struct inode *inode, struct vm_fault *vmf, void *radix_entry), 198 TP_ARGS(inode, vmf, radix_entry), 199 TP_STRUCT__entry( 200 __field(unsigned long, ino) 201 __field(unsigned long, vm_flags) 202 __field(unsigned long, address) 203 __field(void *, radix_entry) 204 __field(dev_t, dev) 205 __field(int, write) 206 ), 207 TP_fast_assign( 208 __entry->dev = inode->i_sb->s_dev; 209 __entry->ino = inode->i_ino; 210 __entry->vm_flags = vmf->vma->vm_flags; 211 __entry->address = vmf->address; 212 __entry->write = vmf->flags & FAULT_FLAG_WRITE; 213 __entry->radix_entry = radix_entry; 214 ), 215 TP_printk("dev %d:%d ino %#lx %s %s address %#lx radix_entry %#lx", 216 MAJOR(__entry->dev), 217 MINOR(__entry->dev), 218 __entry->ino, 219 __entry->vm_flags & VM_SHARED ? "shared" : "private", 220 __entry->write ? "write" : "read", 221 __entry->address, 222 (unsigned long)__entry->radix_entry 223 ) 224 ) 225 226 DECLARE_EVENT_CLASS(dax_writeback_range_class, 227 TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index), 228 TP_ARGS(inode, start_index, end_index), 229 TP_STRUCT__entry( 230 __field(unsigned long, ino) 231 __field(pgoff_t, start_index) 232 __field(pgoff_t, end_index) 233 __field(dev_t, dev) 234 ), 235 TP_fast_assign( 236 __entry->dev = inode->i_sb->s_dev; 237 __entry->ino = inode->i_ino; 238 __entry->start_index = start_index; 239 __entry->end_index = end_index; 240 ), 241 TP_printk("dev %d:%d ino %#lx pgoff %#lx-%#lx", 242 MAJOR(__entry->dev), 243 MINOR(__entry->dev), 244 __entry->ino, 245 __entry->start_index, 246 __entry->end_index 247 ) 248 ) 249 250 #define DEFINE_WRITEBACK_RANGE_EVENT(name) \ 251 DEFINE_EVENT(dax_writeback_range_class, name, \ 252 TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),\ 253 TP_ARGS(inode, start_index, end_index)) 254 255 DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range); 256 DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range_done); 257 258 TRACE_EVENT(dax_writeback_one, 259 TP_PROTO(struct inode *inode, pgoff_t pgoff, pgoff_t pglen), 260 TP_ARGS(inode, pgoff, pglen), 261 TP_STRUCT__entry( 262 __field(unsigned long, ino) 263 __field(pgoff_t, pgoff) 264 __field(pgoff_t, pglen) 265 __field(dev_t, dev) 266 ), 267 TP_fast_assign( 268 __entry->dev = inode->i_sb->s_dev; 269 __entry->ino = inode->i_ino; 270 __entry->pgoff = pgoff; 271 __entry->pglen = pglen; 272 ), 273 TP_printk("dev %d:%d ino %#lx pgoff %#lx pglen %#lx", 274 MAJOR(__entry->dev), 275 MINOR(__entry->dev), 276 __entry->ino, 277 __entry->pgoff, 278 __entry->pglen 279 ) 280 ) 281 282 #endif /* _TRACE_FS_DAX_H */ 283 284 /* This part must be outside protection */ 285 #include <trace/define_trace.h> 286