FM / events

/usr/src/linux-headers-5.15.0-181/include/trace/events/

/usr/src/linux-headers-5.15.0-181/include/trace/events

Name	Size	Mode	Actions
9p.h	5218	0644	edit dl rm
afs.h	46293	0644	edit dl rm
alarmtimer.h	2087	0644	edit dl rm
asoc.h	5342	0644	edit dl rm
avc.h	1292	0644	edit dl rm
bcache.h	11712	0644	edit dl rm
block.h	14000	0644	edit dl rm
bpf_test_run.h	1048	0644	edit dl rm
bridge.h	3509	0644	edit dl rm
btrfs.h	62093	0644	edit dl rm
cachefiles.h	8273	0644	edit dl rm
cgroup.h	4387	0644	edit dl rm
clk.h	5145	0644	edit dl rm
cma.h	2447	0644	edit dl rm
compaction.h	8089	0644	edit dl rm
context_tracking.h	1177	0644	edit dl rm
cpuhp.h	1871	0644	edit dl rm
damon.h	1049	0644	edit dl rm
devfreq.h	1962	0644	edit dl rm
devlink.h	6980	0644	edit dl rm
dma_fence.h	1706	0644	edit dl rm
erofs.h	6070	0644	edit dl rm
error_report.h	2051	0644	edit dl rm
ext4.h	73511	0644	edit dl rm
f2fs.h	50537	0644	edit dl rm
fib.h	2608	0644	edit dl rm
fib6.h	2446	0644	edit dl rm
filelock.h	7547	0644	edit dl rm
filemap.h	2805	0644	edit dl rm
fscache.h	14559	0644	edit dl rm
fsi.h	2880	0644	edit dl rm
fsi_master_aspeed.h	2109	0644	edit dl rm
fsi_master_ast_cf.h	3755	0644	edit dl rm
fsi_master_gpio.h	4017	0644	edit dl rm
fs_dax.h	8456	0644	edit dl rm
gpio.h	1099	0644	edit dl rm
gpu_mem.h	1240	0644	edit dl rm
host1x.h	5670	0644	edit dl rm
huge_memory.h	4584	0644	edit dl rm
hwmon.h	1489	0644	edit dl rm
i2c.h	4047	0644	edit dl rm
ib_mad.h	12719	0644	edit dl rm
ib_umad.h	4095	0644	edit dl rm
initcall.h	1310	0644	edit dl rm
intel-sst.h	2571	0644	edit dl rm
intel_iommu.h	2297	0644	edit dl rm
intel_ish.h	556	0644	edit dl rm
iocost.h	6384	0644	edit dl rm
iommu.h	3105	0644	edit dl rm
io_uring.h	12755	0644	edit dl rm
ipi.h	1924	0644	edit dl rm
irq.h	3889	0644	edit dl rm
irq_matrix.h	5055	0644	edit dl rm
iscsi.h	2336	0644	edit dl rm
jbd2.h	12855	0644	edit dl rm
kmem.h	9228	0644	edit dl rm
kvm.h	11423	0644	edit dl rm
kyber.h	2324	0644	edit dl rm
libata.h	11843	0644	edit dl rm
lock.h	1737	0644	edit dl rm
mce.h	1897	0644	edit dl rm
mdio.h	1048	0644	edit dl rm
migrate.h	2882	0644	edit dl rm
mlxsw.h	2682	0644	edit dl rm
mmap.h	1399	0644	edit dl rm
mmap_lock.h	2217	0644	edit dl rm
mmc.h	7412	0644	edit dl rm
mmflags.h	9242	0644	edit dl rm
module.h	2851	0644	edit dl rm
mptcp.h	4590	0644	edit dl rm
napi.h	1011	0644	edit dl rm
nbd.h	2185	0644	edit dl rm
neigh.h	7118	0644	edit dl rm
net.h	8156	0644	edit dl rm
netfs.h	7358	0644	edit dl rm
netlink.h	490	0644	edit dl rm
net_probe_common.h	1235	0644	edit dl rm
nilfs2.h	5326	0644	edit dl rm
nmi.h	780	0644	edit dl rm
objagg.h	4691	0644	edit dl rm
oom.h	5069	0644	edit dl rm
osnoise.h	3010	0644	edit dl rm
pagemap.h	2195	0644	edit dl rm
page_isolation.h	943	0644	edit dl rm
page_pool.h	2654	0644	edit dl rm
page_ref.h	3034	0644	edit dl rm
percpu.h	2669	0644	edit dl rm
power.h	11080	0644	edit dl rm
power_cpu_migrate.h	1625	0644	edit dl rm
preemptirq.h	2163	0644	edit dl rm
printk.h	786	0644	edit dl rm
pwc.h	1714	0644	edit dl rm
pwm.h	1238	0644	edit dl rm
qdisc.h	3931	0644	edit dl rm
qla.h	937	0644	edit dl rm
qrtr.h	2604	0644	edit dl rm
rcu.h	24867	0644	edit dl rm
rdma_core.h	7193	0644	edit dl rm
regulator.h	2900	0644	edit dl rm
rpcgss.h	14702	0644	edit dl rm
rpcrdma.h	45848	0644	edit dl rm
rpm.h	2500	0644	edit dl rm
rseq.h	1288	0644	edit dl rm
rtc.h	3354	0644	edit dl rm
rxrpc.h	43994	0644	edit dl rm
sched.h	17878	0644	edit dl rm
scmi.h	2272	0644	edit dl rm
scsi.h	10847	0644	edit dl rm
sctp.h	2432	0644	edit dl rm
signal.h	3486	0644	edit dl rm
siox.h	2041	0644	edit dl rm
skb.h	2471	0644	edit dl rm
smbus.h	7508	0644	edit dl rm
sock.h	6878	0644	edit dl rm
spi.h	5951	0644	edit dl rm
spmi.h	3320	0644	edit dl rm
sunrpc.h	56341	0644	edit dl rm
sunvnet.h	3129	0644	edit dl rm
swiotlb.h	1253	0644	edit dl rm
syscalls.h	1506	0644	edit dl rm
target.h	7879	0644	edit dl rm
task.h	1526	0644	edit dl rm
tcp.h	9555	0644	edit dl rm
tegra_apb_dma.h	1645	0644	edit dl rm
thermal.h	5370	0644	edit dl rm
thermal_power_allocator.h	3297	0644	edit dl rm
thp.h	2137	0644	edit dl rm
timer.h	10592	0644	edit dl rm
tlb.h	1439	0644	edit dl rm
udp.h	632	0644	edit dl rm
ufs.h	10966	0644	edit dl rm
v4l2.h	9018	0644	edit dl rm
vb2.h	1769	0644	edit dl rm
vmscan.h	11515	0644	edit dl rm
vsock_virtio_transport_common.h	3678	0644	edit dl rm
wbt.h	3907	0644	edit dl rm
workqueue.h	2997	0644	edit dl rm
writeback.h	23732	0644	edit dl rm
xdp.h	10050	0644	edit dl rm
xen.h	14257	0644	edit dl rm

Edit: /usr/src/linux-headers-5.15.0-181/include/trace/events/io_uring.h (12755B)

/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM io_uring

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

#include <linux/tracepoint.h>

struct io_wq_work;

/**
 * io_uring_create - called after a new io_uring context was prepared
 *
 * @fd:		corresponding file descriptor
 * @ctx:	pointer to a ring context structure
 * @sq_entries:	actual SQ size
 * @cq_entries:	actual CQ size
 * @flags:	SQ ring flags, provided to io_uring_setup(2)
 *
 * Allows to trace io_uring creation and provide pointer to a context, that can
 * be used later to find correlated events.
 */
TRACE_EVENT(io_uring_create,

TP_PROTO(int fd, void *ctx, u32 sq_entries, u32 cq_entries, u32 flags),

TP_ARGS(fd, ctx, sq_entries, cq_entries, flags),

TP_STRUCT__entry (
		__field(  int,		fd			)
		__field(  void *,	ctx			)
		__field(  u32,		sq_entries	)
		__field(  u32,		cq_entries	)
		__field(  u32,		flags		)
	),

TP_fast_assign(
		__entry->fd			= fd;
		__entry->ctx		= ctx;
		__entry->sq_entries	= sq_entries;
		__entry->cq_entries	= cq_entries;
		__entry->flags		= flags;
	),

TP_printk("ring %p, fd %d sq size %d, cq size %d, flags %d",
			  __entry->ctx, __entry->fd, __entry->sq_entries,
			  __entry->cq_entries, __entry->flags)
);

/**
 * io_uring_register - called after a buffer/file/eventfd was successfully
 * 					   registered for a ring
 *
 * @ctx:		pointer to a ring context structure
 * @opcode:		describes which operation to perform
 * @nr_user_files:	number of registered files
 * @nr_user_bufs:	number of registered buffers
 * @cq_ev_fd:		whether eventfs registered or not
 * @ret:		return code
 *
 * Allows to trace fixed files/buffers/eventfds, that could be registered to
 * avoid an overhead of getting references to them for every operation. This
 * event, together with io_uring_file_get, can provide a full picture of how
 * much overhead one can reduce via fixing.
 */
TRACE_EVENT(io_uring_register,

TP_PROTO(void *ctx, unsigned opcode, unsigned nr_files,
			 unsigned nr_bufs, bool eventfd, long ret),

TP_ARGS(ctx, opcode, nr_files, nr_bufs, eventfd, ret),

TP_STRUCT__entry (
		__field(  void *,	ctx			)
		__field(  unsigned,	opcode		)
		__field(  unsigned,	nr_files	)
		__field(  unsigned,	nr_bufs		)
		__field(  bool,		eventfd		)
		__field(  long,		ret			)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->opcode		= opcode;
		__entry->nr_files	= nr_files;
		__entry->nr_bufs	= nr_bufs;
		__entry->eventfd	= eventfd;
		__entry->ret		= ret;
	),

TP_printk("ring %p, opcode %d, nr_user_files %d, nr_user_bufs %d, "
			  "eventfd %d, ret %ld",
			  __entry->ctx, __entry->opcode, __entry->nr_files,
			  __entry->nr_bufs, __entry->eventfd, __entry->ret)
);

/**
 * io_uring_file_get - called before getting references to an SQE file
 *
 * @ctx:	pointer to a ring context structure
 * @fd:		SQE file descriptor
 *
 * Allows to trace out how often an SQE file reference is obtained, which can
 * help figuring out if it makes sense to use fixed files, or check that fixed
 * files are used correctly.
 */
TRACE_EVENT(io_uring_file_get,

TP_PROTO(void *ctx, int fd),

TP_ARGS(ctx, fd),

TP_STRUCT__entry (
		__field(  void *,	ctx	)
		__field(  int,		fd	)
	),

TP_fast_assign(
		__entry->ctx	= ctx;
		__entry->fd		= fd;
	),

TP_printk("ring %p, fd %d", __entry->ctx, __entry->fd)
);

/**
 * io_uring_queue_async_work - called before submitting a new async work
 *
 * @ctx:	pointer to a ring context structure
 * @hashed:	type of workqueue, hashed or normal
 * @req:	pointer to a submitted request
 * @work:	pointer to a submitted io_wq_work
 *
 * Allows to trace asynchronous work submission.
 */
TRACE_EVENT(io_uring_queue_async_work,

TP_PROTO(void *ctx, int rw, void * req, struct io_wq_work *work,
			 unsigned int flags),

TP_ARGS(ctx, rw, req, work, flags),

TP_STRUCT__entry (
		__field(  void *,			ctx	)
		__field(  int,				rw	)
		__field(  void *,			req	)
		__field(  struct io_wq_work *,		work	)
		__field(  unsigned int,			flags	)
	),

TP_fast_assign(
		__entry->ctx	= ctx;
		__entry->rw	= rw;
		__entry->req	= req;
		__entry->work	= work;
		__entry->flags	= flags;
	),

TP_printk("ring %p, request %p, flags %d, %s queue, work %p",
			  __entry->ctx, __entry->req, __entry->flags,
			  __entry->rw ? "hashed" : "normal", __entry->work)
);

/**
 * io_uring_defer - called when an io_uring request is deferred
 *
 * @ctx:	pointer to a ring context structure
 * @req:	pointer to a deferred request
 * @user_data:	user data associated with the request
 *
 * Allows to track deferred requests, to get an insight about what requests are
 * not started immediately.
 */
TRACE_EVENT(io_uring_defer,

TP_PROTO(void *ctx, void *req, unsigned long long user_data),

TP_ARGS(ctx, req, user_data),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  void *,	req		)
		__field(  unsigned long long, data	)
	),

TP_fast_assign(
		__entry->ctx	= ctx;
		__entry->req	= req;
		__entry->data	= user_data;
	),

TP_printk("ring %p, request %p user_data %llu", __entry->ctx,
			__entry->req, __entry->data)
);

/**
 * io_uring_link - called before the io_uring request added into link_list of
 * 		   another request
 *
 * @ctx:		pointer to a ring context structure
 * @req:		pointer to a linked request
 * @target_req:		pointer to a previous request, that would contain @req
 *
 * Allows to track linked requests, to understand dependencies between requests
 * and how does it influence their execution flow.
 */
TRACE_EVENT(io_uring_link,

TP_PROTO(void *ctx, void *req, void *target_req),

TP_ARGS(ctx, req, target_req),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  void *,	req		)
		__field(  void *,	target_req	)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->req		= req;
		__entry->target_req	= target_req;
	),

TP_printk("ring %p, request %p linked after %p",
			  __entry->ctx, __entry->req, __entry->target_req)
);

/**
 * io_uring_cqring_wait - called before start waiting for an available CQE
 *
 * @ctx:		pointer to a ring context structure
 * @min_events:	minimal number of events to wait for
 *
 * Allows to track waiting for CQE, so that we can e.g. troubleshoot
 * situations, when an application wants to wait for an event, that never
 * comes.
 */
TRACE_EVENT(io_uring_cqring_wait,

TP_PROTO(void *ctx, int min_events),

TP_ARGS(ctx, min_events),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  int,		min_events	)
	),

TP_fast_assign(
		__entry->ctx	= ctx;
		__entry->min_events	= min_events;
	),

TP_printk("ring %p, min_events %d", __entry->ctx, __entry->min_events)
);

/**
 * io_uring_fail_link - called before failing a linked request
 *
 * @req:	request, which links were cancelled
 * @link:	cancelled link
 *
 * Allows to track linked requests cancellation, to see not only that some work
 * was cancelled, but also which request was the reason.
 */
TRACE_EVENT(io_uring_fail_link,

TP_PROTO(void *req, void *link),

TP_ARGS(req, link),

TP_STRUCT__entry (
		__field(  void *,	req	)
		__field(  void *,	link	)
	),

TP_fast_assign(
		__entry->req	= req;
		__entry->link	= link;
	),

TP_printk("request %p, link %p", __entry->req, __entry->link)
);

/**
 * io_uring_complete - called when completing an SQE
 *
 * @ctx:		pointer to a ring context structure
 * @user_data:		user data associated with the request
 * @res:		result of the request
 * @cflags:		completion flags
 *
 */
TRACE_EVENT(io_uring_complete,

TP_PROTO(void *ctx, u64 user_data, int res, unsigned cflags),

TP_ARGS(ctx, user_data, res, cflags),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  u64,		user_data	)
		__field(  int,		res		)
		__field(  unsigned,	cflags		)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->user_data	= user_data;
		__entry->res		= res;
		__entry->cflags		= cflags;
	),

TP_printk("ring %p, user_data 0x%llx, result %d, cflags %x",
			  __entry->ctx, (unsigned long long)__entry->user_data,
			  __entry->res, __entry->cflags)
);

/**
 * io_uring_submit_sqe - called before submitting one SQE
 *
 * @ctx:		pointer to a ring context structure
 * @req:		pointer to a submitted request
 * @opcode:		opcode of request
 * @user_data:		user data associated with the request
 * @flags		request flags
 * @force_nonblock:	whether a context blocking or not
 * @sq_thread:		true if sq_thread has submitted this SQE
 *
 * Allows to track SQE submitting, to understand what was the source of it, SQ
 * thread or io_uring_enter call.
 */
TRACE_EVENT(io_uring_submit_sqe,

TP_PROTO(void *ctx, void *req, u8 opcode, u64 user_data, u32 flags,
		 bool force_nonblock, bool sq_thread),

TP_ARGS(ctx, req, opcode, user_data, flags, force_nonblock, sq_thread),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  void *,	req		)
		__field(  u8,		opcode		)
		__field(  u64,		user_data	)
		__field(  u32,		flags		)
		__field(  bool,		force_nonblock	)
		__field(  bool,		sq_thread	)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->req		= req;
		__entry->opcode		= opcode;
		__entry->user_data	= user_data;
		__entry->flags		= flags;
		__entry->force_nonblock	= force_nonblock;
		__entry->sq_thread	= sq_thread;
	),

TP_printk("ring %p, req %p, op %d, data 0x%llx, flags %u, "
		  "non block %d, sq_thread %d", __entry->ctx, __entry->req,
		  __entry->opcode, (unsigned long long)__entry->user_data,
		  __entry->flags, __entry->force_nonblock, __entry->sq_thread)
);

/*
 * io_uring_poll_arm - called after arming a poll wait if successful
 *
 * @ctx:		pointer to a ring context structure
 * @req:		pointer to the armed request
 * @opcode:		opcode of request
 * @user_data:		user data associated with the request
 * @mask:		request poll events mask
 * @events:		registered events of interest
 *
 * Allows to track which fds are waiting for and what are the events of
 * interest.
 */
TRACE_EVENT(io_uring_poll_arm,

TP_PROTO(void *ctx, void *req, u8 opcode, u64 user_data,
		 int mask, int events),

TP_ARGS(ctx, req, opcode, user_data, mask, events),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  void *,	req		)
		__field(  u8,		opcode		)
		__field(  u64,		user_data	)
		__field(  int,		mask		)
		__field(  int,		events		)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->req		= req;
		__entry->opcode		= opcode;
		__entry->user_data	= user_data;
		__entry->mask		= mask;
		__entry->events		= events;
	),

TP_printk("ring %p, req %p, op %d, data 0x%llx, mask 0x%x, events 0x%x",
		  __entry->ctx, __entry->req, __entry->opcode,
		  (unsigned long long) __entry->user_data,
		  __entry->mask, __entry->events)
);

TRACE_EVENT(io_uring_poll_wake,

TP_PROTO(void *ctx, u8 opcode, u64 user_data, int mask),

TP_ARGS(ctx, opcode, user_data, mask),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  u8,		opcode		)
		__field(  u64,		user_data	)
		__field(  int,		mask		)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->opcode		= opcode;
		__entry->user_data	= user_data;
		__entry->mask		= mask;
	),

TP_printk("ring %p, op %d, data 0x%llx, mask 0x%x",
			  __entry->ctx, __entry->opcode,
			  (unsigned long long) __entry->user_data,
			  __entry->mask)
);

TRACE_EVENT(io_uring_task_add,

TP_PROTO(void *ctx, u8 opcode, u64 user_data, int mask),

TP_ARGS(ctx, opcode, user_data, mask),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  u8,		opcode		)
		__field(  u64,		user_data	)
		__field(  int,		mask		)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->opcode		= opcode;
		__entry->user_data	= user_data;
		__entry->mask		= mask;
	),

TP_printk("ring %p, op %d, data 0x%llx, mask %x",
			  __entry->ctx, __entry->opcode,
			  (unsigned long long) __entry->user_data,
			  __entry->mask)
);

/*
 * io_uring_task_run - called when task_work_run() executes the poll events
 *                     notification callbacks
 *
 * @ctx:		pointer to a ring context structure
 * @req:		pointer to the armed request
 * @opcode:		opcode of request
 * @user_data:		user data associated with the request
 *
 * Allows to track when notified poll events are processed
 */
TRACE_EVENT(io_uring_task_run,

TP_PROTO(void *ctx, void *req, u8 opcode, u64 user_data),

TP_ARGS(ctx, req, opcode, user_data),

TP_STRUCT__entry (
		__field(  void *,	ctx		)
		__field(  void *,	req		)
		__field(  u8,		opcode		)
		__field(  u64,		user_data	)
	),

TP_fast_assign(
		__entry->ctx		= ctx;
		__entry->req		= req;
		__entry->opcode		= opcode;
		__entry->user_data	= user_data;
	),

TP_printk("ring %p, req %p, op %d, data 0x%llx",
		  __entry->ctx, __entry->req, __entry->opcode,
		  (unsigned long long) __entry->user_data)
);

#endif /* _TRACE_IO_URING_H */

/* This part must be outside protection */
#include <trace/define_trace.h>

cmd: