[mirror_ubuntu-jammy-kernel.git] / include / trace / events / netfs.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/* Network filesystem support module tracepoints
 *
 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM netfs

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

#include <linux/tracepoint.h>

/*
 * Define enums for tracing information.
 */
#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY

enum netfs_read_trace {
	netfs_read_trace_expanded,
	netfs_read_trace_readahead,
	netfs_read_trace_readpage,
	netfs_read_trace_write_begin,
};

enum netfs_rreq_trace {
	netfs_rreq_trace_assess,
	netfs_rreq_trace_done,
	netfs_rreq_trace_free,
	netfs_rreq_trace_resubmit,
	netfs_rreq_trace_unlock,
	netfs_rreq_trace_unmark,
	netfs_rreq_trace_write,
};

enum netfs_sreq_trace {
	netfs_sreq_trace_download_instead,
	netfs_sreq_trace_free,
	netfs_sreq_trace_prepare,
	netfs_sreq_trace_resubmit_short,
	netfs_sreq_trace_submit,
	netfs_sreq_trace_terminated,
	netfs_sreq_trace_write,
	netfs_sreq_trace_write_skip,
	netfs_sreq_trace_write_term,
};

enum netfs_failure {
	netfs_fail_check_write_begin,
	netfs_fail_copy_to_cache,
	netfs_fail_read,
	netfs_fail_short_readpage,
	netfs_fail_short_write_begin,
	netfs_fail_prepare_write,
};

#endif

#define netfs_read_traces					\
	EM(netfs_read_trace_expanded,		"EXPANDED ")	\
	EM(netfs_read_trace_readahead,		"READAHEAD")	\
	EM(netfs_read_trace_readpage,		"READPAGE ")	\
	E_(netfs_read_trace_write_begin,	"WRITEBEGN")

#define netfs_rreq_traces					\
	EM(netfs_rreq_trace_assess,		"ASSESS")	\
	EM(netfs_rreq_trace_done,		"DONE  ")	\
	EM(netfs_rreq_trace_free,		"FREE  ")	\
	EM(netfs_rreq_trace_resubmit,		"RESUBM")	\
	EM(netfs_rreq_trace_unlock,		"UNLOCK")	\
	EM(netfs_rreq_trace_unmark,		"UNMARK")	\
	E_(netfs_rreq_trace_write,		"WRITE ")

#define netfs_sreq_sources					\
	EM(NETFS_FILL_WITH_ZEROES,		"ZERO")		\
	EM(NETFS_DOWNLOAD_FROM_SERVER,		"DOWN")		\
	EM(NETFS_READ_FROM_CACHE,		"READ")		\
	E_(NETFS_INVALID_READ,			"INVL")		\

#define netfs_sreq_traces					\
	EM(netfs_sreq_trace_download_instead,	"RDOWN")	\
	EM(netfs_sreq_trace_free,		"FREE ")	\
	EM(netfs_sreq_trace_prepare,		"PREP ")	\
	EM(netfs_sreq_trace_resubmit_short,	"SHORT")	\
	EM(netfs_sreq_trace_submit,		"SUBMT")	\
	EM(netfs_sreq_trace_terminated,		"TERM ")	\
	EM(netfs_sreq_trace_write,		"WRITE")	\
	EM(netfs_sreq_trace_write_skip,		"SKIP ")	\
	E_(netfs_sreq_trace_write_term,		"WTERM")

#define netfs_failures							\
	EM(netfs_fail_check_write_begin,	"check-write-begin")	\
	EM(netfs_fail_copy_to_cache,		"copy-to-cache")	\
	EM(netfs_fail_read,			"read")			\
	EM(netfs_fail_short_readpage,		"short-readpage")	\
	EM(netfs_fail_short_write_begin,	"short-write-begin")	\
	E_(netfs_fail_prepare_write,		"prep-write")


/*
 * Export enum symbols via userspace.
 */
#undef EM
#undef E_
#define EM(a, b) TRACE_DEFINE_ENUM(a);
#define E_(a, b) TRACE_DEFINE_ENUM(a);

netfs_read_traces;
netfs_rreq_traces;
netfs_sreq_sources;
netfs_sreq_traces;
netfs_failures;

/*
 * Now redefine the EM() and E_() macros to map the enums to the strings that
 * will be printed in the output.
 */
#undef EM
#undef E_
#define EM(a, b)	{ a, b },
#define E_(a, b)	{ a, b }

TRACE_EVENT(netfs_read,
	    TP_PROTO(struct netfs_read_request *rreq,
		     loff_t start, size_t len,
		     enum netfs_read_trace what),

	    TP_ARGS(rreq, start, len, what),

	    TP_STRUCT__entry(
		    __field(unsigned int,		rreq		)
		    __field(unsigned int,		cookie		)
		    __field(loff_t,			start		)
		    __field(size_t,			len		)
		    __field(enum netfs_read_trace,	what		)
			     ),

	    TP_fast_assign(
		    __entry->rreq	= rreq->debug_id;
		    __entry->cookie	= rreq->cache_resources.debug_id;
		    __entry->start	= start;
		    __entry->len	= len;
		    __entry->what	= what;
			   ),

	    TP_printk("R=%08x %s c=%08x s=%llx %zx",
		      __entry->rreq,
		      __print_symbolic(__entry->what, netfs_read_traces),
		      __entry->cookie,
		      __entry->start, __entry->len)
	    );

TRACE_EVENT(netfs_rreq,
	    TP_PROTO(struct netfs_read_request *rreq,
		     enum netfs_rreq_trace what),

	    TP_ARGS(rreq, what),

	    TP_STRUCT__entry(
		    __field(unsigned int,		rreq		)
		    __field(unsigned short,		flags		)
		    __field(enum netfs_rreq_trace,	what		)
			     ),

	    TP_fast_assign(
		    __entry->rreq	= rreq->debug_id;
		    __entry->flags	= rreq->flags;
		    __entry->what	= what;
			   ),

	    TP_printk("R=%08x %s f=%02x",
		      __entry->rreq,
		      __print_symbolic(__entry->what, netfs_rreq_traces),
		      __entry->flags)
	    );

TRACE_EVENT(netfs_sreq,
	    TP_PROTO(struct netfs_read_subrequest *sreq,
		     enum netfs_sreq_trace what),

	    TP_ARGS(sreq, what),

	    TP_STRUCT__entry(
		    __field(unsigned int,		rreq		)
		    __field(unsigned short,		index		)
		    __field(short,			error		)
		    __field(unsigned short,		flags		)
		    __field(enum netfs_read_source,	source		)
		    __field(enum netfs_sreq_trace,	what		)
		    __field(size_t,			len		)
		    __field(size_t,			transferred	)
		    __field(loff_t,			start		)
			     ),

	    TP_fast_assign(
		    __entry->rreq	= sreq->rreq->debug_id;
		    __entry->index	= sreq->debug_index;
		    __entry->error	= sreq->error;
		    __entry->flags	= sreq->flags;
		    __entry->source	= sreq->source;
		    __entry->what	= what;
		    __entry->len	= sreq->len;
		    __entry->transferred = sreq->transferred;
		    __entry->start	= sreq->start;
			   ),

	    TP_printk("R=%08x[%u] %s %s f=%02x s=%llx %zx/%zx e=%d",
		      __entry->rreq, __entry->index,
		      __print_symbolic(__entry->what, netfs_sreq_traces),
		      __print_symbolic(__entry->source, netfs_sreq_sources),
		      __entry->flags,
		      __entry->start, __entry->transferred, __entry->len,
		      __entry->error)
	    );

TRACE_EVENT(netfs_failure,
	    TP_PROTO(struct netfs_read_request *rreq,
		     struct netfs_read_subrequest *sreq,
		     int error, enum netfs_failure what),

	    TP_ARGS(rreq, sreq, error, what),

	    TP_STRUCT__entry(
		    __field(unsigned int,		rreq		)
		    __field(unsigned short,		index		)
		    __field(short,			error		)
		    __field(unsigned short,		flags		)
		    __field(enum netfs_read_source,	source		)
		    __field(enum netfs_failure,		what		)
		    __field(size_t,			len		)
		    __field(size_t,			transferred	)
		    __field(loff_t,			start		)
			     ),

	    TP_fast_assign(
		    __entry->rreq	= rreq->debug_id;
		    __entry->index	= sreq ? sreq->debug_index : 0;
		    __entry->error	= error;
		    __entry->flags	= sreq ? sreq->flags : 0;
		    __entry->source	= sreq ? sreq->source : NETFS_INVALID_READ;
		    __entry->what	= what;
		    __entry->len	= sreq ? sreq->len : 0;
		    __entry->transferred = sreq ? sreq->transferred : 0;
		    __entry->start	= sreq ? sreq->start : 0;
			   ),

	    TP_printk("R=%08x[%u] %s f=%02x s=%llx %zx/%zx %s e=%d",
		      __entry->rreq, __entry->index,
		      __print_symbolic(__entry->source, netfs_sreq_sources),
		      __entry->flags,
		      __entry->start, __entry->transferred, __entry->len,
		      __print_symbolic(__entry->what, netfs_failures),
		      __entry->error)
	    );

#endif /* _TRACE_NETFS_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
77b4d2c6 DH	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
	2	/* Network filesystem support module tracepoints
	3	*
	4	* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
	6	*/
	7	#undef TRACE_SYSTEM
	8	#define TRACE_SYSTEM netfs
	9
	10	#if !defined(_TRACE_NETFS_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	11	#define _TRACE_NETFS_H
	12
	13	#include <linux/tracepoint.h>
	14
	15	/*
	16	* Define enums for tracing information.
	17	*/
	18	#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
	19	#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
	20
	21	enum netfs_read_trace {
	22	netfs_read_trace_expanded,
	23	netfs_read_trace_readahead,
	24	netfs_read_trace_readpage,
e1b1240c	25	netfs_read_trace_write_begin,
77b4d2c6 DH	26	};
	27
	28	enum netfs_rreq_trace {
	29	netfs_rreq_trace_assess,
	30	netfs_rreq_trace_done,
	31	netfs_rreq_trace_free,
	32	netfs_rreq_trace_resubmit,
	33	netfs_rreq_trace_unlock,
	34	netfs_rreq_trace_unmark,
	35	netfs_rreq_trace_write,
	36	};
	37
	38	enum netfs_sreq_trace {
	39	netfs_sreq_trace_download_instead,
	40	netfs_sreq_trace_free,
	41	netfs_sreq_trace_prepare,
	42	netfs_sreq_trace_resubmit_short,
	43	netfs_sreq_trace_submit,
	44	netfs_sreq_trace_terminated,
	45	netfs_sreq_trace_write,
726218fd	46	netfs_sreq_trace_write_skip,
77b4d2c6 DH	47	netfs_sreq_trace_write_term,
	48	};
	49
0246f3e5 DH	50	enum netfs_failure {
	51	netfs_fail_check_write_begin,
	52	netfs_fail_copy_to_cache,
	53	netfs_fail_read,
	54	netfs_fail_short_readpage,
	55	netfs_fail_short_write_begin,
	56	netfs_fail_prepare_write,
	57	};
	58
77b4d2c6 DH	59	#endif
	60
	61	#define netfs_read_traces \
	62	EM(netfs_read_trace_expanded, "EXPANDED ") \
	63	EM(netfs_read_trace_readahead, "READAHEAD") \
e1b1240c DH	64	EM(netfs_read_trace_readpage, "READPAGE ") \
e1b1240c DH	65	E_(netfs_read_trace_write_begin, "WRITEBEGN")
77b4d2c6 DH	66
	67	#define netfs_rreq_traces \
	68	EM(netfs_rreq_trace_assess, "ASSESS") \
	69	EM(netfs_rreq_trace_done, "DONE ") \
	70	EM(netfs_rreq_trace_free, "FREE ") \
	71	EM(netfs_rreq_trace_resubmit, "RESUBM") \
	72	EM(netfs_rreq_trace_unlock, "UNLOCK") \
	73	EM(netfs_rreq_trace_unmark, "UNMARK") \
	74	E_(netfs_rreq_trace_write, "WRITE ")
	75
	76	#define netfs_sreq_sources \
	77	EM(NETFS_FILL_WITH_ZEROES, "ZERO") \
	78	EM(NETFS_DOWNLOAD_FROM_SERVER, "DOWN") \
	79	EM(NETFS_READ_FROM_CACHE, "READ") \
	80	E_(NETFS_INVALID_READ, "INVL") \
	81
	82	#define netfs_sreq_traces \
	83	EM(netfs_sreq_trace_download_instead, "RDOWN") \
	84	EM(netfs_sreq_trace_free, "FREE ") \
	85	EM(netfs_sreq_trace_prepare, "PREP ") \
	86	EM(netfs_sreq_trace_resubmit_short, "SHORT") \
	87	EM(netfs_sreq_trace_submit, "SUBMT") \
	88	EM(netfs_sreq_trace_terminated, "TERM ") \
	89	EM(netfs_sreq_trace_write, "WRITE") \
726218fd	90	EM(netfs_sreq_trace_write_skip, "SKIP ") \
77b4d2c6 DH	91	E_(netfs_sreq_trace_write_term, "WTERM")
77b4d2c6 DH	92
0246f3e5 DH	93	#define netfs_failures \
	94	EM(netfs_fail_check_write_begin, "check-write-begin") \
	95	EM(netfs_fail_copy_to_cache, "copy-to-cache") \
	96	EM(netfs_fail_read, "read") \
	97	EM(netfs_fail_short_readpage, "short-readpage") \
	98	EM(netfs_fail_short_write_begin, "short-write-begin") \
	99	E_(netfs_fail_prepare_write, "prep-write")
	100
77b4d2c6 DH	101
	102	/*
	103	* Export enum symbols via userspace.
	104	*/
	105	#undef EM
	106	#undef E_
	107	#define EM(a, b) TRACE_DEFINE_ENUM(a);
	108	#define E_(a, b) TRACE_DEFINE_ENUM(a);
	109
	110	netfs_read_traces;
	111	netfs_rreq_traces;
	112	netfs_sreq_sources;
	113	netfs_sreq_traces;
0246f3e5	114	netfs_failures;
77b4d2c6 DH	115
	116	/*
	117	* Now redefine the EM() and E_() macros to map the enums to the strings that
	118	* will be printed in the output.
	119	*/
	120	#undef EM
	121	#undef E_
	122	#define EM(a, b) { a, b },
	123	#define E_(a, b) { a, b }
	124
	125	TRACE_EVENT(netfs_read,
	126	TP_PROTO(struct netfs_read_request *rreq,
	127	loff_t start, size_t len,
	128	enum netfs_read_trace what),
	129
	130	TP_ARGS(rreq, start, len, what),
	131
	132	TP_STRUCT__entry(
	133	__field(unsigned int, rreq )
	134	__field(unsigned int, cookie )
	135	__field(loff_t, start )
	136	__field(size_t, len )
	137	__field(enum netfs_read_trace, what )
	138	),
	139
	140	TP_fast_assign(
	141	__entry->rreq = rreq->debug_id;
a7e20e31	142	__entry->cookie = rreq->cache_resources.debug_id;
77b4d2c6 DH	143	__entry->start = start;
	144	__entry->len = len;
	145	__entry->what = what;
	146	),
	147
	148	TP_printk("R=%08x %s c=%08x s=%llx %zx",
	149	__entry->rreq,
	150	__print_symbolic(__entry->what, netfs_read_traces),
	151	__entry->cookie,
	152	__entry->start, __entry->len)
	153	);
	154
	155	TRACE_EVENT(netfs_rreq,
	156	TP_PROTO(struct netfs_read_request *rreq,
	157	enum netfs_rreq_trace what),
	158
	159	TP_ARGS(rreq, what),
	160
	161	TP_STRUCT__entry(
	162	__field(unsigned int, rreq )
	163	__field(unsigned short, flags )
	164	__field(enum netfs_rreq_trace, what )
	165	),
	166
	167	TP_fast_assign(
	168	__entry->rreq = rreq->debug_id;
	169	__entry->flags = rreq->flags;
	170	__entry->what = what;
	171	),
	172
	173	TP_printk("R=%08x %s f=%02x",
	174	__entry->rreq,
	175	__print_symbolic(__entry->what, netfs_rreq_traces),
	176	__entry->flags)
	177	);
	178
	179	TRACE_EVENT(netfs_sreq,
	180	TP_PROTO(struct netfs_read_subrequest *sreq,
	181	enum netfs_sreq_trace what),
	182
	183	TP_ARGS(sreq, what),
	184
	185	TP_STRUCT__entry(
	186	__field(unsigned int, rreq )
	187	__field(unsigned short, index )
	188	__field(short, error )
	189	__field(unsigned short, flags )
	190	__field(enum netfs_read_source, source )
	191	__field(enum netfs_sreq_trace, what )
	192	__field(size_t, len )
	193	__field(size_t, transferred )
	194	__field(loff_t, start )
	195	),
	196
	197	TP_fast_assign(
	198	__entry->rreq = sreq->rreq->debug_id;
	199	__entry->index = sreq->debug_index;
	200	__entry->error = sreq->error;
	201	__entry->flags = sreq->flags;
	202	__entry->source = sreq->source;
	203	__entry->what = what;
	204	__entry->len = sreq->len;
	205	__entry->transferred = sreq->transferred;
	206	__entry->start = sreq->start;
207	),
208
209	TP_printk("R=%08x[%u] %s %s f=%02x s=%llx %zx/%zx e=%d",
210	__entry->rreq, __entry->index,
211	__print_symbolic(__entry->what, netfs_sreq_traces),
212	__print_symbolic(__entry->source, netfs_sreq_sources),
213	__entry->flags,
214	__entry->start, __entry->transferred, __entry->len,
215	__entry->error)
216	);
217
0246f3e5 DH	218	TRACE_EVENT(netfs_failure,
	219	TP_PROTO(struct netfs_read_request *rreq,
	220	struct netfs_read_subrequest *sreq,
	221	int error, enum netfs_failure what),
	222
	223	TP_ARGS(rreq, sreq, error, what),
	224
	225	TP_STRUCT__entry(
	226	__field(unsigned int, rreq )
	227	__field(unsigned short, index )
	228	__field(short, error )
	229	__field(unsigned short, flags )
	230	__field(enum netfs_read_source, source )
	231	__field(enum netfs_failure, what )
	232	__field(size_t, len )
	233	__field(size_t, transferred )
	234	__field(loff_t, start )
	235	),
	236
	237	TP_fast_assign(
	238	__entry->rreq = rreq->debug_id;
	239	__entry->index = sreq ? sreq->debug_index : 0;
	240	__entry->error = error;
	241	__entry->flags = sreq ? sreq->flags : 0;
	242	__entry->source = sreq ? sreq->source : NETFS_INVALID_READ;
	243	__entry->what = what;
	244	__entry->len = sreq ? sreq->len : 0;
	245	__entry->transferred = sreq ? sreq->transferred : 0;
	246	__entry->start = sreq ? sreq->start : 0;
	247	),
	248
	249	TP_printk("R=%08x[%u] %s f=%02x s=%llx %zx/%zx %s e=%d",
	250	__entry->rreq, __entry->index,
	251	__print_symbolic(__entry->source, netfs_sreq_sources),
	252	__entry->flags,
	253	__entry->start, __entry->transferred, __entry->len,
	254	__print_symbolic(__entry->what, netfs_failures),
	255	__entry->error)
	256	);
	257
77b4d2c6 DH	258	#endif /* _TRACE_NETFS_H */
	259
	260	/* This part must be outside protection */
	261	#include <trace/define_trace.h>