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