Debian Codegraph @

include/trace/events/netfs.h

raw
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 ([email protected])
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 #define netfs_read_traces \
19 EM(netfs_read_trace_dio_read, "DIO-READ ") \
20 EM(netfs_read_trace_expanded, "EXPANDED ") \
21 EM(netfs_read_trace_readahead, "READAHEAD") \
22 EM(netfs_read_trace_readpage, "READPAGE ") \
23 EM(netfs_read_trace_read_gaps, "READ-GAPS") \
24 EM(netfs_read_trace_read_single, "READ-SNGL") \
25 EM(netfs_read_trace_prefetch_for_write, "PREFETCHW") \
26 E_(netfs_read_trace_write_begin, "WRITEBEGN")
27
28 #define netfs_write_traces \
29 EM(netfs_write_trace_copy_to_cache, "COPY2CACH") \
30 EM(netfs_write_trace_dio_write, "DIO-WRITE") \
31 EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \
32 EM(netfs_write_trace_writeback, "WRITEBACK") \
33 EM(netfs_write_trace_writeback_single, "WB-SINGLE") \
34 E_(netfs_write_trace_writethrough, "WRITETHRU")
35
36 #define netfs_rreq_origins \
37 EM(NETFS_READAHEAD, "RA") \
38 EM(NETFS_READPAGE, "RP") \
39 EM(NETFS_READ_GAPS, "RG") \
40 EM(NETFS_READ_SINGLE, "R1") \
41 EM(NETFS_READ_FOR_WRITE, "RW") \
42 EM(NETFS_UNBUFFERED_READ, "UR") \
43 EM(NETFS_DIO_READ, "DR") \
44 EM(NETFS_WRITEBACK, "WB") \
45 EM(NETFS_WRITEBACK_SINGLE, "W1") \
46 EM(NETFS_WRITETHROUGH, "WT") \
47 EM(NETFS_UNBUFFERED_WRITE, "UW") \
48 EM(NETFS_DIO_WRITE, "DW") \
49 E_(NETFS_PGPRIV2_COPY_TO_CACHE, "2C")
50
51 #define netfs_rreq_traces \
52 EM(netfs_rreq_trace_assess, "ASSESS ") \
53 EM(netfs_rreq_trace_collect, "COLLECT") \
54 EM(netfs_rreq_trace_complete, "COMPLET") \
55 EM(netfs_rreq_trace_copy, "COPY ") \
56 EM(netfs_rreq_trace_dirty, "DIRTY ") \
57 EM(netfs_rreq_trace_done, "DONE ") \
58 EM(netfs_rreq_trace_end_copy_to_cache, "END-C2C") \
59 EM(netfs_rreq_trace_free, "FREE ") \
60 EM(netfs_rreq_trace_intr, "INTR ") \
61 EM(netfs_rreq_trace_ki_complete, "KI-CMPL") \
62 EM(netfs_rreq_trace_recollect, "RECLLCT") \
63 EM(netfs_rreq_trace_redirty, "REDIRTY") \
64 EM(netfs_rreq_trace_resubmit, "RESUBMT") \
65 EM(netfs_rreq_trace_set_abandon, "S-ABNDN") \
66 EM(netfs_rreq_trace_set_pause, "PAUSE ") \
67 EM(netfs_rreq_trace_unlock, "UNLOCK ") \
68 EM(netfs_rreq_trace_unlock_pgpriv2, "UNLCK-2") \
69 EM(netfs_rreq_trace_unmark, "UNMARK ") \
70 EM(netfs_rreq_trace_unpause, "UNPAUSE") \
71 EM(netfs_rreq_trace_wait_ip, "WAIT-IP") \
72 EM(netfs_rreq_trace_wait_pause, "--PAUSED--") \
73 EM(netfs_rreq_trace_wait_quiesce, "WAIT-QUIESCE") \
74 EM(netfs_rreq_trace_waited_ip, "DONE-IP") \
75 EM(netfs_rreq_trace_waited_pause, "--UNPAUSED--") \
76 EM(netfs_rreq_trace_waited_quiesce, "DONE-QUIESCE") \
77 EM(netfs_rreq_trace_wake_ip, "WAKE-IP") \
78 EM(netfs_rreq_trace_wake_queue, "WAKE-Q ") \
79 E_(netfs_rreq_trace_write_done, "WR-DONE")
80
81 #define netfs_sreq_sources \
82 EM(NETFS_SOURCE_UNKNOWN, "----") \
83 EM(NETFS_FILL_WITH_ZEROES, "ZERO") \
84 EM(NETFS_DOWNLOAD_FROM_SERVER, "DOWN") \
85 EM(NETFS_READ_FROM_CACHE, "READ") \
86 EM(NETFS_INVALID_READ, "INVL") \
87 EM(NETFS_UPLOAD_TO_SERVER, "UPLD") \
88 E_(NETFS_WRITE_TO_CACHE, "WRIT")
89
90 #define netfs_sreq_traces \
91 EM(netfs_sreq_trace_abandoned, "ABNDN") \
92 EM(netfs_sreq_trace_add_donations, "+DON ") \
93 EM(netfs_sreq_trace_added, "ADD ") \
94 EM(netfs_sreq_trace_cache_nowrite, "CA-NW") \
95 EM(netfs_sreq_trace_cache_prepare, "CA-PR") \
96 EM(netfs_sreq_trace_cache_write, "CA-WR") \
97 EM(netfs_sreq_trace_cancel, "CANCL") \
98 EM(netfs_sreq_trace_clear, "CLEAR") \
99 EM(netfs_sreq_trace_consumed, "CONSM") \
100 EM(netfs_sreq_trace_discard, "DSCRD") \
101 EM(netfs_sreq_trace_donate_to_prev, "DON-P") \
102 EM(netfs_sreq_trace_donate_to_next, "DON-N") \
103 EM(netfs_sreq_trace_download_instead, "RDOWN") \
104 EM(netfs_sreq_trace_fail, "FAIL ") \
105 EM(netfs_sreq_trace_free, "FREE ") \
106 EM(netfs_sreq_trace_hit_eof, "EOF ") \
107 EM(netfs_sreq_trace_io_bad, "I-BAD") \
108 EM(netfs_sreq_trace_io_malformed, "I-MLF") \
109 EM(netfs_sreq_trace_io_unknown, "I-UNK") \
110 EM(netfs_sreq_trace_io_progress, "I-OK ") \
111 EM(netfs_sreq_trace_io_req_submitted, "I-RSB") \
112 EM(netfs_sreq_trace_io_retry_needed, "I-RTR") \
113 EM(netfs_sreq_trace_limited, "LIMIT") \
114 EM(netfs_sreq_trace_need_clear, "N-CLR") \
115 EM(netfs_sreq_trace_partial_read, "PARTR") \
116 EM(netfs_sreq_trace_need_retry, "ND-RT") \
117 EM(netfs_sreq_trace_prepare, "PREP ") \
118 EM(netfs_sreq_trace_prep_failed, "PRPFL") \
119 EM(netfs_sreq_trace_progress, "PRGRS") \
120 EM(netfs_sreq_trace_reprep_failed, "REPFL") \
121 EM(netfs_sreq_trace_retry, "RETRY") \
122 EM(netfs_sreq_trace_short, "SHORT") \
123 EM(netfs_sreq_trace_split, "SPLIT") \
124 EM(netfs_sreq_trace_submit, "SUBMT") \
125 EM(netfs_sreq_trace_superfluous, "SPRFL") \
126 EM(netfs_sreq_trace_terminated, "TERM ") \
127 EM(netfs_sreq_trace_wait_for, "_WAIT") \
128 EM(netfs_sreq_trace_write, "WRITE") \
129 EM(netfs_sreq_trace_write_skip, "SKIP ") \
130 E_(netfs_sreq_trace_write_term, "WTERM")
131
132 #define netfs_failures \
133 EM(netfs_fail_check_write_begin, "check-write-begin") \
134 EM(netfs_fail_copy_to_cache, "copy-to-cache") \
135 EM(netfs_fail_dio_read_short, "dio-read-short") \
136 EM(netfs_fail_dio_read_zero, "dio-read-zero") \
137 EM(netfs_fail_read, "read") \
138 EM(netfs_fail_short_read, "short-read") \
139 EM(netfs_fail_prepare_write, "prep-write") \
140 E_(netfs_fail_write, "write")
141
142 #define netfs_rreq_ref_traces \
143 EM(netfs_rreq_trace_get_for_outstanding,"GET OUTSTND") \
144 EM(netfs_rreq_trace_get_subreq, "GET SUBREQ ") \
145 EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \
146 EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \
147 EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \
148 EM(netfs_rreq_trace_put_no_submit, "PUT NO-SUBM") \
149 EM(netfs_rreq_trace_put_return, "PUT RETURN ") \
150 EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \
151 EM(netfs_rreq_trace_put_work_ip, "PUT WORK IP ") \
152 EM(netfs_rreq_trace_see_work, "SEE WORK ") \
153 EM(netfs_rreq_trace_see_work_complete, "SEE WORK CP") \
154 E_(netfs_rreq_trace_new, "NEW ")
155
156 #define netfs_sreq_ref_traces \
157 EM(netfs_sreq_trace_get_copy_to_cache, "GET COPY2C ") \
158 EM(netfs_sreq_trace_get_resubmit, "GET RESUBMT") \
159 EM(netfs_sreq_trace_get_submit, "GET SUBMIT ") \
160 EM(netfs_sreq_trace_get_short_read, "GET SHORTRD") \
161 EM(netfs_sreq_trace_new, "NEW ") \
162 EM(netfs_sreq_trace_put_abandon, "PUT ABANDON") \
163 EM(netfs_sreq_trace_put_cancel, "PUT CANCEL ") \
164 EM(netfs_sreq_trace_put_clear, "PUT CLEAR ") \
165 EM(netfs_sreq_trace_put_consumed, "PUT CONSUME") \
166 EM(netfs_sreq_trace_put_done, "PUT DONE ") \
167 EM(netfs_sreq_trace_put_failed, "PUT FAILED ") \
168 EM(netfs_sreq_trace_put_merged, "PUT MERGED ") \
169 EM(netfs_sreq_trace_put_no_copy, "PUT NO COPY") \
170 EM(netfs_sreq_trace_put_oom, "PUT OOM ") \
171 EM(netfs_sreq_trace_put_wip, "PUT WIP ") \
172 EM(netfs_sreq_trace_put_work, "PUT WORK ") \
173 EM(netfs_sreq_trace_put_terminated, "PUT TERM ") \
174 E_(netfs_sreq_trace_see_failed, "SEE FAILED ")
175
176 #define netfs_folio_traces \
177 EM(netfs_folio_is_uptodate, "mod-uptodate") \
178 EM(netfs_just_prefetch, "mod-prefetch") \
179 EM(netfs_whole_folio_modify, "mod-whole-f") \
180 EM(netfs_modify_and_clear, "mod-n-clear") \
181 EM(netfs_streaming_write, "mod-streamw") \
182 EM(netfs_streaming_write_cont, "mod-streamw+") \
183 EM(netfs_flush_content, "flush") \
184 EM(netfs_streaming_filled_page, "mod-streamw-f") \
185 EM(netfs_streaming_cont_filled_page, "mod-streamw-f+") \
186 EM(netfs_folio_trace_abandon, "abandon") \
187 EM(netfs_folio_trace_alloc_buffer, "alloc-buf") \
188 EM(netfs_folio_trace_cancel_copy, "cancel-copy") \
189 EM(netfs_folio_trace_cancel_store, "cancel-store") \
190 EM(netfs_folio_trace_clear, "clear") \
191 EM(netfs_folio_trace_clear_cc, "clear-cc") \
192 EM(netfs_folio_trace_clear_g, "clear-g") \
193 EM(netfs_folio_trace_clear_s, "clear-s") \
194 EM(netfs_folio_trace_copy_to_cache, "mark-copy") \
195 EM(netfs_folio_trace_end_copy, "end-copy") \
196 EM(netfs_folio_trace_filled_gaps, "filled-gaps") \
197 EM(netfs_folio_trace_kill, "kill") \
198 EM(netfs_folio_trace_kill_cc, "kill-cc") \
199 EM(netfs_folio_trace_kill_g, "kill-g") \
200 EM(netfs_folio_trace_kill_s, "kill-s") \
201 EM(netfs_folio_trace_mkwrite, "mkwrite") \
202 EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \
203 EM(netfs_folio_trace_not_under_wback, "!wback") \
204 EM(netfs_folio_trace_not_locked, "!locked") \
205 EM(netfs_folio_trace_put, "put") \
206 EM(netfs_folio_trace_read, "read") \
207 EM(netfs_folio_trace_read_done, "read-done") \
208 EM(netfs_folio_trace_read_gaps, "read-gaps") \
209 EM(netfs_folio_trace_read_unlock, "read-unlock") \
210 EM(netfs_folio_trace_redirtied, "redirtied") \
211 EM(netfs_folio_trace_store, "store") \
212 EM(netfs_folio_trace_store_copy, "store-copy") \
213 EM(netfs_folio_trace_store_plus, "store+") \
214 EM(netfs_folio_trace_wthru, "wthru") \
215 E_(netfs_folio_trace_wthru_plus, "wthru+")
216
217 #define netfs_collect_contig_traces \
218 EM(netfs_contig_trace_collect, "Collect") \
219 EM(netfs_contig_trace_jump, "-->JUMP-->") \
220 E_(netfs_contig_trace_unlock, "Unlock")
221
222 #define netfs_donate_traces \
223 EM(netfs_trace_donate_tail_to_prev, "tail-to-prev") \
224 EM(netfs_trace_donate_to_prev, "to-prev") \
225 EM(netfs_trace_donate_to_next, "to-next") \
226 E_(netfs_trace_donate_to_deferred_next, "defer-next")
227
228 #define netfs_folioq_traces \
229 EM(netfs_trace_folioq_alloc_buffer, "alloc-buf") \
230 EM(netfs_trace_folioq_clear, "clear") \
231 EM(netfs_trace_folioq_delete, "delete") \
232 EM(netfs_trace_folioq_make_space, "make-space") \
233 EM(netfs_trace_folioq_rollbuf_init, "roll-init") \
234 E_(netfs_trace_folioq_read_progress, "r-progress")
235
236 #ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
237 #define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
238
239 #undef EM
240 #undef E_
241 #define EM(a, b) a,
242 #define E_(a, b) a
243
244 enum netfs_read_trace { netfs_read_traces } __mode(byte);
245 enum netfs_write_trace { netfs_write_traces } __mode(byte);
246 enum netfs_rreq_trace { netfs_rreq_traces } __mode(byte);
247 enum netfs_sreq_trace { netfs_sreq_traces } __mode(byte);
248 enum netfs_failure { netfs_failures } __mode(byte);
249 enum netfs_rreq_ref_trace { netfs_rreq_ref_traces } __mode(byte);
250 enum netfs_sreq_ref_trace { netfs_sreq_ref_traces } __mode(byte);
251 enum netfs_folio_trace { netfs_folio_traces } __mode(byte);
252 enum netfs_collect_contig_trace { netfs_collect_contig_traces } __mode(byte);
253 enum netfs_donate_trace { netfs_donate_traces } __mode(byte);
254 enum netfs_folioq_trace { netfs_folioq_traces } __mode(byte);
255
256 #endif
257
258 /*
259 * Export enum symbols via userspace.
260 */
261 #undef EM
262 #undef E_
263 #define EM(a, b) TRACE_DEFINE_ENUM(a);
264 #define E_(a, b) TRACE_DEFINE_ENUM(a);
265
266 netfs_read_traces;
267 netfs_write_traces;
268 netfs_rreq_origins;
269 netfs_rreq_traces;
270 netfs_sreq_sources;
271 netfs_sreq_traces;
272 netfs_failures;
273 netfs_rreq_ref_traces;
274 netfs_sreq_ref_traces;
275 netfs_folio_traces;
276 netfs_collect_contig_traces;
277 netfs_donate_traces;
278 netfs_folioq_traces;
279
280 /*
281 * Now redefine the EM() and E_() macros to map the enums to the strings that
282 * will be printed in the output.
283 */
284 #undef EM
285 #undef E_
286 #define EM(a, b) { a, b },
287 #define E_(a, b) { a, b }
288
289 TRACE_EVENT(netfs_read,
290 TP_PROTO(struct netfs_io_request *rreq,
291 loff_t start, size_t len,
292 enum netfs_read_trace what),
293
294 TP_ARGS(rreq, start, len, what),
295
296 TP_STRUCT__entry(
297 __field(unsigned int, rreq)
298 __field(unsigned int, cookie)
299 __field(loff_t, i_size)
300 __field(loff_t, start)
301 __field(size_t, len)
302 __field(enum netfs_read_trace, what)
303 __field(unsigned int, netfs_inode)
304 ),
305
306 TP_fast_assign(
307 __entry->rreq = rreq->debug_id;
308 __entry->cookie = rreq->cache_resources.debug_id;
309 __entry->i_size = rreq->i_size;
310 __entry->start = start;
311 __entry->len = len;
312 __entry->what = what;
313 __entry->netfs_inode = rreq->inode->i_ino;
314 ),
315
316 TP_printk("R=%08x %s c=%08x ni=%x s=%llx l=%zx sz=%llx",
317 __entry->rreq,
318 __print_symbolic(__entry->what, netfs_read_traces),
319 __entry->cookie,
320 __entry->netfs_inode,
321 __entry->start, __entry->len, __entry->i_size)
322 );
323
324 TRACE_EVENT(netfs_rreq,
325 TP_PROTO(struct netfs_io_request *rreq,
326 enum netfs_rreq_trace what),
327
328 TP_ARGS(rreq, what),
329
330 TP_STRUCT__entry(
331 __field(unsigned int, rreq)
332 __field(unsigned int, flags)
333 __field(enum netfs_io_origin, origin)
334 __field(enum netfs_rreq_trace, what)
335 ),
336
337 TP_fast_assign(
338 __entry->rreq = rreq->debug_id;
339 __entry->flags = rreq->flags;
340 __entry->origin = rreq->origin;
341 __entry->what = what;
342 ),
343
344 TP_printk("R=%08x %s %s f=%02x",
345 __entry->rreq,
346 __print_symbolic(__entry->origin, netfs_rreq_origins),
347 __print_symbolic(__entry->what, netfs_rreq_traces),
348 __entry->flags)
349 );
350
351 TRACE_EVENT(netfs_sreq,
352 TP_PROTO(struct netfs_io_subrequest *sreq,
353 enum netfs_sreq_trace what),
354
355 TP_ARGS(sreq, what),
356
357 TP_STRUCT__entry(
358 __field(unsigned int, rreq)
359 __field(unsigned short, index)
360 __field(short, error)
361 __field(unsigned short, flags)
362 __field(enum netfs_io_source, source)
363 __field(enum netfs_sreq_trace, what)
364 __field(u8, slot)
365 __field(size_t, len)
366 __field(size_t, transferred)
367 __field(loff_t, start)
368 ),
369
370 TP_fast_assign(
371 __entry->rreq = sreq->rreq->debug_id;
372 __entry->index = sreq->debug_index;
373 __entry->error = sreq->error;
374 __entry->flags = sreq->flags;
375 __entry->source = sreq->source;
376 __entry->what = what;
377 __entry->len = sreq->len;
378 __entry->transferred = sreq->transferred;
379 __entry->start = sreq->start;
380 __entry->slot = sreq->io_iter.folioq_slot;
381 ),
382
383 TP_printk("R=%08x[%x] %s %s f=%03x s=%llx %zx/%zx s=%u e=%d",
384 __entry->rreq, __entry->index,
385 __print_symbolic(__entry->source, netfs_sreq_sources),
386 __print_symbolic(__entry->what, netfs_sreq_traces),
387 __entry->flags,
388 __entry->start, __entry->transferred, __entry->len,
389 __entry->slot, __entry->error)
390 );
391
392 TRACE_EVENT(netfs_failure,
393 TP_PROTO(struct netfs_io_request *rreq,
394 struct netfs_io_subrequest *sreq,
395 int error, enum netfs_failure what),
396
397 TP_ARGS(rreq, sreq, error, what),
398
399 TP_STRUCT__entry(
400 __field(unsigned int, rreq)
401 __field(short, index)
402 __field(short, error)
403 __field(unsigned short, flags)
404 __field(enum netfs_io_source, source)
405 __field(enum netfs_failure, what)
406 __field(size_t, len)
407 __field(size_t, transferred)
408 __field(loff_t, start)
409 ),
410
411 TP_fast_assign(
412 __entry->rreq = rreq->debug_id;
413 __entry->index = sreq ? sreq->debug_index : -1;
414 __entry->error = error;
415 __entry->flags = sreq ? sreq->flags : 0;
416 __entry->source = sreq ? sreq->source : NETFS_INVALID_READ;
417 __entry->what = what;
418 __entry->len = sreq ? sreq->len : rreq->len;
419 __entry->transferred = sreq ? sreq->transferred : 0;
420 __entry->start = sreq ? sreq->start : 0;
421 ),
422
423 TP_printk("R=%08x[%x] %s f=%02x s=%llx %zx/%zx %s e=%d",
424 __entry->rreq, __entry->index,
425 __print_symbolic(__entry->source, netfs_sreq_sources),
426 __entry->flags,
427 __entry->start, __entry->transferred, __entry->len,
428 __print_symbolic(__entry->what, netfs_failures),
429 __entry->error)
430 );
431
432 TRACE_EVENT(netfs_rreq_ref,
433 TP_PROTO(unsigned int rreq_debug_id, int ref,
434 enum netfs_rreq_ref_trace what),
435
436 TP_ARGS(rreq_debug_id, ref, what),
437
438 TP_STRUCT__entry(
439 __field(unsigned int, rreq)
440 __field(int, ref)
441 __field(enum netfs_rreq_ref_trace, what)
442 ),
443
444 TP_fast_assign(
445 __entry->rreq = rreq_debug_id;
446 __entry->ref = ref;
447 __entry->what = what;
448 ),
449
450 TP_printk("R=%08x %s r=%u",
451 __entry->rreq,
452 __print_symbolic(__entry->what, netfs_rreq_ref_traces),
453 __entry->ref)
454 );
455
456 TRACE_EVENT(netfs_sreq_ref,
457 TP_PROTO(unsigned int rreq_debug_id, unsigned int subreq_debug_index,
458 int ref, enum netfs_sreq_ref_trace what),
459
460 TP_ARGS(rreq_debug_id, subreq_debug_index, ref, what),
461
462 TP_STRUCT__entry(
463 __field(unsigned int, rreq)
464 __field(unsigned int, subreq)
465 __field(int, ref)
466 __field(enum netfs_sreq_ref_trace, what)
467 ),
468
469 TP_fast_assign(
470 __entry->rreq = rreq_debug_id;
471 __entry->subreq = subreq_debug_index;
472 __entry->ref = ref;
473 __entry->what = what;
474 ),
475
476 TP_printk("R=%08x[%x] %s r=%u",
477 __entry->rreq,
478 __entry->subreq,
479 __print_symbolic(__entry->what, netfs_sreq_ref_traces),
480 __entry->ref)
481 );
482
483 TRACE_EVENT(netfs_folio,
484 TP_PROTO(struct folio *folio, enum netfs_folio_trace why),
485
486 TP_ARGS(folio, why),
487
488 TP_STRUCT__entry(
489 __field(ino_t, ino)
490 __field(pgoff_t, index)
491 __field(unsigned int, nr)
492 __field(enum netfs_folio_trace, why)
493 ),
494
495 TP_fast_assign(
496 struct address_space *__m = READ_ONCE(folio->mapping);
497 __entry->ino = __m ? __m->host->i_ino : 0;
498 __entry->why = why;
499 __entry->index = folio->index;
500 __entry->nr = folio_nr_pages(folio);
501 ),
502
503 TP_printk("i=%05lx ix=%05lx-%05lx %s",
504 __entry->ino, __entry->index, __entry->index + __entry->nr - 1,
505 __print_symbolic(__entry->why, netfs_folio_traces))
506 );
507
508 TRACE_EVENT(netfs_write_iter,
509 TP_PROTO(const struct kiocb *iocb, const struct iov_iter *from),
510
511 TP_ARGS(iocb, from),
512
513 TP_STRUCT__entry(
514 __field(unsigned long long, start)
515 __field(size_t, len)
516 __field(unsigned int, flags)
517 __field(unsigned int, ino)
518 ),
519
520 TP_fast_assign(
521 __entry->start = iocb->ki_pos;
522 __entry->len = iov_iter_count(from);
523 __entry->ino = iocb->ki_filp->f_inode->i_ino;
524 __entry->flags = iocb->ki_flags;
525 ),
526
527 TP_printk("WRITE-ITER i=%x s=%llx l=%zx f=%x",
528 __entry->ino, __entry->start, __entry->len, __entry->flags)
529 );
530
531 TRACE_EVENT(netfs_write,
532 TP_PROTO(const struct netfs_io_request *wreq,
533 enum netfs_write_trace what),
534
535 TP_ARGS(wreq, what),
536
537 TP_STRUCT__entry(
538 __field(unsigned int, wreq)
539 __field(unsigned int, cookie)
540 __field(unsigned int, ino)
541 __field(enum netfs_write_trace, what)
542 __field(unsigned long long, start)
543 __field(unsigned long long, len)
544 ),
545
546 TP_fast_assign(
547 struct netfs_inode *__ctx = netfs_inode(wreq->inode);
548 struct fscache_cookie *__cookie = netfs_i_cookie(__ctx);
549 __entry->wreq = wreq->debug_id;
550 __entry->cookie = __cookie ? __cookie->debug_id : 0;
551 __entry->ino = wreq->inode->i_ino;
552 __entry->what = what;
553 __entry->start = wreq->start;
554 __entry->len = wreq->len;
555 ),
556
557 TP_printk("R=%08x %s c=%08x i=%x by=%llx-%llx",
558 __entry->wreq,
559 __print_symbolic(__entry->what, netfs_write_traces),
560 __entry->cookie,
561 __entry->ino,
562 __entry->start, __entry->start + __entry->len - 1)
563 );
564
565 TRACE_EVENT(netfs_copy2cache,
566 TP_PROTO(const struct netfs_io_request *rreq,
567 const struct netfs_io_request *creq),
568
569 TP_ARGS(rreq, creq),
570
571 TP_STRUCT__entry(
572 __field(unsigned int, rreq)
573 __field(unsigned int, creq)
574 __field(unsigned int, cookie)
575 __field(unsigned int, ino)
576 ),
577
578 TP_fast_assign(
579 struct netfs_inode *__ctx = netfs_inode(rreq->inode);
580 struct fscache_cookie *__cookie = netfs_i_cookie(__ctx);
581 __entry->rreq = rreq->debug_id;
582 __entry->creq = creq->debug_id;
583 __entry->cookie = __cookie ? __cookie->debug_id : 0;
584 __entry->ino = rreq->inode->i_ino;
585 ),
586
587 TP_printk("R=%08x CR=%08x c=%08x i=%x ",
588 __entry->rreq,
589 __entry->creq,
590 __entry->cookie,
591 __entry->ino)
592 );
593
594 TRACE_EVENT(netfs_collect,
595 TP_PROTO(const struct netfs_io_request *wreq),
596
597 TP_ARGS(wreq),
598
599 TP_STRUCT__entry(
600 __field(unsigned int, wreq)
601 __field(unsigned int, len)
602 __field(unsigned long long, transferred)
603 __field(unsigned long long, start)
604 ),
605
606 TP_fast_assign(
607 __entry->wreq = wreq->debug_id;
608 __entry->start = wreq->start;
609 __entry->len = wreq->len;
610 __entry->transferred = wreq->transferred;
611 ),
612
613 TP_printk("R=%08x s=%llx-%llx",
614 __entry->wreq,
615 __entry->start + __entry->transferred,
616 __entry->start + __entry->len)
617 );
618
619 TRACE_EVENT(netfs_collect_sreq,
620 TP_PROTO(const struct netfs_io_request *wreq,
621 const struct netfs_io_subrequest *subreq),
622
623 TP_ARGS(wreq, subreq),
624
625 TP_STRUCT__entry(
626 __field(unsigned int, wreq)
627 __field(unsigned int, subreq)
628 __field(unsigned int, stream)
629 __field(unsigned int, len)
630 __field(unsigned int, transferred)
631 __field(unsigned long long, start)
632 ),
633
634 TP_fast_assign(
635 __entry->wreq = wreq->debug_id;
636 __entry->subreq = subreq->debug_index;
637 __entry->stream = subreq->stream_nr;
638 __entry->start = subreq->start;
639 __entry->len = subreq->len;
640 __entry->transferred = subreq->transferred;
641 ),
642
643 TP_printk("R=%08x[%u:%02x] s=%llx t=%x/%x",
644 __entry->wreq, __entry->stream, __entry->subreq,
645 __entry->start, __entry->transferred, __entry->len)
646 );
647
648 TRACE_EVENT(netfs_collect_folio,
649 TP_PROTO(const struct netfs_io_request *wreq,
650 const struct folio *folio,
651 unsigned long long fend,
652 unsigned long long collected_to),
653
654 TP_ARGS(wreq, folio, fend, collected_to),
655
656 TP_STRUCT__entry(
657 __field(unsigned int, wreq)
658 __field(unsigned long, index)
659 __field(unsigned long long, fend)
660 __field(unsigned long long, cleaned_to)
661 __field(unsigned long long, collected_to)
662 ),
663
664 TP_fast_assign(
665 __entry->wreq = wreq->debug_id;
666 __entry->index = folio->index;
667 __entry->fend = fend;
668 __entry->cleaned_to = wreq->cleaned_to;
669 __entry->collected_to = collected_to;
670 ),
671
672 TP_printk("R=%08x ix=%05lx r=%llx-%llx t=%llx/%llx",
673 __entry->wreq, __entry->index,
674 (unsigned long long)__entry->index * PAGE_SIZE, __entry->fend,
675 __entry->cleaned_to, __entry->collected_to)
676 );
677
678 TRACE_EVENT(netfs_collect_state,
679 TP_PROTO(const struct netfs_io_request *wreq,
680 unsigned long long collected_to,
681 unsigned int notes),
682
683 TP_ARGS(wreq, collected_to, notes),
684
685 TP_STRUCT__entry(
686 __field(unsigned int, wreq)
687 __field(unsigned int, notes)
688 __field(unsigned long long, collected_to)
689 __field(unsigned long long, cleaned_to)
690 ),
691
692 TP_fast_assign(
693 __entry->wreq = wreq->debug_id;
694 __entry->notes = notes;
695 __entry->collected_to = collected_to;
696 __entry->cleaned_to = wreq->cleaned_to;
697 ),
698
699 TP_printk("R=%08x col=%llx cln=%llx n=%x",
700 __entry->wreq, __entry->collected_to,
701 __entry->cleaned_to,
702 __entry->notes)
703 );
704
705 TRACE_EVENT(netfs_collect_gap,
706 TP_PROTO(const struct netfs_io_request *wreq,
707 const struct netfs_io_stream *stream,
708 unsigned long long jump_to, char type),
709
710 TP_ARGS(wreq, stream, jump_to, type),
711
712 TP_STRUCT__entry(
713 __field(unsigned int, wreq)
714 __field(unsigned char, stream)
715 __field(unsigned char, type)
716 __field(unsigned long long, from)
717 __field(unsigned long long, to)
718 ),
719
720 TP_fast_assign(
721 __entry->wreq = wreq->debug_id;
722 __entry->stream = stream->stream_nr;
723 __entry->from = stream->collected_to;
724 __entry->to = jump_to;
725 __entry->type = type;
726 ),
727
728 TP_printk("R=%08x[%x:] %llx->%llx %c",
729 __entry->wreq, __entry->stream,
730 __entry->from, __entry->to, __entry->type)
731 );
732
733 TRACE_EVENT(netfs_collect_stream,
734 TP_PROTO(const struct netfs_io_request *wreq,
735 const struct netfs_io_stream *stream),
736
737 TP_ARGS(wreq, stream),
738
739 TP_STRUCT__entry(
740 __field(unsigned int, wreq)
741 __field(unsigned char, stream)
742 __field(unsigned long long, collected_to)
743 __field(unsigned long long, issued_to)
744 ),
745
746 TP_fast_assign(
747 __entry->wreq = wreq->debug_id;
748 __entry->stream = stream->stream_nr;
749 __entry->collected_to = stream->collected_to;
750 __entry->issued_to = atomic64_read(&wreq->issued_to);
751 ),
752
753 TP_printk("R=%08x[%x:] cto=%llx ito=%llx",
754 __entry->wreq, __entry->stream,
755 __entry->collected_to, __entry->issued_to)
756 );
757
758 TRACE_EVENT(netfs_folioq,
759 TP_PROTO(const struct folio_queue *fq,
760 enum netfs_folioq_trace trace),
761
762 TP_ARGS(fq, trace),
763
764 TP_STRUCT__entry(
765 __field(unsigned int, rreq)
766 __field(unsigned int, id)
767 __field(enum netfs_folioq_trace, trace)
768 ),
769
770 TP_fast_assign(
771 __entry->rreq = fq ? fq->rreq_id : 0;
772 __entry->id = fq ? fq->debug_id : 0;
773 __entry->trace = trace;
774 ),
775
776 TP_printk("R=%08x fq=%x %s",
777 __entry->rreq, __entry->id,
778 __print_symbolic(__entry->trace, netfs_folioq_traces))
779 );
780
781 #undef EM
782 #undef E_
783 #endif /* _TRACE_NETFS_H */
784
785 /* This part must be outside protection */
786 #include <trace/define_trace.h>