Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM fs_dax
0004 
0005 #if !defined(_TRACE_FS_DAX_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_FS_DAX_H
0007 
0008 #include <linux/tracepoint.h>
0009 
0010 DECLARE_EVENT_CLASS(dax_pmd_fault_class,
0011     TP_PROTO(struct inode *inode, struct vm_fault *vmf,
0012         pgoff_t max_pgoff, int result),
0013     TP_ARGS(inode, vmf, max_pgoff, result),
0014     TP_STRUCT__entry(
0015         __field(unsigned long, ino)
0016         __field(unsigned long, vm_start)
0017         __field(unsigned long, vm_end)
0018         __field(unsigned long, vm_flags)
0019         __field(unsigned long, address)
0020         __field(pgoff_t, pgoff)
0021         __field(pgoff_t, max_pgoff)
0022         __field(dev_t, dev)
0023         __field(unsigned int, flags)
0024         __field(int, result)
0025     ),
0026     TP_fast_assign(
0027         __entry->dev = inode->i_sb->s_dev;
0028         __entry->ino = inode->i_ino;
0029         __entry->vm_start = vmf->vma->vm_start;
0030         __entry->vm_end = vmf->vma->vm_end;
0031         __entry->vm_flags = vmf->vma->vm_flags;
0032         __entry->address = vmf->address;
0033         __entry->flags = vmf->flags;
0034         __entry->pgoff = vmf->pgoff;
0035         __entry->max_pgoff = max_pgoff;
0036         __entry->result = result;
0037     ),
0038     TP_printk("dev %d:%d ino %#lx %s %s address %#lx vm_start "
0039             "%#lx vm_end %#lx pgoff %#lx max_pgoff %#lx %s",
0040         MAJOR(__entry->dev),
0041         MINOR(__entry->dev),
0042         __entry->ino,
0043         __entry->vm_flags & VM_SHARED ? "shared" : "private",
0044         __print_flags(__entry->flags, "|", FAULT_FLAG_TRACE),
0045         __entry->address,
0046         __entry->vm_start,
0047         __entry->vm_end,
0048         __entry->pgoff,
0049         __entry->max_pgoff,
0050         __print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE)
0051     )
0052 )
0053 
0054 #define DEFINE_PMD_FAULT_EVENT(name) \
0055 DEFINE_EVENT(dax_pmd_fault_class, name, \
0056     TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
0057         pgoff_t max_pgoff, int result), \
0058     TP_ARGS(inode, vmf, max_pgoff, result))
0059 
0060 DEFINE_PMD_FAULT_EVENT(dax_pmd_fault);
0061 DEFINE_PMD_FAULT_EVENT(dax_pmd_fault_done);
0062 
0063 DECLARE_EVENT_CLASS(dax_pmd_load_hole_class,
0064     TP_PROTO(struct inode *inode, struct vm_fault *vmf,
0065         struct page *zero_page,
0066         void *radix_entry),
0067     TP_ARGS(inode, vmf, zero_page, radix_entry),
0068     TP_STRUCT__entry(
0069         __field(unsigned long, ino)
0070         __field(unsigned long, vm_flags)
0071         __field(unsigned long, address)
0072         __field(struct page *, zero_page)
0073         __field(void *, radix_entry)
0074         __field(dev_t, dev)
0075     ),
0076     TP_fast_assign(
0077         __entry->dev = inode->i_sb->s_dev;
0078         __entry->ino = inode->i_ino;
0079         __entry->vm_flags = vmf->vma->vm_flags;
0080         __entry->address = vmf->address;
0081         __entry->zero_page = zero_page;
0082         __entry->radix_entry = radix_entry;
0083     ),
0084     TP_printk("dev %d:%d ino %#lx %s address %#lx zero_page %p "
0085             "radix_entry %#lx",
0086         MAJOR(__entry->dev),
0087         MINOR(__entry->dev),
0088         __entry->ino,
0089         __entry->vm_flags & VM_SHARED ? "shared" : "private",
0090         __entry->address,
0091         __entry->zero_page,
0092         (unsigned long)__entry->radix_entry
0093     )
0094 )
0095 
0096 #define DEFINE_PMD_LOAD_HOLE_EVENT(name) \
0097 DEFINE_EVENT(dax_pmd_load_hole_class, name, \
0098     TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
0099         struct page *zero_page, void *radix_entry), \
0100     TP_ARGS(inode, vmf, zero_page, radix_entry))
0101 
0102 DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole);
0103 DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole_fallback);
0104 
0105 DECLARE_EVENT_CLASS(dax_pmd_insert_mapping_class,
0106     TP_PROTO(struct inode *inode, struct vm_fault *vmf,
0107         long length, pfn_t pfn, void *radix_entry),
0108     TP_ARGS(inode, vmf, length, pfn, radix_entry),
0109     TP_STRUCT__entry(
0110         __field(unsigned long, ino)
0111         __field(unsigned long, vm_flags)
0112         __field(unsigned long, address)
0113         __field(long, length)
0114         __field(u64, pfn_val)
0115         __field(void *, radix_entry)
0116         __field(dev_t, dev)
0117         __field(int, write)
0118     ),
0119     TP_fast_assign(
0120         __entry->dev = inode->i_sb->s_dev;
0121         __entry->ino = inode->i_ino;
0122         __entry->vm_flags = vmf->vma->vm_flags;
0123         __entry->address = vmf->address;
0124         __entry->write = vmf->flags & FAULT_FLAG_WRITE;
0125         __entry->length = length;
0126         __entry->pfn_val = pfn.val;
0127         __entry->radix_entry = radix_entry;
0128     ),
0129     TP_printk("dev %d:%d ino %#lx %s %s address %#lx length %#lx "
0130             "pfn %#llx %s radix_entry %#lx",
0131         MAJOR(__entry->dev),
0132         MINOR(__entry->dev),
0133         __entry->ino,
0134         __entry->vm_flags & VM_SHARED ? "shared" : "private",
0135         __entry->write ? "write" : "read",
0136         __entry->address,
0137         __entry->length,
0138         __entry->pfn_val & ~PFN_FLAGS_MASK,
0139         __print_flags_u64(__entry->pfn_val & PFN_FLAGS_MASK, "|",
0140             PFN_FLAGS_TRACE),
0141         (unsigned long)__entry->radix_entry
0142     )
0143 )
0144 
0145 #define DEFINE_PMD_INSERT_MAPPING_EVENT(name) \
0146 DEFINE_EVENT(dax_pmd_insert_mapping_class, name, \
0147     TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
0148         long length, pfn_t pfn, void *radix_entry), \
0149     TP_ARGS(inode, vmf, length, pfn, radix_entry))
0150 
0151 DEFINE_PMD_INSERT_MAPPING_EVENT(dax_pmd_insert_mapping);
0152 
0153 DECLARE_EVENT_CLASS(dax_pte_fault_class,
0154     TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result),
0155     TP_ARGS(inode, vmf, result),
0156     TP_STRUCT__entry(
0157         __field(unsigned long, ino)
0158         __field(unsigned long, vm_flags)
0159         __field(unsigned long, address)
0160         __field(pgoff_t, pgoff)
0161         __field(dev_t, dev)
0162         __field(unsigned int, flags)
0163         __field(int, result)
0164     ),
0165     TP_fast_assign(
0166         __entry->dev = inode->i_sb->s_dev;
0167         __entry->ino = inode->i_ino;
0168         __entry->vm_flags = vmf->vma->vm_flags;
0169         __entry->address = vmf->address;
0170         __entry->flags = vmf->flags;
0171         __entry->pgoff = vmf->pgoff;
0172         __entry->result = result;
0173     ),
0174     TP_printk("dev %d:%d ino %#lx %s %s address %#lx pgoff %#lx %s",
0175         MAJOR(__entry->dev),
0176         MINOR(__entry->dev),
0177         __entry->ino,
0178         __entry->vm_flags & VM_SHARED ? "shared" : "private",
0179         __print_flags(__entry->flags, "|", FAULT_FLAG_TRACE),
0180         __entry->address,
0181         __entry->pgoff,
0182         __print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE)
0183     )
0184 )
0185 
0186 #define DEFINE_PTE_FAULT_EVENT(name) \
0187 DEFINE_EVENT(dax_pte_fault_class, name, \
0188     TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result), \
0189     TP_ARGS(inode, vmf, result))
0190 
0191 DEFINE_PTE_FAULT_EVENT(dax_pte_fault);
0192 DEFINE_PTE_FAULT_EVENT(dax_pte_fault_done);
0193 DEFINE_PTE_FAULT_EVENT(dax_load_hole);
0194 DEFINE_PTE_FAULT_EVENT(dax_insert_pfn_mkwrite_no_entry);
0195 DEFINE_PTE_FAULT_EVENT(dax_insert_pfn_mkwrite);
0196 
0197 TRACE_EVENT(dax_insert_mapping,
0198     TP_PROTO(struct inode *inode, struct vm_fault *vmf, void *radix_entry),
0199     TP_ARGS(inode, vmf, radix_entry),
0200     TP_STRUCT__entry(
0201         __field(unsigned long, ino)
0202         __field(unsigned long, vm_flags)
0203         __field(unsigned long, address)
0204         __field(void *, radix_entry)
0205         __field(dev_t, dev)
0206         __field(int, write)
0207     ),
0208     TP_fast_assign(
0209         __entry->dev = inode->i_sb->s_dev;
0210         __entry->ino = inode->i_ino;
0211         __entry->vm_flags = vmf->vma->vm_flags;
0212         __entry->address = vmf->address;
0213         __entry->write = vmf->flags & FAULT_FLAG_WRITE;
0214         __entry->radix_entry = radix_entry;
0215     ),
0216     TP_printk("dev %d:%d ino %#lx %s %s address %#lx radix_entry %#lx",
0217         MAJOR(__entry->dev),
0218         MINOR(__entry->dev),
0219         __entry->ino,
0220         __entry->vm_flags & VM_SHARED ? "shared" : "private",
0221         __entry->write ? "write" : "read",
0222         __entry->address,
0223         (unsigned long)__entry->radix_entry
0224     )
0225 )
0226 
0227 DECLARE_EVENT_CLASS(dax_writeback_range_class,
0228     TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),
0229     TP_ARGS(inode, start_index, end_index),
0230     TP_STRUCT__entry(
0231         __field(unsigned long, ino)
0232         __field(pgoff_t, start_index)
0233         __field(pgoff_t, end_index)
0234         __field(dev_t, dev)
0235     ),
0236     TP_fast_assign(
0237         __entry->dev = inode->i_sb->s_dev;
0238         __entry->ino = inode->i_ino;
0239         __entry->start_index = start_index;
0240         __entry->end_index = end_index;
0241     ),
0242     TP_printk("dev %d:%d ino %#lx pgoff %#lx-%#lx",
0243         MAJOR(__entry->dev),
0244         MINOR(__entry->dev),
0245         __entry->ino,
0246         __entry->start_index,
0247         __entry->end_index
0248     )
0249 )
0250 
0251 #define DEFINE_WRITEBACK_RANGE_EVENT(name) \
0252 DEFINE_EVENT(dax_writeback_range_class, name, \
0253     TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),\
0254     TP_ARGS(inode, start_index, end_index))
0255 
0256 DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range);
0257 DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range_done);
0258 
0259 TRACE_EVENT(dax_writeback_one,
0260     TP_PROTO(struct inode *inode, pgoff_t pgoff, pgoff_t pglen),
0261     TP_ARGS(inode, pgoff, pglen),
0262     TP_STRUCT__entry(
0263         __field(unsigned long, ino)
0264         __field(pgoff_t, pgoff)
0265         __field(pgoff_t, pglen)
0266         __field(dev_t, dev)
0267     ),
0268     TP_fast_assign(
0269         __entry->dev = inode->i_sb->s_dev;
0270         __entry->ino = inode->i_ino;
0271         __entry->pgoff = pgoff;
0272         __entry->pglen = pglen;
0273     ),
0274     TP_printk("dev %d:%d ino %#lx pgoff %#lx pglen %#lx",
0275         MAJOR(__entry->dev),
0276         MINOR(__entry->dev),
0277         __entry->ino,
0278         __entry->pgoff,
0279         __entry->pglen
0280     )
0281 )
0282 
0283 #endif /* _TRACE_FS_DAX_H */
0284 
0285 /* This part must be outside protection */
0286 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!