Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #undef TRACE_SYSTEM
3 : : #define TRACE_SYSTEM io_uring
4 : :
5 : : #if !defined(_TRACE_IO_URING_H) || defined(TRACE_HEADER_MULTI_READ)
6 : : #define _TRACE_IO_URING_H
7 : :
8 : : #include <linux/tracepoint.h>
9 : :
10 : : struct io_wq_work;
11 : :
12 : : /**
13 : : * io_uring_create - called after a new io_uring context was prepared
14 : : *
15 : : * @fd: corresponding file descriptor
16 : : * @ctx: pointer to a ring context structure
17 : : * @sq_entries: actual SQ size
18 : : * @cq_entries: actual CQ size
19 : : * @flags: SQ ring flags, provided to io_uring_setup(2)
20 : : *
21 : : * Allows to trace io_uring creation and provide pointer to a context, that can
22 : : * be used later to find correlated events.
23 : : */
24 [ # # # # : 0 : TRACE_EVENT(io_uring_create,
# # # # ]
25 : :
26 : : TP_PROTO(int fd, void *ctx, u32 sq_entries, u32 cq_entries, u32 flags),
27 : :
28 : : TP_ARGS(fd, ctx, sq_entries, cq_entries, flags),
29 : :
30 : : TP_STRUCT__entry (
31 : : __field( int, fd )
32 : : __field( void *, ctx )
33 : : __field( u32, sq_entries )
34 : : __field( u32, cq_entries )
35 : : __field( u32, flags )
36 : : ),
37 : :
38 : : TP_fast_assign(
39 : : __entry->fd = fd;
40 : : __entry->ctx = ctx;
41 : : __entry->sq_entries = sq_entries;
42 : : __entry->cq_entries = cq_entries;
43 : : __entry->flags = flags;
44 : : ),
45 : :
46 : : TP_printk("ring %p, fd %d sq size %d, cq size %d, flags %d",
47 : : __entry->ctx, __entry->fd, __entry->sq_entries,
48 : : __entry->cq_entries, __entry->flags)
49 : : );
50 : :
51 : : /**
52 : : * io_uring_register - called after a buffer/file/eventfd was succesfully
53 : : * registered for a ring
54 : : *
55 : : * @ctx: pointer to a ring context structure
56 : : * @opcode: describes which operation to perform
57 : : * @nr_user_files: number of registered files
58 : : * @nr_user_bufs: number of registered buffers
59 : : * @cq_ev_fd: whether eventfs registered or not
60 : : * @ret: return code
61 : : *
62 : : * Allows to trace fixed files/buffers/eventfds, that could be registered to
63 : : * avoid an overhead of getting references to them for every operation. This
64 : : * event, together with io_uring_file_get, can provide a full picture of how
65 : : * much overhead one can reduce via fixing.
66 : : */
67 [ # # # # : 0 : TRACE_EVENT(io_uring_register,
# # # # ]
68 : :
69 : : TP_PROTO(void *ctx, unsigned opcode, unsigned nr_files,
70 : : unsigned nr_bufs, bool eventfd, long ret),
71 : :
72 : : TP_ARGS(ctx, opcode, nr_files, nr_bufs, eventfd, ret),
73 : :
74 : : TP_STRUCT__entry (
75 : : __field( void *, ctx )
76 : : __field( unsigned, opcode )
77 : : __field( unsigned, nr_files )
78 : : __field( unsigned, nr_bufs )
79 : : __field( bool, eventfd )
80 : : __field( long, ret )
81 : : ),
82 : :
83 : : TP_fast_assign(
84 : : __entry->ctx = ctx;
85 : : __entry->opcode = opcode;
86 : : __entry->nr_files = nr_files;
87 : : __entry->nr_bufs = nr_bufs;
88 : : __entry->eventfd = eventfd;
89 : : __entry->ret = ret;
90 : : ),
91 : :
92 : : TP_printk("ring %p, opcode %d, nr_user_files %d, nr_user_bufs %d, "
93 : : "eventfd %d, ret %ld",
94 : : __entry->ctx, __entry->opcode, __entry->nr_files,
95 : : __entry->nr_bufs, __entry->eventfd, __entry->ret)
96 : : );
97 : :
98 : : /**
99 : : * io_uring_file_get - called before getting references to an SQE file
100 : : *
101 : : * @ctx: pointer to a ring context structure
102 : : * @fd: SQE file descriptor
103 : : *
104 : : * Allows to trace out how often an SQE file reference is obtained, which can
105 : : * help figuring out if it makes sense to use fixed files, or check that fixed
106 : : * files are used correctly.
107 : : */
108 [ # # # # : 0 : TRACE_EVENT(io_uring_file_get,
# # # # ]
109 : :
110 : : TP_PROTO(void *ctx, int fd),
111 : :
112 : : TP_ARGS(ctx, fd),
113 : :
114 : : TP_STRUCT__entry (
115 : : __field( void *, ctx )
116 : : __field( int, fd )
117 : : ),
118 : :
119 : : TP_fast_assign(
120 : : __entry->ctx = ctx;
121 : : __entry->fd = fd;
122 : : ),
123 : :
124 : : TP_printk("ring %p, fd %d", __entry->ctx, __entry->fd)
125 : : );
126 : :
127 : : /**
128 : : * io_uring_queue_async_work - called before submitting a new async work
129 : : *
130 : : * @ctx: pointer to a ring context structure
131 : : * @hashed: type of workqueue, hashed or normal
132 : : * @req: pointer to a submitted request
133 : : * @work: pointer to a submitted io_wq_work
134 : : *
135 : : * Allows to trace asynchronous work submission.
136 : : */
137 [ # # # # : 0 : TRACE_EVENT(io_uring_queue_async_work,
# # # # ]
138 : :
139 : : TP_PROTO(void *ctx, int rw, void * req, struct io_wq_work *work,
140 : : unsigned int flags),
141 : :
142 : : TP_ARGS(ctx, rw, req, work, flags),
143 : :
144 : : TP_STRUCT__entry (
145 : : __field( void *, ctx )
146 : : __field( int, rw )
147 : : __field( void *, req )
148 : : __field( struct io_wq_work *, work )
149 : : __field( unsigned int, flags )
150 : : ),
151 : :
152 : : TP_fast_assign(
153 : : __entry->ctx = ctx;
154 : : __entry->rw = rw;
155 : : __entry->req = req;
156 : : __entry->work = work;
157 : : __entry->flags = flags;
158 : : ),
159 : :
160 : : TP_printk("ring %p, request %p, flags %d, %s queue, work %p",
161 : : __entry->ctx, __entry->req, __entry->flags,
162 : : __entry->rw ? "hashed" : "normal", __entry->work)
163 : : );
164 : :
165 : : /**
166 : : * io_uring_defer - called when an io_uring request is deferred
167 : : *
168 : : * @ctx: pointer to a ring context structure
169 : : * @req: pointer to a deferred request
170 : : * @user_data: user data associated with the request
171 : : *
172 : : * Allows to track deferred requests, to get an insight about what requests are
173 : : * not started immediately.
174 : : */
175 [ # # # # : 0 : TRACE_EVENT(io_uring_defer,
# # # # ]
176 : :
177 : : TP_PROTO(void *ctx, void *req, unsigned long long user_data),
178 : :
179 : : TP_ARGS(ctx, req, user_data),
180 : :
181 : : TP_STRUCT__entry (
182 : : __field( void *, ctx )
183 : : __field( void *, req )
184 : : __field( unsigned long long, data )
185 : : ),
186 : :
187 : : TP_fast_assign(
188 : : __entry->ctx = ctx;
189 : : __entry->req = req;
190 : : __entry->data = user_data;
191 : : ),
192 : :
193 : : TP_printk("ring %p, request %p user_data %llu", __entry->ctx,
194 : : __entry->req, __entry->data)
195 : : );
196 : :
197 : : /**
198 : : * io_uring_link - called before the io_uring request added into link_list of
199 : : * another request
200 : : *
201 : : * @ctx: pointer to a ring context structure
202 : : * @req: pointer to a linked request
203 : : * @target_req: pointer to a previous request, that would contain @req
204 : : *
205 : : * Allows to track linked requests, to understand dependencies between requests
206 : : * and how does it influence their execution flow.
207 : : */
208 [ # # # # : 0 : TRACE_EVENT(io_uring_link,
# # # # ]
209 : :
210 : : TP_PROTO(void *ctx, void *req, void *target_req),
211 : :
212 : : TP_ARGS(ctx, req, target_req),
213 : :
214 : : TP_STRUCT__entry (
215 : : __field( void *, ctx )
216 : : __field( void *, req )
217 : : __field( void *, target_req )
218 : : ),
219 : :
220 : : TP_fast_assign(
221 : : __entry->ctx = ctx;
222 : : __entry->req = req;
223 : : __entry->target_req = target_req;
224 : : ),
225 : :
226 : : TP_printk("ring %p, request %p linked after %p",
227 : : __entry->ctx, __entry->req, __entry->target_req)
228 : : );
229 : :
230 : : /**
231 : : * io_uring_cqring_wait - called before start waiting for an available CQE
232 : : *
233 : : * @ctx: pointer to a ring context structure
234 : : * @min_events: minimal number of events to wait for
235 : : *
236 : : * Allows to track waiting for CQE, so that we can e.g. troubleshoot
237 : : * situations, when an application wants to wait for an event, that never
238 : : * comes.
239 : : */
240 [ # # # # : 0 : TRACE_EVENT(io_uring_cqring_wait,
# # # # ]
241 : :
242 : : TP_PROTO(void *ctx, int min_events),
243 : :
244 : : TP_ARGS(ctx, min_events),
245 : :
246 : : TP_STRUCT__entry (
247 : : __field( void *, ctx )
248 : : __field( int, min_events )
249 : : ),
250 : :
251 : : TP_fast_assign(
252 : : __entry->ctx = ctx;
253 : : __entry->min_events = min_events;
254 : : ),
255 : :
256 : : TP_printk("ring %p, min_events %d", __entry->ctx, __entry->min_events)
257 : : );
258 : :
259 : : /**
260 : : * io_uring_fail_link - called before failing a linked request
261 : : *
262 : : * @req: request, which links were cancelled
263 : : * @link: cancelled link
264 : : *
265 : : * Allows to track linked requests cancellation, to see not only that some work
266 : : * was cancelled, but also which request was the reason.
267 : : */
268 [ # # # # : 0 : TRACE_EVENT(io_uring_fail_link,
# # # # ]
269 : :
270 : : TP_PROTO(void *req, void *link),
271 : :
272 : : TP_ARGS(req, link),
273 : :
274 : : TP_STRUCT__entry (
275 : : __field( void *, req )
276 : : __field( void *, link )
277 : : ),
278 : :
279 : : TP_fast_assign(
280 : : __entry->req = req;
281 : : __entry->link = link;
282 : : ),
283 : :
284 : : TP_printk("request %p, link %p", __entry->req, __entry->link)
285 : : );
286 : :
287 : : /**
288 : : * io_uring_complete - called when completing an SQE
289 : : *
290 : : * @ctx: pointer to a ring context structure
291 : : * @user_data: user data associated with the request
292 : : * @res: result of the request
293 : : *
294 : : */
295 [ # # # # : 0 : TRACE_EVENT(io_uring_complete,
# # # # ]
296 : :
297 : : TP_PROTO(void *ctx, u64 user_data, long res),
298 : :
299 : : TP_ARGS(ctx, user_data, res),
300 : :
301 : : TP_STRUCT__entry (
302 : : __field( void *, ctx )
303 : : __field( u64, user_data )
304 : : __field( long, res )
305 : : ),
306 : :
307 : : TP_fast_assign(
308 : : __entry->ctx = ctx;
309 : : __entry->user_data = user_data;
310 : : __entry->res = res;
311 : : ),
312 : :
313 : : TP_printk("ring %p, user_data 0x%llx, result %ld",
314 : : __entry->ctx, (unsigned long long)__entry->user_data,
315 : : __entry->res)
316 : : );
317 : :
318 : :
319 : : /**
320 : : * io_uring_submit_sqe - called before submitting one SQE
321 : : *
322 : : * @ctx: pointer to a ring context structure
323 : : * @opcode: opcode of request
324 : : * @user_data: user data associated with the request
325 : : * @force_nonblock: whether a context blocking or not
326 : : * @sq_thread: true if sq_thread has submitted this SQE
327 : : *
328 : : * Allows to track SQE submitting, to understand what was the source of it, SQ
329 : : * thread or io_uring_enter call.
330 : : */
331 [ # # # # : 0 : TRACE_EVENT(io_uring_submit_sqe,
# # # # ]
332 : :
333 : : TP_PROTO(void *ctx, u8 opcode, u64 user_data, bool force_nonblock,
334 : : bool sq_thread),
335 : :
336 : : TP_ARGS(ctx, opcode, user_data, force_nonblock, sq_thread),
337 : :
338 : : TP_STRUCT__entry (
339 : : __field( void *, ctx )
340 : : __field( u8, opcode )
341 : : __field( u64, user_data )
342 : : __field( bool, force_nonblock )
343 : : __field( bool, sq_thread )
344 : : ),
345 : :
346 : : TP_fast_assign(
347 : : __entry->ctx = ctx;
348 : : __entry->opcode = opcode;
349 : : __entry->user_data = user_data;
350 : : __entry->force_nonblock = force_nonblock;
351 : : __entry->sq_thread = sq_thread;
352 : : ),
353 : :
354 : : TP_printk("ring %p, op %d, data 0x%llx, non block %d, sq_thread %d",
355 : : __entry->ctx, __entry->opcode,
356 : : (unsigned long long) __entry->user_data,
357 : : __entry->force_nonblock, __entry->sq_thread)
358 : : );
359 : :
360 : : #endif /* _TRACE_IO_URING_H */
361 : :
362 : : /* This part must be outside protection */
363 : : #include <trace/define_trace.h>
|
