[mirror_ubuntu-bionic-kernel.git] / include / trace / events / fs_dax.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM fs_dax

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

#include <linux/tracepoint.h>

DECLARE_EVENT_CLASS(dax_pmd_fault_class,
	TP_PROTO(struct inode *inode, struct vm_fault *vmf,
		pgoff_t max_pgoff, int result),
	TP_ARGS(inode, vmf, max_pgoff, result),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(unsigned long, vm_start)
		__field(unsigned long, vm_end)
		__field(unsigned long, vm_flags)
		__field(unsigned long, address)
		__field(pgoff_t, pgoff)
		__field(pgoff_t, max_pgoff)
		__field(dev_t, dev)
		__field(unsigned int, flags)
		__field(int, result)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->vm_start = vmf->vma->vm_start;
		__entry->vm_end = vmf->vma->vm_end;
		__entry->vm_flags = vmf->vma->vm_flags;
		__entry->address = vmf->address;
		__entry->flags = vmf->flags;
		__entry->pgoff = vmf->pgoff;
		__entry->max_pgoff = max_pgoff;
		__entry->result = result;
	),
	TP_printk("dev %d:%d ino %#lx %s %s address %#lx vm_start "
			"%#lx vm_end %#lx pgoff %#lx max_pgoff %#lx %s",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->vm_flags & VM_SHARED ? "shared" : "private",
		__print_flags(__entry->flags, "|", FAULT_FLAG_TRACE),
		__entry->address,
		__entry->vm_start,
		__entry->vm_end,
		__entry->pgoff,
		__entry->max_pgoff,
		__print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE)
	)
)

#define DEFINE_PMD_FAULT_EVENT(name) \
DEFINE_EVENT(dax_pmd_fault_class, name, \
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
		pgoff_t max_pgoff, int result), \
	TP_ARGS(inode, vmf, max_pgoff, result))

DEFINE_PMD_FAULT_EVENT(dax_pmd_fault);
DEFINE_PMD_FAULT_EVENT(dax_pmd_fault_done);

DECLARE_EVENT_CLASS(dax_pmd_load_hole_class,
	TP_PROTO(struct inode *inode, struct vm_fault *vmf,
		struct page *zero_page,
		void *radix_entry),
	TP_ARGS(inode, vmf, zero_page, radix_entry),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(unsigned long, vm_flags)
		__field(unsigned long, address)
		__field(struct page *, zero_page)
		__field(void *, radix_entry)
		__field(dev_t, dev)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->vm_flags = vmf->vma->vm_flags;
		__entry->address = vmf->address;
		__entry->zero_page = zero_page;
		__entry->radix_entry = radix_entry;
	),
	TP_printk("dev %d:%d ino %#lx %s address %#lx zero_page %p "
			"radix_entry %#lx",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->vm_flags & VM_SHARED ? "shared" : "private",
		__entry->address,
		__entry->zero_page,
		(unsigned long)__entry->radix_entry
	)
)

#define DEFINE_PMD_LOAD_HOLE_EVENT(name) \
DEFINE_EVENT(dax_pmd_load_hole_class, name, \
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
		struct page *zero_page, void *radix_entry), \
	TP_ARGS(inode, vmf, zero_page, radix_entry))

DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole);
DEFINE_PMD_LOAD_HOLE_EVENT(dax_pmd_load_hole_fallback);

DECLARE_EVENT_CLASS(dax_pmd_insert_mapping_class,
	TP_PROTO(struct inode *inode, struct vm_fault *vmf,
		long length, pfn_t pfn, void *radix_entry),
	TP_ARGS(inode, vmf, length, pfn, radix_entry),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(unsigned long, vm_flags)
		__field(unsigned long, address)
		__field(long, length)
		__field(u64, pfn_val)
		__field(void *, radix_entry)
		__field(dev_t, dev)
		__field(int, write)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->vm_flags = vmf->vma->vm_flags;
		__entry->address = vmf->address;
		__entry->write = vmf->flags & FAULT_FLAG_WRITE;
		__entry->length = length;
		__entry->pfn_val = pfn.val;
		__entry->radix_entry = radix_entry;
	),
	TP_printk("dev %d:%d ino %#lx %s %s address %#lx length %#lx "
			"pfn %#llx %s radix_entry %#lx",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->vm_flags & VM_SHARED ? "shared" : "private",
		__entry->write ? "write" : "read",
		__entry->address,
		__entry->length,
		__entry->pfn_val & ~PFN_FLAGS_MASK,
		__print_flags_u64(__entry->pfn_val & PFN_FLAGS_MASK, "|",
			PFN_FLAGS_TRACE),
		(unsigned long)__entry->radix_entry
	)
)

#define DEFINE_PMD_INSERT_MAPPING_EVENT(name) \
DEFINE_EVENT(dax_pmd_insert_mapping_class, name, \
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, \
		long length, pfn_t pfn, void *radix_entry), \
	TP_ARGS(inode, vmf, length, pfn, radix_entry))

DEFINE_PMD_INSERT_MAPPING_EVENT(dax_pmd_insert_mapping);

DECLARE_EVENT_CLASS(dax_pte_fault_class,
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result),
	TP_ARGS(inode, vmf, result),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(unsigned long, vm_flags)
		__field(unsigned long, address)
		__field(pgoff_t, pgoff)
		__field(dev_t, dev)
		__field(unsigned int, flags)
		__field(int, result)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->vm_flags = vmf->vma->vm_flags;
		__entry->address = vmf->address;
		__entry->flags = vmf->flags;
		__entry->pgoff = vmf->pgoff;
		__entry->result = result;
	),
	TP_printk("dev %d:%d ino %#lx %s %s address %#lx pgoff %#lx %s",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->vm_flags & VM_SHARED ? "shared" : "private",
		__print_flags(__entry->flags, "|", FAULT_FLAG_TRACE),
		__entry->address,
		__entry->pgoff,
		__print_flags(__entry->result, "|", VM_FAULT_RESULT_TRACE)
	)
)

#define DEFINE_PTE_FAULT_EVENT(name) \
DEFINE_EVENT(dax_pte_fault_class, name, \
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result), \
	TP_ARGS(inode, vmf, result))

DEFINE_PTE_FAULT_EVENT(dax_pte_fault);
DEFINE_PTE_FAULT_EVENT(dax_pte_fault_done);
DEFINE_PTE_FAULT_EVENT(dax_load_hole);

TRACE_EVENT(dax_insert_mapping,
	TP_PROTO(struct inode *inode, struct vm_fault *vmf, void *radix_entry),
	TP_ARGS(inode, vmf, radix_entry),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(unsigned long, vm_flags)
		__field(unsigned long, address)
		__field(void *, radix_entry)
		__field(dev_t, dev)
		__field(int, write)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->vm_flags = vmf->vma->vm_flags;
		__entry->address = vmf->address;
		__entry->write = vmf->flags & FAULT_FLAG_WRITE;
		__entry->radix_entry = radix_entry;
	),
	TP_printk("dev %d:%d ino %#lx %s %s address %#lx radix_entry %#lx",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->vm_flags & VM_SHARED ? "shared" : "private",
		__entry->write ? "write" : "read",
		__entry->address,
		(unsigned long)__entry->radix_entry
	)
)

DECLARE_EVENT_CLASS(dax_writeback_range_class,
	TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),
	TP_ARGS(inode, start_index, end_index),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(pgoff_t, start_index)
		__field(pgoff_t, end_index)
		__field(dev_t, dev)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->start_index = start_index;
		__entry->end_index = end_index;
	),
	TP_printk("dev %d:%d ino %#lx pgoff %#lx-%#lx",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->start_index,
		__entry->end_index
	)
)

#define DEFINE_WRITEBACK_RANGE_EVENT(name) \
DEFINE_EVENT(dax_writeback_range_class, name, \
	TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),\
	TP_ARGS(inode, start_index, end_index))

DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range);
DEFINE_WRITEBACK_RANGE_EVENT(dax_writeback_range_done);

TRACE_EVENT(dax_writeback_one,
	TP_PROTO(struct inode *inode, pgoff_t pgoff, pgoff_t pglen),
	TP_ARGS(inode, pgoff, pglen),
	TP_STRUCT__entry(
		__field(unsigned long, ino)
		__field(pgoff_t, pgoff)
		__field(pgoff_t, pglen)
		__field(dev_t, dev)
	),
	TP_fast_assign(
		__entry->dev = inode->i_sb->s_dev;
		__entry->ino = inode->i_ino;
		__entry->pgoff = pgoff;
		__entry->pglen = pglen;
	),
	TP_printk("dev %d:%d ino %#lx pgoff %#lx pglen %#lx",
		MAJOR(__entry->dev),
		MINOR(__entry->dev),
		__entry->ino,
		__entry->pgoff,
		__entry->pglen
	)
)

#endif /* _TRACE_FS_DAX_H */

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