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