1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #undef TRACE_SYSTEM 3 #define TRACE_SYSTEM f2fs 4 5 #if !defined(_TRACE_F2FS_H) || defined(TRACE_HEADER_MULTI_READ) 6 #define _TRACE_F2FS_H 7 8 #include <linux/tracepoint.h> 9 #include <uapi/linux/f2fs.h> 10 11 #define show_dev(dev) MAJOR(dev), MINOR(dev) 12 #define show_dev_ino(entry) show_dev(entry->dev), (unsigned long long)entry->ino 13 14 TRACE_DEFINE_ENUM(NODE); 15 TRACE_DEFINE_ENUM(DATA); 16 TRACE_DEFINE_ENUM(META); 17 TRACE_DEFINE_ENUM(META_FLUSH); 18 TRACE_DEFINE_ENUM(IPU); 19 TRACE_DEFINE_ENUM(OPU); 20 TRACE_DEFINE_ENUM(HOT); 21 TRACE_DEFINE_ENUM(WARM); 22 TRACE_DEFINE_ENUM(COLD); 23 TRACE_DEFINE_ENUM(CURSEG_HOT_DATA); 24 TRACE_DEFINE_ENUM(CURSEG_WARM_DATA); 25 TRACE_DEFINE_ENUM(CURSEG_COLD_DATA); 26 TRACE_DEFINE_ENUM(CURSEG_HOT_NODE); 27 TRACE_DEFINE_ENUM(CURSEG_WARM_NODE); 28 TRACE_DEFINE_ENUM(CURSEG_COLD_NODE); 29 TRACE_DEFINE_ENUM(NO_CHECK_TYPE); 30 TRACE_DEFINE_ENUM(GC_GREEDY); 31 TRACE_DEFINE_ENUM(GC_CB); 32 TRACE_DEFINE_ENUM(FG_GC); 33 TRACE_DEFINE_ENUM(BG_GC); 34 TRACE_DEFINE_ENUM(LFS); 35 TRACE_DEFINE_ENUM(SSR); 36 TRACE_DEFINE_ENUM(__REQ_RAHEAD); 37 TRACE_DEFINE_ENUM(__REQ_SYNC); 38 TRACE_DEFINE_ENUM(__REQ_IDLE); 39 TRACE_DEFINE_ENUM(__REQ_PREFLUSH); 40 TRACE_DEFINE_ENUM(__REQ_FUA); 41 TRACE_DEFINE_ENUM(__REQ_PRIO); 42 TRACE_DEFINE_ENUM(__REQ_META); 43 TRACE_DEFINE_ENUM(CP_UMOUNT); 44 TRACE_DEFINE_ENUM(CP_FASTBOOT); 45 TRACE_DEFINE_ENUM(CP_SYNC); 46 TRACE_DEFINE_ENUM(CP_RECOVERY); 47 TRACE_DEFINE_ENUM(CP_DISCARD); 48 TRACE_DEFINE_ENUM(CP_TRIMMED); 49 TRACE_DEFINE_ENUM(CP_PAUSE); 50 TRACE_DEFINE_ENUM(CP_RESIZE); 51 TRACE_DEFINE_ENUM(EX_READ); 52 TRACE_DEFINE_ENUM(EX_BLOCK_AGE); 53 TRACE_DEFINE_ENUM(CP_PHASE_START_BLOCK_OPS); 54 TRACE_DEFINE_ENUM(CP_PHASE_FINISH_BLOCK_OPS); 55 TRACE_DEFINE_ENUM(CP_PHASE_FINISH_CHECKPOINT); 56 57 #define show_block_type(type) \ 58 __print_symbolic(type, \ 59 { NODE, "NODE" }, \ 60 { DATA, "DATA" }, \ 61 { META, "META" }, \ 62 { META_FLUSH, "META_FLUSH" }, \ 63 { IPU, "IN-PLACE" }, \ 64 { OPU, "OUT-OF-PLACE" }) 65 66 #define show_block_temp(temp) \ 67 __print_symbolic(temp, \ 68 { HOT, "HOT" }, \ 69 { WARM, "WARM" }, \ 70 { COLD, "COLD" }) 71 72 #define F2FS_OP_FLAGS (REQ_RAHEAD | REQ_SYNC | REQ_META | REQ_PRIO | \ 73 REQ_PREFLUSH | REQ_FUA) 74 #define F2FS_BIO_FLAG_MASK(t) (__force u32)((t) & F2FS_OP_FLAGS) 75 76 #define show_bio_type(op,op_flags) show_bio_op(op), \ 77 show_bio_op_flags(op_flags) 78 79 #define show_bio_op(op) blk_op_str(op) 80 81 #define show_bio_op_flags(flags) \ 82 __print_flags(F2FS_BIO_FLAG_MASK(flags), "|", \ 83 { (__force u32)REQ_RAHEAD, "R" }, \ 84 { (__force u32)REQ_SYNC, "S" }, \ 85 { (__force u32)REQ_META, "M" }, \ 86 { (__force u32)REQ_PRIO, "P" }, \ 87 { (__force u32)REQ_PREFLUSH, "PF" }, \ 88 { (__force u32)REQ_FUA, "FUA" }) 89 90 #define show_data_type(type) \ 91 __print_symbolic(type, \ 92 { CURSEG_HOT_DATA, "Hot DATA" }, \ 93 { CURSEG_WARM_DATA, "Warm DATA" }, \ 94 { CURSEG_COLD_DATA, "Cold DATA" }, \ 95 { CURSEG_HOT_NODE, "Hot NODE" }, \ 96 { CURSEG_WARM_NODE, "Warm NODE" }, \ 97 { CURSEG_COLD_NODE, "Cold NODE" }, \ 98 { NO_CHECK_TYPE, "No TYPE" }) 99 100 #define show_file_type(type) \ 101 __print_symbolic(type, \ 102 { 0, "FILE" }, \ 103 { 1, "DIR" }) 104 105 #define show_gc_type(type) \ 106 __print_symbolic(type, \ 107 { FG_GC, "Foreground GC" }, \ 108 { BG_GC, "Background GC" }) 109 110 #define show_alloc_mode(type) \ 111 __print_symbolic(type, \ 112 { LFS, "LFS-mode" }, \ 113 { SSR, "SSR-mode" }, \ 114 { AT_SSR, "AT_SSR-mode" }) 115 116 #define show_victim_policy(type) \ 117 __print_symbolic(type, \ 118 { GC_GREEDY, "Greedy" }, \ 119 { GC_CB, "Cost-Benefit" }, \ 120 { GC_AT, "Age-threshold" }) 121 122 #define show_cpreason(type) \ 123 __print_flags(type, "|", \ 124 { CP_UMOUNT, "Umount" }, \ 125 { CP_FASTBOOT, "Fastboot" }, \ 126 { CP_SYNC, "Sync" }, \ 127 { CP_RECOVERY, "Recovery" }, \ 128 { CP_DISCARD, "Discard" }, \ 129 { CP_PAUSE, "Pause" }, \ 130 { CP_TRIMMED, "Trimmed" }, \ 131 { CP_RESIZE, "Resize" }) 132 133 #define show_fsync_cpreason(type) \ 134 __print_symbolic(type, \ 135 { CP_NO_NEEDED, "no needed" }, \ 136 { CP_NON_REGULAR, "non regular" }, \ 137 { CP_COMPRESSED, "compressed" }, \ 138 { CP_HARDLINK, "hardlink" }, \ 139 { CP_SB_NEED_CP, "sb needs cp" }, \ 140 { CP_WRONG_PINO, "wrong pino" }, \ 141 { CP_NO_SPC_ROLL, "no space roll forward" }, \ 142 { CP_NODE_NEED_CP, "node needs cp" }, \ 143 { CP_FASTBOOT_MODE, "fastboot mode" }, \ 144 { CP_SPEC_LOG_NUM, "log type is 2" }, \ 145 { CP_RECOVER_DIR, "dir needs recovery" }, \ 146 { CP_XATTR_DIR, "dir's xattr updated" }) 147 148 #define show_shutdown_mode(type) \ 149 __print_symbolic(type, \ 150 { F2FS_GOING_DOWN_FULLSYNC, "full sync" }, \ 151 { F2FS_GOING_DOWN_METASYNC, "meta sync" }, \ 152 { F2FS_GOING_DOWN_NOSYNC, "no sync" }, \ 153 { F2FS_GOING_DOWN_METAFLUSH, "meta flush" }, \ 154 { F2FS_GOING_DOWN_NEED_FSCK, "need fsck" }) 155 156 #define show_compress_algorithm(type) \ 157 __print_symbolic(type, \ 158 { COMPRESS_LZO, "LZO" }, \ 159 { COMPRESS_LZ4, "LZ4" }, \ 160 { COMPRESS_ZSTD, "ZSTD" }, \ 161 { COMPRESS_LZORLE, "LZO-RLE" }) 162 163 #define show_extent_type(type) \ 164 __print_symbolic(type, \ 165 { EX_READ, "Read" }, \ 166 { EX_BLOCK_AGE, "Block Age" }) 167 168 #define show_inode_type(x) \ 169 __print_symbolic(x, \ 170 { S_IFLNK, "symbolic" }, \ 171 { S_IFREG, "regular" }, \ 172 { S_IFDIR, "directory" }, \ 173 { S_IFCHR, "character" }, \ 174 { S_IFBLK, "block" }, \ 175 { S_IFIFO, "fifo" }, \ 176 { S_IFSOCK, "sock" }) 177 178 #define S_ALL_PERM (S_ISUID | S_ISGID | S_ISVTX | \ 179 S_IRWXU | S_IRWXG | S_IRWXO) 180 181 #define show_cp_phase(phase) \ 182 __print_symbolic(phase, \ 183 { CP_PHASE_START_BLOCK_OPS, "start block_ops" }, \ 184 { CP_PHASE_FINISH_BLOCK_OPS, "finish block_ops" }, \ 185 { CP_PHASE_FINISH_CHECKPOINT, "finish checkpoint" }) 186 187 #define show_lock_name(lock) \ 188 __print_symbolic(lock, \ 189 { LOCK_NAME_CP_RWSEM, "cp_rwsem" }, \ 190 { LOCK_NAME_NODE_CHANGE, "node_change" }, \ 191 { LOCK_NAME_NODE_WRITE, "node_write" }, \ 192 { LOCK_NAME_GC_LOCK, "gc_lock" }, \ 193 { LOCK_NAME_CP_GLOBAL, "cp_global" }, \ 194 { LOCK_NAME_IO_RWSEM, "io_rwsem" }, \ 195 { LOCK_NAME_NAT_TREE_LOCK, "nat_tree_lock" }) 196 197 struct f2fs_sb_info; 198 struct f2fs_io_info; 199 struct extent_info; 200 struct victim_sel_policy; 201 struct f2fs_map_blocks; 202 203 DECLARE_EVENT_CLASS(f2fs__inode, 204 205 TP_PROTO(struct inode *inode), 206 207 TP_ARGS(inode), 208 209 TP_STRUCT__entry( 210 __field(u64, ino) 211 __field(u64, pino) 212 __field(loff_t, size) 213 __field(blkcnt_t, blocks) 214 __field(dev_t, dev) 215 __field(umode_t, mode) 216 __field(unsigned int, nlink) 217 __field(__u8, advise) 218 ), 219 220 TP_fast_assign( 221 __entry->dev = inode->i_sb->s_dev; 222 __entry->ino = inode->i_ino; 223 __entry->pino = F2FS_I(inode)->i_pino; 224 __entry->mode = inode->i_mode; 225 __entry->nlink = inode->i_nlink; 226 __entry->size = i_size_read(inode); 227 __entry->blocks = inode->i_blocks; 228 __entry->advise = F2FS_I(inode)->i_advise; 229 ), 230 231 TP_printk("dev = (%d,%d), ino = %llu, pino = %llu, i_mode = 0x%hx, " 232 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x", 233 show_dev_ino(__entry), 234 __entry->pino, 235 __entry->mode, 236 __entry->size, 237 (unsigned int)__entry->nlink, 238 (unsigned long long)__entry->blocks, 239 (unsigned char)__entry->advise) 240 ); 241 242 DECLARE_EVENT_CLASS(f2fs__inode_exit, 243 244 TP_PROTO(struct inode *inode, int ret), 245 246 TP_ARGS(inode, ret), 247 248 TP_STRUCT__entry( 249 __field(u64, ino) 250 __field(dev_t, dev) 251 __field(umode_t, mode) 252 __field(int, ret) 253 ), 254 255 TP_fast_assign( 256 __entry->dev = inode->i_sb->s_dev; 257 __entry->ino = inode->i_ino; 258 __entry->mode = inode->i_mode; 259 __entry->ret = ret; 260 ), 261 262 TP_printk("dev = (%d,%d), ino = %llu, type: %s, mode = 0%o, ret = %d", 263 show_dev_ino(__entry), 264 show_inode_type(__entry->mode & S_IFMT), 265 __entry->mode & S_ALL_PERM, 266 __entry->ret) 267 ); 268 269 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter, 270 271 TP_PROTO(struct inode *inode), 272 273 TP_ARGS(inode) 274 ); 275 276 TRACE_EVENT(f2fs_sync_file_exit, 277 278 TP_PROTO(struct inode *inode, int cp_reason, int datasync, int ret), 279 280 TP_ARGS(inode, cp_reason, datasync, ret), 281 282 TP_STRUCT__entry( 283 __field(u64, ino) 284 __field(dev_t, dev) 285 __field(int, cp_reason) 286 __field(int, datasync) 287 __field(int, ret) 288 ), 289 290 TP_fast_assign( 291 __entry->dev = inode->i_sb->s_dev; 292 __entry->ino = inode->i_ino; 293 __entry->cp_reason = cp_reason; 294 __entry->datasync = datasync; 295 __entry->ret = ret; 296 ), 297 298 TP_printk("dev = (%d,%d), ino = %llu, cp_reason: %s, " 299 "datasync = %d, ret = %d", 300 show_dev_ino(__entry), 301 show_fsync_cpreason(__entry->cp_reason), 302 __entry->datasync, 303 __entry->ret) 304 ); 305 306 TRACE_EVENT(f2fs_sync_fs, 307 308 TP_PROTO(struct super_block *sb, int wait), 309 310 TP_ARGS(sb, wait), 311 312 TP_STRUCT__entry( 313 __field(dev_t, dev) 314 __field(int, dirty) 315 __field(int, wait) 316 ), 317 318 TP_fast_assign( 319 __entry->dev = sb->s_dev; 320 __entry->dirty = is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY); 321 __entry->wait = wait; 322 ), 323 324 TP_printk("dev = (%d,%d), superblock is %s, wait = %d", 325 show_dev(__entry->dev), 326 __entry->dirty ? "dirty" : "not dirty", 327 __entry->wait) 328 ); 329 330 DEFINE_EVENT(f2fs__inode, f2fs_iget, 331 332 TP_PROTO(struct inode *inode), 333 334 TP_ARGS(inode) 335 ); 336 337 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit, 338 339 TP_PROTO(struct inode *inode, int ret), 340 341 TP_ARGS(inode, ret) 342 ); 343 344 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode, 345 346 TP_PROTO(struct inode *inode), 347 348 TP_ARGS(inode) 349 ); 350 351 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode, 352 353 TP_PROTO(struct inode *inode, int ret), 354 355 TP_ARGS(inode, ret) 356 ); 357 358 TRACE_EVENT(f2fs_unlink_enter, 359 360 TP_PROTO(struct inode *dir, struct dentry *dentry), 361 362 TP_ARGS(dir, dentry), 363 364 TP_STRUCT__entry( 365 __field(u64, ino) 366 __field(loff_t, size) 367 __field(blkcnt_t, blocks) 368 __field(dev_t, dev) 369 __string(name, dentry->d_name.name) 370 ), 371 372 TP_fast_assign( 373 __entry->dev = dir->i_sb->s_dev; 374 __entry->ino = dir->i_ino; 375 __entry->size = i_size_read(dir); 376 __entry->blocks = dir->i_blocks; 377 __assign_str(name); 378 ), 379 380 TP_printk("dev = (%d,%d), dir ino = %llu, i_size = %lld, " 381 "i_blocks = %llu, name = %s", 382 show_dev_ino(__entry), 383 __entry->size, 384 (unsigned long long)__entry->blocks, 385 __get_str(name)) 386 ); 387 388 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit, 389 390 TP_PROTO(struct inode *inode, int ret), 391 392 TP_ARGS(inode, ret) 393 ); 394 395 DEFINE_EVENT(f2fs__inode_exit, f2fs_drop_inode, 396 397 TP_PROTO(struct inode *inode, int ret), 398 399 TP_ARGS(inode, ret) 400 ); 401 402 DEFINE_EVENT(f2fs__inode, f2fs_truncate, 403 404 TP_PROTO(struct inode *inode), 405 406 TP_ARGS(inode) 407 ); 408 409 TRACE_EVENT(f2fs_truncate_data_blocks_range, 410 411 TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free), 412 413 TP_ARGS(inode, nid, ofs, free), 414 415 TP_STRUCT__entry( 416 __field(u64, ino) 417 __field(dev_t, dev) 418 __field(nid_t, nid) 419 __field(unsigned int, ofs) 420 __field(int, free) 421 ), 422 423 TP_fast_assign( 424 __entry->dev = inode->i_sb->s_dev; 425 __entry->ino = inode->i_ino; 426 __entry->nid = nid; 427 __entry->ofs = ofs; 428 __entry->free = free; 429 ), 430 431 TP_printk("dev = (%d,%d), ino = %llu, nid = %u, offset = %u, freed = %d", 432 show_dev_ino(__entry), 433 (unsigned int)__entry->nid, 434 __entry->ofs, 435 __entry->free) 436 ); 437 438 DECLARE_EVENT_CLASS(f2fs__truncate_op, 439 440 TP_PROTO(struct inode *inode, u64 from), 441 442 TP_ARGS(inode, from), 443 444 TP_STRUCT__entry( 445 __field(u64, ino) 446 __field(loff_t, size) 447 __field(blkcnt_t, blocks) 448 __field(u64, from) 449 __field(dev_t, dev) 450 ), 451 452 TP_fast_assign( 453 __entry->dev = inode->i_sb->s_dev; 454 __entry->ino = inode->i_ino; 455 __entry->size = i_size_read(inode); 456 __entry->blocks = inode->i_blocks; 457 __entry->from = from; 458 ), 459 460 TP_printk("dev = (%d,%d), ino = %llu, i_size = %lld, i_blocks = %llu, " 461 "start file offset = %llu", 462 show_dev_ino(__entry), 463 __entry->size, 464 (unsigned long long)__entry->blocks, 465 (unsigned long long)__entry->from) 466 ); 467 468 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter, 469 470 TP_PROTO(struct inode *inode, u64 from), 471 472 TP_ARGS(inode, from) 473 ); 474 475 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit, 476 477 TP_PROTO(struct inode *inode, int ret), 478 479 TP_ARGS(inode, ret) 480 ); 481 482 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter, 483 484 TP_PROTO(struct inode *inode, u64 from), 485 486 TP_ARGS(inode, from) 487 ); 488 489 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit, 490 491 TP_PROTO(struct inode *inode, int ret), 492 493 TP_ARGS(inode, ret) 494 ); 495 496 DECLARE_EVENT_CLASS(f2fs__truncate_node, 497 498 TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr), 499 500 TP_ARGS(inode, nid, blk_addr), 501 502 TP_STRUCT__entry( 503 __field(u64, ino) 504 __field(dev_t, dev) 505 __field(nid_t, nid) 506 __field(block_t, blk_addr) 507 ), 508 509 TP_fast_assign( 510 __entry->dev = inode->i_sb->s_dev; 511 __entry->ino = inode->i_ino; 512 __entry->nid = nid; 513 __entry->blk_addr = blk_addr; 514 ), 515 516 TP_printk("dev = (%d,%d), ino = %llu, nid = %u, block_address = 0x%llx", 517 show_dev_ino(__entry), 518 (unsigned int)__entry->nid, 519 (unsigned long long)__entry->blk_addr) 520 ); 521 522 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter, 523 524 TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr), 525 526 TP_ARGS(inode, nid, blk_addr) 527 ); 528 529 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit, 530 531 TP_PROTO(struct inode *inode, int ret), 532 533 TP_ARGS(inode, ret) 534 ); 535 536 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node, 537 538 TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr), 539 540 TP_ARGS(inode, nid, blk_addr) 541 ); 542 543 TRACE_EVENT(f2fs_truncate_partial_nodes, 544 545 TP_PROTO(struct inode *inode, nid_t *nid, int depth, int err), 546 547 TP_ARGS(inode, nid, depth, err), 548 549 TP_STRUCT__entry( 550 __field(u64, ino) 551 __field(dev_t, dev) 552 __array(nid_t, nid, 3) 553 __field(int, depth) 554 __field(int, err) 555 ), 556 557 TP_fast_assign( 558 __entry->dev = inode->i_sb->s_dev; 559 __entry->ino = inode->i_ino; 560 __entry->nid[0] = nid[0]; 561 __entry->nid[1] = nid[1]; 562 __entry->nid[2] = nid[2]; 563 __entry->depth = depth; 564 __entry->err = err; 565 ), 566 567 TP_printk("dev = (%d,%d), ino = %llu, " 568 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d", 569 show_dev_ino(__entry), 570 (unsigned int)__entry->nid[0], 571 (unsigned int)__entry->nid[1], 572 (unsigned int)__entry->nid[2], 573 __entry->depth, 574 __entry->err) 575 ); 576 577 TRACE_EVENT(f2fs_file_write_iter, 578 579 TP_PROTO(struct inode *inode, loff_t offset, size_t length, 580 ssize_t ret), 581 582 TP_ARGS(inode, offset, length, ret), 583 584 TP_STRUCT__entry( 585 __field(u64, ino) 586 __field(loff_t, offset) 587 __field(size_t, length) 588 __field(ssize_t, ret) 589 __field(dev_t, dev) 590 ), 591 592 TP_fast_assign( 593 __entry->dev = inode->i_sb->s_dev; 594 __entry->ino = inode->i_ino; 595 __entry->offset = offset; 596 __entry->length = length; 597 __entry->ret = ret; 598 ), 599 600 TP_printk("dev = (%d,%d), ino = %llu, " 601 "offset = %lld, length = %zu, written(err) = %zd", 602 show_dev_ino(__entry), 603 __entry->offset, 604 __entry->length, 605 __entry->ret) 606 ); 607 608 TRACE_EVENT(f2fs_fadvise, 609 610 TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int advice), 611 612 TP_ARGS(inode, offset, len, advice), 613 614 TP_STRUCT__entry( 615 __field(u64, ino) 616 __field(loff_t, size) 617 __field(loff_t, offset) 618 __field(loff_t, len) 619 __field(dev_t, dev) 620 __field(int, advice) 621 ), 622 623 TP_fast_assign( 624 __entry->dev = inode->i_sb->s_dev; 625 __entry->ino = inode->i_ino; 626 __entry->size = i_size_read(inode); 627 __entry->offset = offset; 628 __entry->len = len; 629 __entry->advice = advice; 630 ), 631 632 TP_printk("dev = (%d,%d), ino = %llu, i_size = %lld offset:%llu, len:%llu, advise:%d", 633 show_dev_ino(__entry), 634 (unsigned long long)__entry->size, 635 __entry->offset, 636 __entry->len, 637 __entry->advice) 638 ); 639 640 TRACE_EVENT(f2fs_map_blocks, 641 TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map, int flag, 642 int ret), 643 644 TP_ARGS(inode, map, flag, ret), 645 646 TP_STRUCT__entry( 647 __field(u64, ino) 648 __field(dev_t, dev) 649 __field(block_t, m_lblk) 650 __field(block_t, m_pblk) 651 __field(unsigned int, m_len) 652 __field(unsigned int, m_flags) 653 __field(int, m_seg_type) 654 __field(bool, m_may_create) 655 __field(bool, m_multidev_dio) 656 __field(int, flag) 657 __field(int, ret) 658 ), 659 660 TP_fast_assign( 661 __entry->dev = map->m_bdev->bd_dev; 662 __entry->ino = inode->i_ino; 663 __entry->m_lblk = map->m_lblk; 664 __entry->m_pblk = map->m_pblk; 665 __entry->m_len = map->m_len; 666 __entry->m_flags = map->m_flags; 667 __entry->m_seg_type = map->m_seg_type; 668 __entry->m_may_create = map->m_may_create; 669 __entry->m_multidev_dio = map->m_multidev_dio; 670 __entry->flag = flag; 671 __entry->ret = ret; 672 ), 673 674 TP_printk("dev = (%d,%d), ino = %llu, file offset = %llu, " 675 "start blkaddr = 0x%llx, len = 0x%llx, flags = %u, " 676 "seg_type = %d, may_create = %d, multidevice = %d, " 677 "flag = %d, err = %d", 678 show_dev_ino(__entry), 679 (unsigned long long)__entry->m_lblk, 680 (unsigned long long)__entry->m_pblk, 681 (unsigned long long)__entry->m_len, 682 __entry->m_flags, 683 __entry->m_seg_type, 684 __entry->m_may_create, 685 __entry->m_multidev_dio, 686 __entry->flag, 687 __entry->ret) 688 ); 689 690 TRACE_EVENT(f2fs_background_gc, 691 692 TP_PROTO(struct super_block *sb, unsigned int wait_ms, 693 unsigned int prefree, unsigned int free), 694 695 TP_ARGS(sb, wait_ms, prefree, free), 696 697 TP_STRUCT__entry( 698 __field(dev_t, dev) 699 __field(unsigned int, wait_ms) 700 __field(unsigned int, prefree) 701 __field(unsigned int, free) 702 ), 703 704 TP_fast_assign( 705 __entry->dev = sb->s_dev; 706 __entry->wait_ms = wait_ms; 707 __entry->prefree = prefree; 708 __entry->free = free; 709 ), 710 711 TP_printk("dev = (%d,%d), wait_ms = %u, prefree = %u, free = %u", 712 show_dev(__entry->dev), 713 __entry->wait_ms, 714 __entry->prefree, 715 __entry->free) 716 ); 717 718 TRACE_EVENT(f2fs_gc_begin, 719 720 TP_PROTO(struct super_block *sb, int gc_type, bool no_bg_gc, 721 unsigned int nr_free_secs, 722 long long dirty_nodes, long long dirty_dents, 723 long long dirty_imeta, unsigned int free_sec, 724 unsigned int free_seg, int reserved_seg, 725 unsigned int prefree_seg), 726 727 TP_ARGS(sb, gc_type, no_bg_gc, nr_free_secs, dirty_nodes, 728 dirty_dents, dirty_imeta, 729 free_sec, free_seg, reserved_seg, prefree_seg), 730 731 TP_STRUCT__entry( 732 __field(dev_t, dev) 733 __field(int, gc_type) 734 __field(bool, no_bg_gc) 735 __field(unsigned int, nr_free_secs) 736 __field(long long, dirty_nodes) 737 __field(long long, dirty_dents) 738 __field(long long, dirty_imeta) 739 __field(unsigned int, free_sec) 740 __field(unsigned int, free_seg) 741 __field(int, reserved_seg) 742 __field(unsigned int, prefree_seg) 743 ), 744 745 TP_fast_assign( 746 __entry->dev = sb->s_dev; 747 __entry->gc_type = gc_type; 748 __entry->no_bg_gc = no_bg_gc; 749 __entry->nr_free_secs = nr_free_secs; 750 __entry->dirty_nodes = dirty_nodes; 751 __entry->dirty_dents = dirty_dents; 752 __entry->dirty_imeta = dirty_imeta; 753 __entry->free_sec = free_sec; 754 __entry->free_seg = free_seg; 755 __entry->reserved_seg = reserved_seg; 756 __entry->prefree_seg = prefree_seg; 757 ), 758 759 TP_printk("dev = (%d,%d), gc_type = %s, no_background_GC = %d, nr_free_secs = %u, " 760 "nodes = %lld, dents = %lld, imeta = %lld, free_sec:%u, free_seg:%u, " 761 "rsv_seg:%d, prefree_seg:%u", 762 show_dev(__entry->dev), 763 show_gc_type(__entry->gc_type), 764 (__entry->gc_type == BG_GC) ? __entry->no_bg_gc : -1, 765 __entry->nr_free_secs, 766 __entry->dirty_nodes, 767 __entry->dirty_dents, 768 __entry->dirty_imeta, 769 __entry->free_sec, 770 __entry->free_seg, 771 __entry->reserved_seg, 772 __entry->prefree_seg) 773 ); 774 775 TRACE_EVENT(f2fs_gc_end, 776 777 TP_PROTO(struct super_block *sb, int ret, int seg_freed, 778 int sec_freed, long long dirty_nodes, 779 long long dirty_dents, long long dirty_imeta, 780 unsigned int free_sec, unsigned int free_seg, 781 int reserved_seg, unsigned int prefree_seg), 782 783 TP_ARGS(sb, ret, seg_freed, sec_freed, dirty_nodes, dirty_dents, 784 dirty_imeta, free_sec, free_seg, reserved_seg, prefree_seg), 785 786 TP_STRUCT__entry( 787 __field(dev_t, dev) 788 __field(int, ret) 789 __field(int, seg_freed) 790 __field(int, sec_freed) 791 __field(long long, dirty_nodes) 792 __field(long long, dirty_dents) 793 __field(long long, dirty_imeta) 794 __field(unsigned int, free_sec) 795 __field(unsigned int, free_seg) 796 __field(int, reserved_seg) 797 __field(unsigned int, prefree_seg) 798 ), 799 800 TP_fast_assign( 801 __entry->dev = sb->s_dev; 802 __entry->ret = ret; 803 __entry->seg_freed = seg_freed; 804 __entry->sec_freed = sec_freed; 805 __entry->dirty_nodes = dirty_nodes; 806 __entry->dirty_dents = dirty_dents; 807 __entry->dirty_imeta = dirty_imeta; 808 __entry->free_sec = free_sec; 809 __entry->free_seg = free_seg; 810 __entry->reserved_seg = reserved_seg; 811 __entry->prefree_seg = prefree_seg; 812 ), 813 814 TP_printk("dev = (%d,%d), ret = %d, seg_freed = %d, sec_freed = %d, " 815 "nodes = %lld, dents = %lld, imeta = %lld, free_sec:%u, " 816 "free_seg:%u, rsv_seg:%d, prefree_seg:%u", 817 show_dev(__entry->dev), 818 __entry->ret, 819 __entry->seg_freed, 820 __entry->sec_freed, 821 __entry->dirty_nodes, 822 __entry->dirty_dents, 823 __entry->dirty_imeta, 824 __entry->free_sec, 825 __entry->free_seg, 826 __entry->reserved_seg, 827 __entry->prefree_seg) 828 ); 829 830 TRACE_EVENT(f2fs_get_victim, 831 832 TP_PROTO(struct super_block *sb, int type, int gc_type, 833 struct victim_sel_policy *p, unsigned int pre_victim, 834 unsigned int prefree, unsigned int free), 835 836 TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free), 837 838 TP_STRUCT__entry( 839 __field(dev_t, dev) 840 __field(int, type) 841 __field(int, gc_type) 842 __field(int, alloc_mode) 843 __field(int, gc_mode) 844 __field(unsigned int, victim) 845 __field(unsigned int, cost) 846 __field(unsigned int, ofs_unit) 847 __field(unsigned int, pre_victim) 848 __field(unsigned int, prefree) 849 __field(unsigned int, free) 850 ), 851 852 TP_fast_assign( 853 __entry->dev = sb->s_dev; 854 __entry->type = type; 855 __entry->gc_type = gc_type; 856 __entry->alloc_mode = p->alloc_mode; 857 __entry->gc_mode = p->gc_mode; 858 __entry->victim = p->min_segno; 859 __entry->cost = p->min_cost; 860 __entry->ofs_unit = p->ofs_unit; 861 __entry->pre_victim = pre_victim; 862 __entry->prefree = prefree; 863 __entry->free = free; 864 ), 865 866 TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), " 867 "victim = %u, cost = %u, ofs_unit = %u, " 868 "pre_victim_secno = %d, prefree = %u, free = %u", 869 show_dev(__entry->dev), 870 show_data_type(__entry->type), 871 show_gc_type(__entry->gc_type), 872 show_alloc_mode(__entry->alloc_mode), 873 show_victim_policy(__entry->gc_mode), 874 __entry->victim, 875 __entry->cost, 876 __entry->ofs_unit, 877 (int)__entry->pre_victim, 878 __entry->prefree, 879 __entry->free) 880 ); 881 882 TRACE_EVENT(f2fs_lookup_start, 883 884 TP_PROTO(struct inode *dir, struct dentry *dentry, unsigned int flags), 885 886 TP_ARGS(dir, dentry, flags), 887 888 TP_STRUCT__entry( 889 __field(u64, ino) 890 __field(dev_t, dev) 891 __string(name, dentry->d_name.name) 892 __field(unsigned int, flags) 893 ), 894 895 TP_fast_assign( 896 __entry->dev = dir->i_sb->s_dev; 897 __entry->ino = dir->i_ino; 898 __assign_str(name); 899 __entry->flags = flags; 900 ), 901 902 TP_printk("dev = (%d,%d), pino = %llu, name:%s, flags:%u", 903 show_dev_ino(__entry), 904 __get_str(name), 905 __entry->flags) 906 ); 907 908 TRACE_EVENT(f2fs_lookup_end, 909 910 TP_PROTO(struct inode *dir, struct dentry *dentry, nid_t ino, 911 int err), 912 913 TP_ARGS(dir, dentry, ino, err), 914 915 TP_STRUCT__entry( 916 __field(u64, ino) 917 __field(dev_t, dev) 918 __string(name, dentry->d_name.name) 919 __field(nid_t, cino) 920 __field(int, err) 921 ), 922 923 TP_fast_assign( 924 __entry->dev = dir->i_sb->s_dev; 925 __entry->ino = dir->i_ino; 926 __assign_str(name); 927 __entry->cino = ino; 928 __entry->err = err; 929 ), 930 931 TP_printk("dev = (%d,%d), pino = %llu, name:%s, ino:%u, err:%d", 932 show_dev_ino(__entry), 933 __get_str(name), 934 __entry->cino, 935 __entry->err) 936 ); 937 938 TRACE_EVENT(f2fs_rename_start, 939 940 TP_PROTO(struct inode *old_dir, struct dentry *old_dentry, 941 struct inode *new_dir, struct dentry *new_dentry, 942 unsigned int flags), 943 944 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, flags), 945 946 TP_STRUCT__entry( 947 __field(u64, ino) 948 __field(u64, new_pino) 949 __field(dev_t, dev) 950 __string(old_name, old_dentry->d_name.name) 951 __string(new_name, new_dentry->d_name.name) 952 __field(unsigned int, flags) 953 ), 954 955 TP_fast_assign( 956 __entry->dev = old_dir->i_sb->s_dev; 957 __entry->ino = old_dir->i_ino; 958 __assign_str(old_name); 959 __entry->new_pino = new_dir->i_ino; 960 __assign_str(new_name); 961 __entry->flags = flags; 962 ), 963 964 TP_printk("dev = (%d,%d), old_dir = %llu, old_name: %s, " 965 "new_dir = %llu, new_name: %s, flags = %u", 966 show_dev_ino(__entry), 967 __get_str(old_name), 968 __entry->new_pino, 969 __get_str(new_name), 970 __entry->flags) 971 ); 972 973 TRACE_EVENT(f2fs_rename_end, 974 975 TP_PROTO(struct dentry *old_dentry, struct dentry *new_dentry, 976 unsigned int flags, int ret), 977 978 TP_ARGS(old_dentry, new_dentry, flags, ret), 979 980 TP_STRUCT__entry( 981 __field(u64, ino) 982 __field(dev_t, dev) 983 __string(old_name, old_dentry->d_name.name) 984 __string(new_name, new_dentry->d_name.name) 985 __field(unsigned int, flags) 986 __field(int, ret) 987 ), 988 989 TP_fast_assign( 990 __entry->dev = old_dentry->d_sb->s_dev; 991 __entry->ino = old_dentry->d_inode->i_ino; 992 __assign_str(old_name); 993 __assign_str(new_name); 994 __entry->flags = flags; 995 __entry->ret = ret; 996 ), 997 998 TP_printk("dev = (%d,%d), ino = %llu, old_name: %s, " 999 "new_name: %s, flags = %u, ret = %d", 1000 show_dev_ino(__entry), 1001 __get_str(old_name), 1002 __get_str(new_name), 1003 __entry->flags, 1004 __entry->ret) 1005 ); 1006 1007 TRACE_EVENT(f2fs_readdir, 1008 1009 TP_PROTO(struct inode *dir, loff_t start_pos, loff_t end_pos, int err), 1010 1011 TP_ARGS(dir, start_pos, end_pos, err), 1012 1013 TP_STRUCT__entry( 1014 __field(u64, ino) 1015 __field(loff_t, start) 1016 __field(loff_t, end) 1017 __field(dev_t, dev) 1018 __field(int, err) 1019 ), 1020 1021 TP_fast_assign( 1022 __entry->dev = dir->i_sb->s_dev; 1023 __entry->ino = dir->i_ino; 1024 __entry->start = start_pos; 1025 __entry->end = end_pos; 1026 __entry->err = err; 1027 ), 1028 1029 TP_printk("dev = (%d,%d), ino = %llu, start_pos:%llu, end_pos:%llu, err:%d", 1030 show_dev_ino(__entry), 1031 __entry->start, 1032 __entry->end, 1033 __entry->err) 1034 ); 1035 1036 TRACE_EVENT(f2fs_fallocate, 1037 1038 TP_PROTO(struct inode *inode, int mode, 1039 loff_t offset, loff_t len, int ret), 1040 1041 TP_ARGS(inode, mode, offset, len, ret), 1042 1043 TP_STRUCT__entry( 1044 __field(u64, ino) 1045 __field(loff_t, offset) 1046 __field(loff_t, len) 1047 __field(loff_t, size) 1048 __field(blkcnt_t, blocks) 1049 __field(dev_t, dev) 1050 __field(int, mode) 1051 __field(int, ret) 1052 ), 1053 1054 TP_fast_assign( 1055 __entry->dev = inode->i_sb->s_dev; 1056 __entry->ino = inode->i_ino; 1057 __entry->mode = mode; 1058 __entry->offset = offset; 1059 __entry->len = len; 1060 __entry->size = i_size_read(inode); 1061 __entry->blocks = inode->i_blocks; 1062 __entry->ret = ret; 1063 ), 1064 1065 TP_printk("dev = (%d,%d), ino = %llu, mode = %x, offset = %lld, " 1066 "len = %lld, i_size = %lld, i_blocks = %llu, ret = %d", 1067 show_dev_ino(__entry), 1068 __entry->mode, 1069 (unsigned long long)__entry->offset, 1070 (unsigned long long)__entry->len, 1071 (unsigned long long)__entry->size, 1072 (unsigned long long)__entry->blocks, 1073 __entry->ret) 1074 ); 1075 1076 TRACE_EVENT(f2fs_direct_IO_enter, 1077 1078 TP_PROTO(struct inode *inode, struct kiocb *iocb, long len, int rw), 1079 1080 TP_ARGS(inode, iocb, len, rw), 1081 1082 TP_STRUCT__entry( 1083 __field(u64, ino) 1084 __field(loff_t, ki_pos) 1085 __field(unsigned long, len) 1086 __field(dev_t, dev) 1087 __field(int, ki_flags) 1088 __field(u16, ki_ioprio) 1089 __field(int, rw) 1090 ), 1091 1092 TP_fast_assign( 1093 __entry->dev = inode->i_sb->s_dev; 1094 __entry->ino = inode->i_ino; 1095 __entry->ki_pos = iocb->ki_pos; 1096 __entry->ki_flags = iocb->ki_flags; 1097 __entry->ki_ioprio = iocb->ki_ioprio; 1098 __entry->len = len; 1099 __entry->rw = rw; 1100 ), 1101 1102 TP_printk("dev = (%d,%d), ino = %llu pos = %lld len = %lu ki_flags = %x ki_ioprio = %x rw = %d", 1103 show_dev_ino(__entry), 1104 __entry->ki_pos, 1105 __entry->len, 1106 __entry->ki_flags, 1107 __entry->ki_ioprio, 1108 __entry->rw) 1109 ); 1110 1111 TRACE_EVENT(f2fs_direct_IO_exit, 1112 1113 TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, 1114 int rw, int ret), 1115 1116 TP_ARGS(inode, offset, len, rw, ret), 1117 1118 TP_STRUCT__entry( 1119 __field(u64, ino) 1120 __field(loff_t, pos) 1121 __field(unsigned long, len) 1122 __field(dev_t, dev) 1123 __field(int, rw) 1124 __field(int, ret) 1125 ), 1126 1127 TP_fast_assign( 1128 __entry->dev = inode->i_sb->s_dev; 1129 __entry->ino = inode->i_ino; 1130 __entry->pos = offset; 1131 __entry->len = len; 1132 __entry->rw = rw; 1133 __entry->ret = ret; 1134 ), 1135 1136 TP_printk("dev = (%d,%d), ino = %llu pos = %lld len = %lu " 1137 "rw = %d ret = %d", 1138 show_dev_ino(__entry), 1139 __entry->pos, 1140 __entry->len, 1141 __entry->rw, 1142 __entry->ret) 1143 ); 1144 1145 TRACE_EVENT(f2fs_reserve_new_blocks, 1146 1147 TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node, 1148 blkcnt_t count), 1149 1150 TP_ARGS(inode, nid, ofs_in_node, count), 1151 1152 TP_STRUCT__entry( 1153 __field(dev_t, dev) 1154 __field(nid_t, nid) 1155 __field(unsigned int, ofs_in_node) 1156 __field(blkcnt_t, count) 1157 ), 1158 1159 TP_fast_assign( 1160 __entry->dev = inode->i_sb->s_dev; 1161 __entry->nid = nid; 1162 __entry->ofs_in_node = ofs_in_node; 1163 __entry->count = count; 1164 ), 1165 1166 TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u, count = %llu", 1167 show_dev(__entry->dev), 1168 (unsigned int)__entry->nid, 1169 __entry->ofs_in_node, 1170 (unsigned long long)__entry->count) 1171 ); 1172 1173 DECLARE_EVENT_CLASS(f2fs__submit_folio_bio, 1174 1175 TP_PROTO(struct folio *folio, struct f2fs_io_info *fio), 1176 1177 TP_ARGS(folio, fio), 1178 1179 TP_STRUCT__entry( 1180 __field(u64, ino) 1181 __field(pgoff_t, index) 1182 __field(dev_t, dev) 1183 __field(block_t, old_blkaddr) 1184 __field(block_t, new_blkaddr) 1185 __field(enum req_op, op) 1186 __field(blk_opf_t, op_flags) 1187 __field(int, temp) 1188 __field(int, type) 1189 ), 1190 1191 TP_fast_assign( 1192 __entry->dev = folio->mapping->host->i_sb->s_dev; 1193 __entry->ino = folio->mapping->host->i_ino; 1194 __entry->index = folio->index; 1195 __entry->old_blkaddr = fio->old_blkaddr; 1196 __entry->new_blkaddr = fio->new_blkaddr; 1197 __entry->op = fio->op; 1198 __entry->op_flags = fio->op_flags; 1199 __entry->temp = fio->temp; 1200 __entry->type = fio->type; 1201 ), 1202 1203 TP_printk("dev = (%d,%d), ino = %llu, folio_index = 0x%lx, " 1204 "oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s(%s), type = %s_%s", 1205 show_dev_ino(__entry), 1206 (unsigned long)__entry->index, 1207 (unsigned long long)__entry->old_blkaddr, 1208 (unsigned long long)__entry->new_blkaddr, 1209 show_bio_type(__entry->op, __entry->op_flags), 1210 show_block_temp(__entry->temp), 1211 show_block_type(__entry->type)) 1212 ); 1213 1214 DEFINE_EVENT_CONDITION(f2fs__submit_folio_bio, f2fs_submit_folio_bio, 1215 1216 TP_PROTO(struct folio *folio, struct f2fs_io_info *fio), 1217 1218 TP_ARGS(folio, fio), 1219 1220 TP_CONDITION(folio->mapping) 1221 ); 1222 1223 DEFINE_EVENT_CONDITION(f2fs__submit_folio_bio, f2fs_submit_folio_write, 1224 1225 TP_PROTO(struct folio *folio, struct f2fs_io_info *fio), 1226 1227 TP_ARGS(folio, fio), 1228 1229 TP_CONDITION(folio->mapping) 1230 ); 1231 1232 DECLARE_EVENT_CLASS(f2fs__bio, 1233 1234 TP_PROTO(struct super_block *sb, int type, struct bio *bio), 1235 1236 TP_ARGS(sb, type, bio), 1237 1238 TP_STRUCT__entry( 1239 __field(dev_t, dev) 1240 __field(dev_t, target) 1241 __field(enum req_op, op) 1242 __field(blk_opf_t, op_flags) 1243 __field(int, type) 1244 __field(sector_t, sector) 1245 __field(unsigned int, size) 1246 ), 1247 1248 TP_fast_assign( 1249 __entry->dev = sb->s_dev; 1250 __entry->target = bio_dev(bio); 1251 __entry->op = bio_op(bio); 1252 __entry->op_flags = bio->bi_opf; 1253 __entry->type = type; 1254 __entry->sector = bio->bi_iter.bi_sector; 1255 __entry->size = bio->bi_iter.bi_size; 1256 ), 1257 1258 TP_printk("dev = (%d,%d)/(%d,%d), rw = %s(%s), %s, sector = %lld, size = %u", 1259 show_dev(__entry->target), 1260 show_dev(__entry->dev), 1261 show_bio_type(__entry->op, __entry->op_flags), 1262 show_block_type(__entry->type), 1263 (unsigned long long)__entry->sector, 1264 __entry->size) 1265 ); 1266 1267 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_write_bio, 1268 1269 TP_PROTO(struct super_block *sb, int type, struct bio *bio), 1270 1271 TP_ARGS(sb, type, bio), 1272 1273 TP_CONDITION(bio) 1274 ); 1275 1276 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_read_bio, 1277 1278 TP_PROTO(struct super_block *sb, int type, struct bio *bio), 1279 1280 TP_ARGS(sb, type, bio), 1281 1282 TP_CONDITION(bio) 1283 ); 1284 1285 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_read_bio, 1286 1287 TP_PROTO(struct super_block *sb, int type, struct bio *bio), 1288 1289 TP_ARGS(sb, type, bio), 1290 1291 TP_CONDITION(bio) 1292 ); 1293 1294 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_write_bio, 1295 1296 TP_PROTO(struct super_block *sb, int type, struct bio *bio), 1297 1298 TP_ARGS(sb, type, bio), 1299 1300 TP_CONDITION(bio) 1301 ); 1302 1303 TRACE_EVENT(f2fs_write_begin, 1304 1305 TP_PROTO(struct inode *inode, loff_t pos, unsigned int len), 1306 1307 TP_ARGS(inode, pos, len), 1308 1309 TP_STRUCT__entry( 1310 __field(u64, ino) 1311 __field(loff_t, pos) 1312 __field(dev_t, dev) 1313 __field(unsigned int, len) 1314 ), 1315 1316 TP_fast_assign( 1317 __entry->dev = inode->i_sb->s_dev; 1318 __entry->ino = inode->i_ino; 1319 __entry->pos = pos; 1320 __entry->len = len; 1321 ), 1322 1323 TP_printk("dev = (%d,%d), ino = %llu, pos = %llu, len = %u", 1324 show_dev_ino(__entry), 1325 (unsigned long long)__entry->pos, 1326 __entry->len) 1327 ); 1328 1329 TRACE_EVENT(f2fs_write_end, 1330 1331 TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, 1332 unsigned int copied), 1333 1334 TP_ARGS(inode, pos, len, copied), 1335 1336 TP_STRUCT__entry( 1337 __field(u64, ino) 1338 __field(loff_t, pos) 1339 __field(dev_t, dev) 1340 __field(unsigned int, len) 1341 __field(unsigned int, copied) 1342 ), 1343 1344 TP_fast_assign( 1345 __entry->dev = inode->i_sb->s_dev; 1346 __entry->ino = inode->i_ino; 1347 __entry->pos = pos; 1348 __entry->len = len; 1349 __entry->copied = copied; 1350 ), 1351 1352 TP_printk("dev = (%d,%d), ino = %llu, pos = %llu, len = %u, copied = %u", 1353 show_dev_ino(__entry), 1354 (unsigned long long)__entry->pos, 1355 __entry->len, 1356 __entry->copied) 1357 ); 1358 1359 DECLARE_EVENT_CLASS(f2fs__folio, 1360 1361 TP_PROTO(struct folio *folio, int type), 1362 1363 TP_ARGS(folio, type), 1364 1365 TP_STRUCT__entry( 1366 __field(u64, ino) 1367 __field(pgoff_t, index) 1368 __field(pgoff_t, nrpages) 1369 __field(dev_t, dev) 1370 __field(int, type) 1371 __field(int, dir) 1372 __field(int, dirty) 1373 __field(int, uptodate) 1374 ), 1375 1376 TP_fast_assign( 1377 __entry->dev = folio->mapping->host->i_sb->s_dev; 1378 __entry->ino = folio->mapping->host->i_ino; 1379 __entry->type = type; 1380 __entry->dir = S_ISDIR(folio->mapping->host->i_mode); 1381 __entry->index = folio->index; 1382 __entry->nrpages= folio_nr_pages(folio); 1383 __entry->dirty = folio_test_dirty(folio); 1384 __entry->uptodate = folio_test_uptodate(folio); 1385 ), 1386 1387 TP_printk("dev = (%d,%d), ino = %llu, %s, %s, index = %lu, nr_pages = %lu, " 1388 "dirty = %d, uptodate = %d", 1389 show_dev_ino(__entry), 1390 show_block_type(__entry->type), 1391 show_file_type(__entry->dir), 1392 (unsigned long)__entry->index, 1393 (unsigned long)__entry->nrpages, 1394 __entry->dirty, 1395 __entry->uptodate) 1396 ); 1397 1398 DEFINE_EVENT(f2fs__folio, f2fs_writepage, 1399 1400 TP_PROTO(struct folio *folio, int type), 1401 1402 TP_ARGS(folio, type) 1403 ); 1404 1405 DEFINE_EVENT(f2fs__folio, f2fs_do_write_data_page, 1406 1407 TP_PROTO(struct folio *folio, int type), 1408 1409 TP_ARGS(folio, type) 1410 ); 1411 1412 DEFINE_EVENT(f2fs__folio, f2fs_readpage, 1413 1414 TP_PROTO(struct folio *folio, int type), 1415 1416 TP_ARGS(folio, type) 1417 ); 1418 1419 DEFINE_EVENT(f2fs__folio, f2fs_read_folio, 1420 1421 TP_PROTO(struct folio *folio, int type), 1422 1423 TP_ARGS(folio, type) 1424 ); 1425 1426 DEFINE_EVENT(f2fs__folio, f2fs_set_page_dirty, 1427 1428 TP_PROTO(struct folio *folio, int type), 1429 1430 TP_ARGS(folio, type) 1431 ); 1432 1433 TRACE_EVENT(f2fs_replace_atomic_write_block, 1434 1435 TP_PROTO(struct inode *inode, struct inode *cow_inode, pgoff_t index, 1436 block_t old_addr, block_t new_addr, bool recovery), 1437 1438 TP_ARGS(inode, cow_inode, index, old_addr, new_addr, recovery), 1439 1440 TP_STRUCT__entry( 1441 __field(u64, ino) 1442 __field(u64, cow_ino) 1443 __field(pgoff_t, index) 1444 __field(dev_t, dev) 1445 __field(block_t, old_addr) 1446 __field(block_t, new_addr) 1447 __field(bool, recovery) 1448 ), 1449 1450 TP_fast_assign( 1451 __entry->dev = inode->i_sb->s_dev; 1452 __entry->ino = inode->i_ino; 1453 __entry->cow_ino = cow_inode->i_ino; 1454 __entry->index = index; 1455 __entry->old_addr = old_addr; 1456 __entry->new_addr = new_addr; 1457 __entry->recovery = recovery; 1458 ), 1459 1460 TP_printk("dev = (%d,%d), ino = %llu, cow_ino = %llu, index = %lu, " 1461 "old_addr = 0x%llx, new_addr = 0x%llx, recovery = %d", 1462 show_dev_ino(__entry), 1463 __entry->cow_ino, 1464 (unsigned long)__entry->index, 1465 (unsigned long long)__entry->old_addr, 1466 (unsigned long long)__entry->new_addr, 1467 __entry->recovery) 1468 ); 1469 1470 DECLARE_EVENT_CLASS(f2fs_mmap, 1471 1472 TP_PROTO(struct inode *inode, pgoff_t index, 1473 vm_flags_t flags, vm_fault_t ret), 1474 1475 TP_ARGS(inode, index, flags, ret), 1476 1477 TP_STRUCT__entry( 1478 __field(u64, ino) 1479 __field(pgoff_t, index) 1480 __field(vm_flags_t, flags) 1481 __field(dev_t, dev) 1482 __field(vm_fault_t, ret) 1483 ), 1484 1485 TP_fast_assign( 1486 __entry->dev = inode->i_sb->s_dev; 1487 __entry->ino = inode->i_ino; 1488 __entry->index = index; 1489 __entry->flags = flags; 1490 __entry->ret = ret; 1491 ), 1492 1493 TP_printk("dev = (%d,%d), ino = %llu, index = %lu, flags: %s, ret: %s", 1494 show_dev_ino(__entry), 1495 (unsigned long)__entry->index, 1496 __print_flags(__entry->flags, "|", FAULT_FLAG_TRACE), 1497 __print_flags(__entry->ret, "|", VM_FAULT_RESULT_TRACE)) 1498 ); 1499 1500 DEFINE_EVENT(f2fs_mmap, f2fs_filemap_fault, 1501 1502 TP_PROTO(struct inode *inode, pgoff_t index, 1503 vm_flags_t flags, vm_fault_t ret), 1504 1505 TP_ARGS(inode, index, flags, ret) 1506 ); 1507 1508 DEFINE_EVENT(f2fs_mmap, f2fs_vm_page_mkwrite, 1509 1510 TP_PROTO(struct inode *inode, pgoff_t index, 1511 vm_flags_t flags, vm_fault_t ret), 1512 1513 TP_ARGS(inode, index, flags, ret) 1514 ); 1515 1516 TRACE_EVENT(f2fs_writepages, 1517 1518 TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type), 1519 1520 TP_ARGS(inode, wbc, type), 1521 1522 TP_STRUCT__entry( 1523 __field(u64, ino) 1524 __field(loff_t, range_start) 1525 __field(loff_t, range_end) 1526 __field(long, nr_to_write) 1527 __field(long, pages_skipped) 1528 __field(pgoff_t, writeback_index) 1529 __field(dev_t, dev) 1530 __field(int, type) 1531 __field(int, dir) 1532 __field(int, sync_mode) 1533 __field(char, for_kupdate) 1534 __field(char, for_background) 1535 __field(char, tagged_writepages) 1536 __field(char, range_cyclic) 1537 __field(char, for_sync) 1538 ), 1539 1540 TP_fast_assign( 1541 __entry->dev = inode->i_sb->s_dev; 1542 __entry->ino = inode->i_ino; 1543 __entry->type = type; 1544 __entry->dir = S_ISDIR(inode->i_mode); 1545 __entry->nr_to_write = wbc->nr_to_write; 1546 __entry->pages_skipped = wbc->pages_skipped; 1547 __entry->range_start = wbc->range_start; 1548 __entry->range_end = wbc->range_end; 1549 __entry->writeback_index = inode->i_mapping->writeback_index; 1550 __entry->sync_mode = wbc->sync_mode; 1551 __entry->for_kupdate = wbc->for_kupdate; 1552 __entry->for_background = wbc->for_background; 1553 __entry->tagged_writepages = wbc->tagged_writepages; 1554 __entry->range_cyclic = wbc->range_cyclic; 1555 __entry->for_sync = wbc->for_sync; 1556 ), 1557 1558 TP_printk("dev = (%d,%d), ino = %llu, %s, %s, nr_to_write %ld, " 1559 "skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, " 1560 "kupdate %u background %u tagged %u cyclic %u sync %u", 1561 show_dev_ino(__entry), 1562 show_block_type(__entry->type), 1563 show_file_type(__entry->dir), 1564 __entry->nr_to_write, 1565 __entry->pages_skipped, 1566 __entry->range_start, 1567 __entry->range_end, 1568 (unsigned long)__entry->writeback_index, 1569 __entry->sync_mode, 1570 __entry->for_kupdate, 1571 __entry->for_background, 1572 __entry->tagged_writepages, 1573 __entry->range_cyclic, 1574 __entry->for_sync) 1575 ); 1576 1577 TRACE_EVENT(f2fs_readpages, 1578 1579 TP_PROTO(struct inode *inode, pgoff_t start, unsigned int nrpage), 1580 1581 TP_ARGS(inode, start, nrpage), 1582 1583 TP_STRUCT__entry( 1584 __field(u64, ino) 1585 __field(pgoff_t, start) 1586 __field(dev_t, dev) 1587 __field(unsigned int, nrpage) 1588 ), 1589 1590 TP_fast_assign( 1591 __entry->dev = inode->i_sb->s_dev; 1592 __entry->ino = inode->i_ino; 1593 __entry->start = start; 1594 __entry->nrpage = nrpage; 1595 ), 1596 1597 TP_printk("dev = (%d,%d), ino = %llu, start = %lu nrpage = %u", 1598 show_dev_ino(__entry), 1599 (unsigned long)__entry->start, 1600 __entry->nrpage) 1601 ); 1602 1603 TRACE_EVENT(f2fs_write_checkpoint, 1604 1605 TP_PROTO(struct super_block *sb, int reason, u16 phase), 1606 1607 TP_ARGS(sb, reason, phase), 1608 1609 TP_STRUCT__entry( 1610 __field(dev_t, dev) 1611 __field(int, reason) 1612 __field(u16, phase) 1613 ), 1614 1615 TP_fast_assign( 1616 __entry->dev = sb->s_dev; 1617 __entry->reason = reason; 1618 __entry->phase = phase; 1619 ), 1620 1621 TP_printk("dev = (%d,%d), checkpoint for %s, state = %s", 1622 show_dev(__entry->dev), 1623 show_cpreason(__entry->reason), 1624 show_cp_phase(__entry->phase)) 1625 ); 1626 1627 DECLARE_EVENT_CLASS(f2fs_discard, 1628 1629 TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen), 1630 1631 TP_ARGS(dev, blkstart, blklen), 1632 1633 TP_STRUCT__entry( 1634 __field(dev_t, dev) 1635 __field(block_t, blkstart) 1636 __field(block_t, blklen) 1637 ), 1638 1639 TP_fast_assign( 1640 __entry->dev = dev->bd_dev; 1641 __entry->blkstart = blkstart; 1642 __entry->blklen = blklen; 1643 ), 1644 1645 TP_printk("dev = (%d,%d), blkstart = 0x%llx, blklen = 0x%llx", 1646 show_dev(__entry->dev), 1647 (unsigned long long)__entry->blkstart, 1648 (unsigned long long)__entry->blklen) 1649 ); 1650 1651 DEFINE_EVENT(f2fs_discard, f2fs_queue_discard, 1652 1653 TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen), 1654 1655 TP_ARGS(dev, blkstart, blklen) 1656 ); 1657 1658 DEFINE_EVENT(f2fs_discard, f2fs_issue_discard, 1659 1660 TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen), 1661 1662 TP_ARGS(dev, blkstart, blklen) 1663 ); 1664 1665 DEFINE_EVENT(f2fs_discard, f2fs_remove_discard, 1666 1667 TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen), 1668 1669 TP_ARGS(dev, blkstart, blklen) 1670 ); 1671 1672 DECLARE_EVENT_CLASS(f2fs_reset_zone, 1673 1674 TP_PROTO(struct block_device *dev, block_t blkstart), 1675 1676 TP_ARGS(dev, blkstart), 1677 1678 TP_STRUCT__entry( 1679 __field(dev_t, dev) 1680 __field(block_t, blkstart) 1681 ), 1682 1683 TP_fast_assign( 1684 __entry->dev = dev->bd_dev; 1685 __entry->blkstart = blkstart; 1686 ), 1687 1688 TP_printk("dev = (%d,%d), zone at block = 0x%llx", 1689 show_dev(__entry->dev), 1690 (unsigned long long)__entry->blkstart) 1691 ); 1692 1693 DEFINE_EVENT(f2fs_reset_zone, f2fs_queue_reset_zone, 1694 1695 TP_PROTO(struct block_device *dev, block_t blkstart), 1696 1697 TP_ARGS(dev, blkstart) 1698 ); 1699 1700 DEFINE_EVENT(f2fs_reset_zone, f2fs_issue_reset_zone, 1701 1702 TP_PROTO(struct block_device *dev, block_t blkstart), 1703 1704 TP_ARGS(dev, blkstart) 1705 ); 1706 1707 TRACE_EVENT(f2fs_issue_flush, 1708 1709 TP_PROTO(struct block_device *dev, unsigned int nobarrier, 1710 unsigned int flush_merge, int ret), 1711 1712 TP_ARGS(dev, nobarrier, flush_merge, ret), 1713 1714 TP_STRUCT__entry( 1715 __field(dev_t, dev) 1716 __field(unsigned int, nobarrier) 1717 __field(unsigned int, flush_merge) 1718 __field(int, ret) 1719 ), 1720 1721 TP_fast_assign( 1722 __entry->dev = dev->bd_dev; 1723 __entry->nobarrier = nobarrier; 1724 __entry->flush_merge = flush_merge; 1725 __entry->ret = ret; 1726 ), 1727 1728 TP_printk("dev = (%d,%d), %s %s, ret = %d", 1729 show_dev(__entry->dev), 1730 __entry->nobarrier ? "skip (nobarrier)" : "issue", 1731 __entry->flush_merge ? " with flush_merge" : "", 1732 __entry->ret) 1733 ); 1734 1735 TRACE_EVENT(f2fs_lookup_extent_tree_start, 1736 1737 TP_PROTO(struct inode *inode, unsigned int pgofs, enum extent_type type), 1738 1739 TP_ARGS(inode, pgofs, type), 1740 1741 TP_STRUCT__entry( 1742 __field(u64, ino) 1743 __field(dev_t, dev) 1744 __field(unsigned int, pgofs) 1745 __field(enum extent_type, type) 1746 ), 1747 1748 TP_fast_assign( 1749 __entry->dev = inode->i_sb->s_dev; 1750 __entry->ino = inode->i_ino; 1751 __entry->pgofs = pgofs; 1752 __entry->type = type; 1753 ), 1754 1755 TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, type = %s", 1756 show_dev_ino(__entry), 1757 __entry->pgofs, 1758 show_extent_type(__entry->type)) 1759 ); 1760 1761 TRACE_EVENT_CONDITION(f2fs_lookup_read_extent_tree_end, 1762 1763 TP_PROTO(struct inode *inode, unsigned int pgofs, 1764 struct extent_info *ei), 1765 1766 TP_ARGS(inode, pgofs, ei), 1767 1768 TP_CONDITION(ei), 1769 1770 TP_STRUCT__entry( 1771 __field(u64, ino) 1772 __field(dev_t, dev) 1773 __field(unsigned int, pgofs) 1774 __field(unsigned int, fofs) 1775 __field(unsigned int, len) 1776 __field(u32, blk) 1777 ), 1778 1779 TP_fast_assign( 1780 __entry->dev = inode->i_sb->s_dev; 1781 __entry->ino = inode->i_ino; 1782 __entry->pgofs = pgofs; 1783 __entry->fofs = ei->fofs; 1784 __entry->len = ei->len; 1785 __entry->blk = ei->blk; 1786 ), 1787 1788 TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, " 1789 "read_ext_info(fofs: %u, len: %u, blk: %u)", 1790 show_dev_ino(__entry), 1791 __entry->pgofs, 1792 __entry->fofs, 1793 __entry->len, 1794 __entry->blk) 1795 ); 1796 1797 TRACE_EVENT_CONDITION(f2fs_lookup_age_extent_tree_end, 1798 1799 TP_PROTO(struct inode *inode, unsigned int pgofs, 1800 struct extent_info *ei), 1801 1802 TP_ARGS(inode, pgofs, ei), 1803 1804 TP_CONDITION(ei), 1805 1806 TP_STRUCT__entry( 1807 __field(u64, ino) 1808 __field(unsigned long long, age) 1809 __field(unsigned long long, blocks) 1810 __field(dev_t, dev) 1811 __field(unsigned int, pgofs) 1812 __field(unsigned int, fofs) 1813 __field(unsigned int, len) 1814 ), 1815 1816 TP_fast_assign( 1817 __entry->dev = inode->i_sb->s_dev; 1818 __entry->ino = inode->i_ino; 1819 __entry->pgofs = pgofs; 1820 __entry->fofs = ei->fofs; 1821 __entry->len = ei->len; 1822 __entry->age = ei->age; 1823 __entry->blocks = ei->last_blocks; 1824 ), 1825 1826 TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, " 1827 "age_ext_info(fofs: %u, len: %u, age: %llu, blocks: %llu)", 1828 show_dev_ino(__entry), 1829 __entry->pgofs, 1830 __entry->fofs, 1831 __entry->len, 1832 __entry->age, 1833 __entry->blocks) 1834 ); 1835 1836 TRACE_EVENT(f2fs_update_read_extent_tree_range, 1837 1838 TP_PROTO(struct inode *inode, unsigned int pgofs, unsigned int len, 1839 block_t blkaddr, 1840 unsigned int c_len), 1841 1842 TP_ARGS(inode, pgofs, len, blkaddr, c_len), 1843 1844 TP_STRUCT__entry( 1845 __field(u64, ino) 1846 __field(dev_t, dev) 1847 __field(unsigned int, pgofs) 1848 __field(u32, blk) 1849 __field(unsigned int, len) 1850 __field(unsigned int, c_len) 1851 ), 1852 1853 TP_fast_assign( 1854 __entry->dev = inode->i_sb->s_dev; 1855 __entry->ino = inode->i_ino; 1856 __entry->pgofs = pgofs; 1857 __entry->len = len; 1858 __entry->blk = blkaddr; 1859 __entry->c_len = c_len; 1860 ), 1861 1862 TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, " 1863 "len = %u, blkaddr = %u, c_len = %u", 1864 show_dev_ino(__entry), 1865 __entry->pgofs, 1866 __entry->len, 1867 __entry->blk, 1868 __entry->c_len) 1869 ); 1870 1871 TRACE_EVENT(f2fs_update_age_extent_tree_range, 1872 1873 TP_PROTO(struct inode *inode, unsigned int pgofs, unsigned int len, 1874 unsigned long long age, 1875 unsigned long long last_blks), 1876 1877 TP_ARGS(inode, pgofs, len, age, last_blks), 1878 1879 TP_STRUCT__entry( 1880 __field(u64, ino) 1881 __field(unsigned long long, age) 1882 __field(unsigned long long, blocks) 1883 __field(dev_t, dev) 1884 __field(unsigned int, pgofs) 1885 __field(unsigned int, len) 1886 ), 1887 1888 TP_fast_assign( 1889 __entry->dev = inode->i_sb->s_dev; 1890 __entry->ino = inode->i_ino; 1891 __entry->pgofs = pgofs; 1892 __entry->len = len; 1893 __entry->age = age; 1894 __entry->blocks = last_blks; 1895 ), 1896 1897 TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, " 1898 "len = %u, age = %llu, blocks = %llu", 1899 show_dev_ino(__entry), 1900 __entry->pgofs, 1901 __entry->len, 1902 __entry->age, 1903 __entry->blocks) 1904 ); 1905 1906 TRACE_EVENT(f2fs_shrink_extent_tree, 1907 1908 TP_PROTO(struct f2fs_sb_info *sbi, unsigned int node_cnt, 1909 unsigned int tree_cnt, enum extent_type type), 1910 1911 TP_ARGS(sbi, node_cnt, tree_cnt, type), 1912 1913 TP_STRUCT__entry( 1914 __field(dev_t, dev) 1915 __field(unsigned int, node_cnt) 1916 __field(unsigned int, tree_cnt) 1917 __field(enum extent_type, type) 1918 ), 1919 1920 TP_fast_assign( 1921 __entry->dev = sbi->sb->s_dev; 1922 __entry->node_cnt = node_cnt; 1923 __entry->tree_cnt = tree_cnt; 1924 __entry->type = type; 1925 ), 1926 1927 TP_printk("dev = (%d,%d), shrunk: node_cnt = %u, tree_cnt = %u, type = %s", 1928 show_dev(__entry->dev), 1929 __entry->node_cnt, 1930 __entry->tree_cnt, 1931 show_extent_type(__entry->type)) 1932 ); 1933 1934 TRACE_EVENT(f2fs_destroy_extent_tree, 1935 1936 TP_PROTO(struct inode *inode, unsigned int node_cnt, 1937 enum extent_type type), 1938 1939 TP_ARGS(inode, node_cnt, type), 1940 1941 TP_STRUCT__entry( 1942 __field(u64, ino) 1943 __field(dev_t, dev) 1944 __field(unsigned int, node_cnt) 1945 __field(enum extent_type, type) 1946 ), 1947 1948 TP_fast_assign( 1949 __entry->dev = inode->i_sb->s_dev; 1950 __entry->ino = inode->i_ino; 1951 __entry->node_cnt = node_cnt; 1952 __entry->type = type; 1953 ), 1954 1955 TP_printk("dev = (%d,%d), ino = %llu, destroyed: node_cnt = %u, type = %s", 1956 show_dev_ino(__entry), 1957 __entry->node_cnt, 1958 show_extent_type(__entry->type)) 1959 ); 1960 1961 DECLARE_EVENT_CLASS(f2fs_sync_dirty_inodes, 1962 1963 TP_PROTO(struct super_block *sb, int type, s64 count), 1964 1965 TP_ARGS(sb, type, count), 1966 1967 TP_STRUCT__entry( 1968 __field(dev_t, dev) 1969 __field(int, type) 1970 __field(s64, count) 1971 ), 1972 1973 TP_fast_assign( 1974 __entry->dev = sb->s_dev; 1975 __entry->type = type; 1976 __entry->count = count; 1977 ), 1978 1979 TP_printk("dev = (%d,%d), %s, dirty count = %lld", 1980 show_dev(__entry->dev), 1981 show_file_type(__entry->type), 1982 __entry->count) 1983 ); 1984 1985 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_enter, 1986 1987 TP_PROTO(struct super_block *sb, int type, s64 count), 1988 1989 TP_ARGS(sb, type, count) 1990 ); 1991 1992 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_exit, 1993 1994 TP_PROTO(struct super_block *sb, int type, s64 count), 1995 1996 TP_ARGS(sb, type, count) 1997 ); 1998 1999 TRACE_EVENT(f2fs_shutdown, 2000 2001 TP_PROTO(struct f2fs_sb_info *sbi, unsigned int mode, int ret), 2002 2003 TP_ARGS(sbi, mode, ret), 2004 2005 TP_STRUCT__entry( 2006 __field(dev_t, dev) 2007 __field(unsigned int, mode) 2008 __field(int, ret) 2009 ), 2010 2011 TP_fast_assign( 2012 __entry->dev = sbi->sb->s_dev; 2013 __entry->mode = mode; 2014 __entry->ret = ret; 2015 ), 2016 2017 TP_printk("dev = (%d,%d), mode: %s, ret:%d", 2018 show_dev(__entry->dev), 2019 show_shutdown_mode(__entry->mode), 2020 __entry->ret) 2021 ); 2022 2023 DECLARE_EVENT_CLASS(f2fs_zip_start, 2024 2025 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2026 unsigned int cluster_size, unsigned char algtype), 2027 2028 TP_ARGS(inode, cluster_idx, cluster_size, algtype), 2029 2030 TP_STRUCT__entry( 2031 __field(u64, ino) 2032 __field(pgoff_t, idx) 2033 __field(dev_t, dev) 2034 __field(unsigned int, size) 2035 __field(unsigned int, algtype) 2036 ), 2037 2038 TP_fast_assign( 2039 __entry->dev = inode->i_sb->s_dev; 2040 __entry->ino = inode->i_ino; 2041 __entry->idx = cluster_idx; 2042 __entry->size = cluster_size; 2043 __entry->algtype = algtype; 2044 ), 2045 2046 TP_printk("dev = (%d,%d), ino = %llu, cluster_idx:%lu, " 2047 "cluster_size = %u, algorithm = %s", 2048 show_dev_ino(__entry), 2049 __entry->idx, 2050 __entry->size, 2051 show_compress_algorithm(__entry->algtype)) 2052 ); 2053 2054 DECLARE_EVENT_CLASS(f2fs_zip_end, 2055 2056 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2057 unsigned int compressed_size, int ret), 2058 2059 TP_ARGS(inode, cluster_idx, compressed_size, ret), 2060 2061 TP_STRUCT__entry( 2062 __field(u64, ino) 2063 __field(pgoff_t, idx) 2064 __field(dev_t, dev) 2065 __field(unsigned int, size) 2066 __field(unsigned int, ret) 2067 ), 2068 2069 TP_fast_assign( 2070 __entry->dev = inode->i_sb->s_dev; 2071 __entry->ino = inode->i_ino; 2072 __entry->idx = cluster_idx; 2073 __entry->size = compressed_size; 2074 __entry->ret = ret; 2075 ), 2076 2077 TP_printk("dev = (%d,%d), ino = %llu, cluster_idx:%lu, " 2078 "compressed_size = %u, ret = %d", 2079 show_dev_ino(__entry), 2080 __entry->idx, 2081 __entry->size, 2082 __entry->ret) 2083 ); 2084 2085 DEFINE_EVENT(f2fs_zip_start, f2fs_compress_pages_start, 2086 2087 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2088 unsigned int cluster_size, unsigned char algtype), 2089 2090 TP_ARGS(inode, cluster_idx, cluster_size, algtype) 2091 ); 2092 2093 DEFINE_EVENT(f2fs_zip_start, f2fs_decompress_pages_start, 2094 2095 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2096 unsigned int cluster_size, unsigned char algtype), 2097 2098 TP_ARGS(inode, cluster_idx, cluster_size, algtype) 2099 ); 2100 2101 DEFINE_EVENT(f2fs_zip_end, f2fs_compress_pages_end, 2102 2103 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2104 unsigned int compressed_size, int ret), 2105 2106 TP_ARGS(inode, cluster_idx, compressed_size, ret) 2107 ); 2108 2109 DEFINE_EVENT(f2fs_zip_end, f2fs_decompress_pages_end, 2110 2111 TP_PROTO(struct inode *inode, pgoff_t cluster_idx, 2112 unsigned int compressed_size, int ret), 2113 2114 TP_ARGS(inode, cluster_idx, compressed_size, ret) 2115 ); 2116 2117 #ifdef CONFIG_F2FS_IOSTAT 2118 /* 2119 * Number of read folio order buckets emitted by the f2fs_iostat tracepoint. 2120 * TP_printk() cannot loop, so the field count is fixed here and must be >= 2121 * the largest possible NR_PAGE_ORDERS (14 on arm64 with 64K pages). The 2122 * BUILD_BUG_ON() in f2fs_update_read_folio_count() enforces this. 2123 */ 2124 #define F2FS_IOSTAT_RD_FOLIO_ORDERS 16 2125 2126 TRACE_EVENT(f2fs_iostat, 2127 2128 TP_PROTO(struct f2fs_sb_info *sbi, unsigned long long *iostat, 2129 unsigned long long *read_folio_count), 2130 2131 TP_ARGS(sbi, iostat, read_folio_count), 2132 2133 TP_STRUCT__entry( 2134 __field(dev_t, dev) 2135 __field(unsigned long long, app_dio) 2136 __field(unsigned long long, app_bio) 2137 __field(unsigned long long, app_wio) 2138 __field(unsigned long long, app_mio) 2139 __field(unsigned long long, app_bcdio) 2140 __field(unsigned long long, app_mcdio) 2141 __field(unsigned long long, fs_dio) 2142 __field(unsigned long long, fs_cdio) 2143 __field(unsigned long long, fs_nio) 2144 __field(unsigned long long, fs_mio) 2145 __field(unsigned long long, fs_gc_dio) 2146 __field(unsigned long long, fs_gc_nio) 2147 __field(unsigned long long, fs_cp_dio) 2148 __field(unsigned long long, fs_cp_nio) 2149 __field(unsigned long long, fs_cp_mio) 2150 __field(unsigned long long, app_drio) 2151 __field(unsigned long long, app_brio) 2152 __field(unsigned long long, app_rio) 2153 __field(unsigned long long, app_mrio) 2154 __field(unsigned long long, app_bcrio) 2155 __field(unsigned long long, app_mcrio) 2156 __field(unsigned long long, fs_drio) 2157 __field(unsigned long long, fs_gdrio) 2158 __field(unsigned long long, fs_cdrio) 2159 __field(unsigned long long, fs_nrio) 2160 __field(unsigned long long, fs_mrio) 2161 __field(unsigned long long, fs_discard) 2162 __field(unsigned long long, fs_reset_zone) 2163 __array(unsigned long long, read_folio_count, F2FS_IOSTAT_RD_FOLIO_ORDERS) 2164 ), 2165 2166 TP_fast_assign( 2167 __entry->dev = sbi->sb->s_dev; 2168 __entry->app_dio = iostat[APP_DIRECT_IO]; 2169 __entry->app_bio = iostat[APP_BUFFERED_IO]; 2170 __entry->app_wio = iostat[APP_WRITE_IO]; 2171 __entry->app_mio = iostat[APP_MAPPED_IO]; 2172 __entry->app_bcdio = iostat[APP_BUFFERED_CDATA_IO]; 2173 __entry->app_mcdio = iostat[APP_MAPPED_CDATA_IO]; 2174 __entry->fs_dio = iostat[FS_DATA_IO]; 2175 __entry->fs_cdio = iostat[FS_CDATA_IO]; 2176 __entry->fs_nio = iostat[FS_NODE_IO]; 2177 __entry->fs_mio = iostat[FS_META_IO]; 2178 __entry->fs_gc_dio = iostat[FS_GC_DATA_IO]; 2179 __entry->fs_gc_nio = iostat[FS_GC_NODE_IO]; 2180 __entry->fs_cp_dio = iostat[FS_CP_DATA_IO]; 2181 __entry->fs_cp_nio = iostat[FS_CP_NODE_IO]; 2182 __entry->fs_cp_mio = iostat[FS_CP_META_IO]; 2183 __entry->app_drio = iostat[APP_DIRECT_READ_IO]; 2184 __entry->app_brio = iostat[APP_BUFFERED_READ_IO]; 2185 __entry->app_rio = iostat[APP_READ_IO]; 2186 __entry->app_mrio = iostat[APP_MAPPED_READ_IO]; 2187 __entry->app_bcrio = iostat[APP_BUFFERED_CDATA_READ_IO]; 2188 __entry->app_mcrio = iostat[APP_MAPPED_CDATA_READ_IO]; 2189 __entry->fs_drio = iostat[FS_DATA_READ_IO]; 2190 __entry->fs_gdrio = iostat[FS_GDATA_READ_IO]; 2191 __entry->fs_cdrio = iostat[FS_CDATA_READ_IO]; 2192 __entry->fs_nrio = iostat[FS_NODE_READ_IO]; 2193 __entry->fs_mrio = iostat[FS_META_READ_IO]; 2194 __entry->fs_discard = iostat[FS_DISCARD_IO]; 2195 __entry->fs_reset_zone = iostat[FS_ZONE_RESET_IO]; 2196 memset(__entry->read_folio_count, 0, sizeof(__entry->read_folio_count)); 2197 memcpy(__entry->read_folio_count, read_folio_count, 2198 sizeof(unsigned long long) * 2199 min_t(int, NR_PAGE_ORDERS, F2FS_IOSTAT_RD_FOLIO_ORDERS)); 2200 ), 2201 2202 TP_printk("dev = (%d,%d), " 2203 "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu, " 2204 "compr(buffered=%llu, mapped=%llu)], " 2205 "fs [data=%llu, cdata=%llu, node=%llu, meta=%llu, discard=%llu, " 2206 "reset_zone=%llu], " 2207 "gc [data=%llu, node=%llu], " 2208 "cp [data=%llu, node=%llu, meta=%llu], " 2209 "app [read=%llu (direct=%llu, buffered=%llu), mapped=%llu], " 2210 "compr(buffered=%llu, mapped=%llu)], " 2211 "fs [data=%llu, (gc_data=%llu, cdata=%llu), " 2212 "node=%llu, meta=%llu], " 2213 "read_folio_count [0=%llu, 1=%llu, 2=%llu, 3=%llu, 4=%llu, " 2214 "5=%llu, 6=%llu, 7=%llu, 8=%llu, 9=%llu, 10=%llu, 11=%llu, " 2215 "12=%llu, 13=%llu, 14=%llu, 15=%llu]", 2216 show_dev(__entry->dev), __entry->app_wio, __entry->app_dio, 2217 __entry->app_bio, __entry->app_mio, __entry->app_bcdio, 2218 __entry->app_mcdio, __entry->fs_dio, __entry->fs_cdio, 2219 __entry->fs_nio, __entry->fs_mio, __entry->fs_discard, 2220 __entry->fs_reset_zone, 2221 __entry->fs_gc_dio, __entry->fs_gc_nio, __entry->fs_cp_dio, 2222 __entry->fs_cp_nio, __entry->fs_cp_mio, 2223 __entry->app_rio, __entry->app_drio, __entry->app_brio, 2224 __entry->app_mrio, __entry->app_bcrio, __entry->app_mcrio, 2225 __entry->fs_drio, __entry->fs_gdrio, 2226 __entry->fs_cdrio, __entry->fs_nrio, __entry->fs_mrio, 2227 __entry->read_folio_count[0], __entry->read_folio_count[1], 2228 __entry->read_folio_count[2], __entry->read_folio_count[3], 2229 __entry->read_folio_count[4], __entry->read_folio_count[5], 2230 __entry->read_folio_count[6], __entry->read_folio_count[7], 2231 __entry->read_folio_count[8], __entry->read_folio_count[9], 2232 __entry->read_folio_count[10], __entry->read_folio_count[11], 2233 __entry->read_folio_count[12], __entry->read_folio_count[13], 2234 __entry->read_folio_count[14], __entry->read_folio_count[15]) 2235 ); 2236 2237 #ifndef __F2FS_IOSTAT_LATENCY_TYPE 2238 #define __F2FS_IOSTAT_LATENCY_TYPE 2239 struct f2fs_iostat_latency { 2240 unsigned int peak_lat; 2241 unsigned int avg_lat; 2242 unsigned int cnt; 2243 }; 2244 #endif /* __F2FS_IOSTAT_LATENCY_TYPE */ 2245 2246 TRACE_EVENT(f2fs_iostat_latency, 2247 2248 TP_PROTO(struct f2fs_sb_info *sbi, struct f2fs_iostat_latency (*iostat_lat)[NR_PAGE_TYPE]), 2249 2250 TP_ARGS(sbi, iostat_lat), 2251 2252 TP_STRUCT__entry( 2253 __field(dev_t, dev) 2254 __field(unsigned int, d_rd_peak) 2255 __field(unsigned int, d_rd_avg) 2256 __field(unsigned int, d_rd_cnt) 2257 __field(unsigned int, n_rd_peak) 2258 __field(unsigned int, n_rd_avg) 2259 __field(unsigned int, n_rd_cnt) 2260 __field(unsigned int, m_rd_peak) 2261 __field(unsigned int, m_rd_avg) 2262 __field(unsigned int, m_rd_cnt) 2263 __field(unsigned int, d_wr_s_peak) 2264 __field(unsigned int, d_wr_s_avg) 2265 __field(unsigned int, d_wr_s_cnt) 2266 __field(unsigned int, n_wr_s_peak) 2267 __field(unsigned int, n_wr_s_avg) 2268 __field(unsigned int, n_wr_s_cnt) 2269 __field(unsigned int, m_wr_s_peak) 2270 __field(unsigned int, m_wr_s_avg) 2271 __field(unsigned int, m_wr_s_cnt) 2272 __field(unsigned int, d_wr_as_peak) 2273 __field(unsigned int, d_wr_as_avg) 2274 __field(unsigned int, d_wr_as_cnt) 2275 __field(unsigned int, n_wr_as_peak) 2276 __field(unsigned int, n_wr_as_avg) 2277 __field(unsigned int, n_wr_as_cnt) 2278 __field(unsigned int, m_wr_as_peak) 2279 __field(unsigned int, m_wr_as_avg) 2280 __field(unsigned int, m_wr_as_cnt) 2281 ), 2282 2283 TP_fast_assign( 2284 __entry->dev = sbi->sb->s_dev; 2285 __entry->d_rd_peak = iostat_lat[READ_IO][DATA].peak_lat; 2286 __entry->d_rd_avg = iostat_lat[READ_IO][DATA].avg_lat; 2287 __entry->d_rd_cnt = iostat_lat[READ_IO][DATA].cnt; 2288 __entry->n_rd_peak = iostat_lat[READ_IO][NODE].peak_lat; 2289 __entry->n_rd_avg = iostat_lat[READ_IO][NODE].avg_lat; 2290 __entry->n_rd_cnt = iostat_lat[READ_IO][NODE].cnt; 2291 __entry->m_rd_peak = iostat_lat[READ_IO][META].peak_lat; 2292 __entry->m_rd_avg = iostat_lat[READ_IO][META].avg_lat; 2293 __entry->m_rd_cnt = iostat_lat[READ_IO][META].cnt; 2294 __entry->d_wr_s_peak = iostat_lat[WRITE_SYNC_IO][DATA].peak_lat; 2295 __entry->d_wr_s_avg = iostat_lat[WRITE_SYNC_IO][DATA].avg_lat; 2296 __entry->d_wr_s_cnt = iostat_lat[WRITE_SYNC_IO][DATA].cnt; 2297 __entry->n_wr_s_peak = iostat_lat[WRITE_SYNC_IO][NODE].peak_lat; 2298 __entry->n_wr_s_avg = iostat_lat[WRITE_SYNC_IO][NODE].avg_lat; 2299 __entry->n_wr_s_cnt = iostat_lat[WRITE_SYNC_IO][NODE].cnt; 2300 __entry->m_wr_s_peak = iostat_lat[WRITE_SYNC_IO][META].peak_lat; 2301 __entry->m_wr_s_avg = iostat_lat[WRITE_SYNC_IO][META].avg_lat; 2302 __entry->m_wr_s_cnt = iostat_lat[WRITE_SYNC_IO][META].cnt; 2303 __entry->d_wr_as_peak = iostat_lat[WRITE_ASYNC_IO][DATA].peak_lat; 2304 __entry->d_wr_as_avg = iostat_lat[WRITE_ASYNC_IO][DATA].avg_lat; 2305 __entry->d_wr_as_cnt = iostat_lat[WRITE_ASYNC_IO][DATA].cnt; 2306 __entry->n_wr_as_peak = iostat_lat[WRITE_ASYNC_IO][NODE].peak_lat; 2307 __entry->n_wr_as_avg = iostat_lat[WRITE_ASYNC_IO][NODE].avg_lat; 2308 __entry->n_wr_as_cnt = iostat_lat[WRITE_ASYNC_IO][NODE].cnt; 2309 __entry->m_wr_as_peak = iostat_lat[WRITE_ASYNC_IO][META].peak_lat; 2310 __entry->m_wr_as_avg = iostat_lat[WRITE_ASYNC_IO][META].avg_lat; 2311 __entry->m_wr_as_cnt = iostat_lat[WRITE_ASYNC_IO][META].cnt; 2312 ), 2313 2314 TP_printk("dev = (%d,%d), " 2315 "iotype [peak lat.(ms)/avg lat.(ms)/count], " 2316 "rd_data [%u/%u/%u], rd_node [%u/%u/%u], rd_meta [%u/%u/%u], " 2317 "wr_sync_data [%u/%u/%u], wr_sync_node [%u/%u/%u], " 2318 "wr_sync_meta [%u/%u/%u], wr_async_data [%u/%u/%u], " 2319 "wr_async_node [%u/%u/%u], wr_async_meta [%u/%u/%u]", 2320 show_dev(__entry->dev), 2321 __entry->d_rd_peak, __entry->d_rd_avg, __entry->d_rd_cnt, 2322 __entry->n_rd_peak, __entry->n_rd_avg, __entry->n_rd_cnt, 2323 __entry->m_rd_peak, __entry->m_rd_avg, __entry->m_rd_cnt, 2324 __entry->d_wr_s_peak, __entry->d_wr_s_avg, __entry->d_wr_s_cnt, 2325 __entry->n_wr_s_peak, __entry->n_wr_s_avg, __entry->n_wr_s_cnt, 2326 __entry->m_wr_s_peak, __entry->m_wr_s_avg, __entry->m_wr_s_cnt, 2327 __entry->d_wr_as_peak, __entry->d_wr_as_avg, __entry->d_wr_as_cnt, 2328 __entry->n_wr_as_peak, __entry->n_wr_as_avg, __entry->n_wr_as_cnt, 2329 __entry->m_wr_as_peak, __entry->m_wr_as_avg, __entry->m_wr_as_cnt) 2330 ); 2331 #endif 2332 2333 TRACE_EVENT(f2fs_bmap, 2334 2335 TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock), 2336 2337 TP_ARGS(inode, lblock, pblock), 2338 2339 TP_STRUCT__entry( 2340 __field(u64, ino) 2341 __field(sector_t, lblock) 2342 __field(sector_t, pblock) 2343 __field(dev_t, dev) 2344 ), 2345 2346 TP_fast_assign( 2347 __entry->dev = inode->i_sb->s_dev; 2348 __entry->ino = inode->i_ino; 2349 __entry->lblock = lblock; 2350 __entry->pblock = pblock; 2351 ), 2352 2353 TP_printk("dev = (%d,%d), ino = %llu, lblock:%lld, pblock:%lld", 2354 show_dev_ino(__entry), 2355 (unsigned long long)__entry->lblock, 2356 (unsigned long long)__entry->pblock) 2357 ); 2358 2359 TRACE_EVENT(f2fs_fiemap, 2360 2361 TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock, 2362 unsigned long long len, unsigned int flags, int ret), 2363 2364 TP_ARGS(inode, lblock, pblock, len, flags, ret), 2365 2366 TP_STRUCT__entry( 2367 __field(u64, ino) 2368 __field(sector_t, lblock) 2369 __field(sector_t, pblock) 2370 __field(unsigned long long, len) 2371 __field(dev_t, dev) 2372 __field(unsigned int, flags) 2373 __field(int, ret) 2374 ), 2375 2376 TP_fast_assign( 2377 __entry->dev = inode->i_sb->s_dev; 2378 __entry->ino = inode->i_ino; 2379 __entry->lblock = lblock; 2380 __entry->pblock = pblock; 2381 __entry->len = len; 2382 __entry->flags = flags; 2383 __entry->ret = ret; 2384 ), 2385 2386 TP_printk("dev = (%d,%d), ino = %llu, lblock:%lld, pblock:%lld, " 2387 "len:%llu, flags:%u, ret:%d", 2388 show_dev_ino(__entry), 2389 (unsigned long long)__entry->lblock, 2390 (unsigned long long)__entry->pblock, 2391 __entry->len, 2392 __entry->flags, 2393 __entry->ret) 2394 ); 2395 2396 DECLARE_EVENT_CLASS(f2fs__rw_start, 2397 2398 TP_PROTO(struct inode *inode, loff_t offset, int bytes, 2399 pid_t pid, char *pathname, char *command), 2400 2401 TP_ARGS(inode, offset, bytes, pid, pathname, command), 2402 2403 TP_STRUCT__entry( 2404 __field(u64, ino) 2405 __field(loff_t, offset) 2406 __field(loff_t, i_size) 2407 __string(pathbuf, pathname) 2408 __string(cmdline, command) 2409 __field(pid_t, pid) 2410 __field(int, bytes) 2411 ), 2412 2413 TP_fast_assign( 2414 /* 2415 * Replace the spaces in filenames and cmdlines 2416 * because this screws up the tooling that parses 2417 * the traces. 2418 */ 2419 __assign_str(pathbuf); 2420 (void)strreplace(__get_str(pathbuf), ' ', '_'); 2421 __entry->offset = offset; 2422 __entry->bytes = bytes; 2423 __entry->i_size = i_size_read(inode); 2424 __assign_str(cmdline); 2425 (void)strreplace(__get_str(cmdline), ' ', '_'); 2426 __entry->pid = pid; 2427 __entry->ino = inode->i_ino; 2428 ), 2429 2430 TP_printk("entry_name %s, offset %llu, bytes %d, cmdline %s," 2431 " pid %d, i_size %llu, ino %llu", 2432 __get_str(pathbuf), __entry->offset, __entry->bytes, 2433 __get_str(cmdline), __entry->pid, __entry->i_size, 2434 __entry->ino) 2435 ); 2436 2437 DECLARE_EVENT_CLASS(f2fs__rw_end, 2438 2439 TP_PROTO(struct inode *inode, loff_t offset, int bytes), 2440 2441 TP_ARGS(inode, offset, bytes), 2442 2443 TP_STRUCT__entry( 2444 __field(u64, ino) 2445 __field(loff_t, offset) 2446 __field(int, bytes) 2447 ), 2448 2449 TP_fast_assign( 2450 __entry->ino = inode->i_ino; 2451 __entry->offset = offset; 2452 __entry->bytes = bytes; 2453 ), 2454 2455 TP_printk("ino %llu, offset %llu, bytes %d", 2456 __entry->ino, 2457 __entry->offset, __entry->bytes) 2458 ); 2459 2460 DEFINE_EVENT(f2fs__rw_start, f2fs_dataread_start, 2461 2462 TP_PROTO(struct inode *inode, loff_t offset, int bytes, 2463 pid_t pid, char *pathname, char *command), 2464 2465 TP_ARGS(inode, offset, bytes, pid, pathname, command) 2466 ); 2467 2468 DEFINE_EVENT(f2fs__rw_end, f2fs_dataread_end, 2469 2470 TP_PROTO(struct inode *inode, loff_t offset, int bytes), 2471 2472 TP_ARGS(inode, offset, bytes) 2473 ); 2474 2475 DEFINE_EVENT(f2fs__rw_start, f2fs_datawrite_start, 2476 2477 TP_PROTO(struct inode *inode, loff_t offset, int bytes, 2478 pid_t pid, char *pathname, char *command), 2479 2480 TP_ARGS(inode, offset, bytes, pid, pathname, command) 2481 ); 2482 2483 DEFINE_EVENT(f2fs__rw_end, f2fs_datawrite_end, 2484 2485 TP_PROTO(struct inode *inode, loff_t offset, int bytes), 2486 2487 TP_ARGS(inode, offset, bytes) 2488 ); 2489 2490 TRACE_EVENT(f2fs_lock_elapsed_time, 2491 2492 TP_PROTO(struct f2fs_sb_info *sbi, enum f2fs_lock_name lock_name, 2493 bool is_write, struct task_struct *p, int ioprio, 2494 unsigned long long total_time, 2495 unsigned long long running_time, 2496 unsigned long long runnable_time, 2497 unsigned long long io_sleep_time, 2498 unsigned long long other_time), 2499 2500 TP_ARGS(sbi, lock_name, is_write, p, ioprio, total_time, running_time, 2501 runnable_time, io_sleep_time, other_time), 2502 2503 TP_STRUCT__entry( 2504 __field(dev_t, dev) 2505 __array(char, comm, TASK_COMM_LEN) 2506 __field(pid_t, pid) 2507 __field(int, prio) 2508 __field(int, ioprio_class) 2509 __field(int, ioprio_data) 2510 __field(unsigned int, lock_name) 2511 __field(bool, is_write) 2512 __field(unsigned long long, total_time) 2513 __field(unsigned long long, running_time) 2514 __field(unsigned long long, runnable_time) 2515 __field(unsigned long long, io_sleep_time) 2516 __field(unsigned long long, other_time) 2517 ), 2518 2519 TP_fast_assign( 2520 __entry->dev = sbi->sb->s_dev; 2521 memcpy(__entry->comm, p->comm, TASK_COMM_LEN); 2522 __entry->pid = p->pid; 2523 __entry->prio = p->prio; 2524 __entry->ioprio_class = IOPRIO_PRIO_CLASS(ioprio); 2525 __entry->ioprio_data = IOPRIO_PRIO_DATA(ioprio); 2526 __entry->lock_name = lock_name; 2527 __entry->is_write = is_write; 2528 __entry->total_time = total_time; 2529 __entry->running_time = running_time; 2530 __entry->runnable_time = runnable_time; 2531 __entry->io_sleep_time = io_sleep_time; 2532 __entry->other_time = other_time; 2533 ), 2534 2535 TP_printk("dev = (%d,%d), comm: %s, pid: %d, prio: %d, " 2536 "ioprio_class: %d, ioprio_data: %d, lock_name: %s, " 2537 "lock_type: %s, total: %llu, running: %llu, " 2538 "runnable: %llu, io_sleep: %llu, other: %llu", 2539 show_dev(__entry->dev), 2540 __entry->comm, 2541 __entry->pid, 2542 __entry->prio, 2543 __entry->ioprio_class, 2544 __entry->ioprio_data, 2545 show_lock_name(__entry->lock_name), 2546 __entry->is_write ? "wlock" : "rlock", 2547 __entry->total_time, 2548 __entry->running_time, 2549 __entry->runnable_time, 2550 __entry->io_sleep_time, 2551 __entry->other_time) 2552 ); 2553 2554 DECLARE_EVENT_CLASS(f2fs_priority_update, 2555 2556 TP_PROTO(struct f2fs_sb_info *sbi, enum f2fs_lock_name lock_name, 2557 bool is_write, struct task_struct *p, int orig_prio, 2558 int new_prio), 2559 2560 TP_ARGS(sbi, lock_name, is_write, p, orig_prio, new_prio), 2561 2562 TP_STRUCT__entry( 2563 __field(dev_t, dev) 2564 __array(char, comm, TASK_COMM_LEN) 2565 __field(pid_t, pid) 2566 __field(unsigned int, lock_name) 2567 __field(bool, is_write) 2568 __field(int, orig_prio) 2569 __field(int, new_prio) 2570 ), 2571 2572 TP_fast_assign( 2573 __entry->dev = sbi->sb->s_dev; 2574 memcpy(__entry->comm, p->comm, TASK_COMM_LEN); 2575 __entry->pid = p->pid; 2576 __entry->lock_name = lock_name; 2577 __entry->is_write = is_write; 2578 __entry->orig_prio = orig_prio; 2579 __entry->new_prio = new_prio; 2580 ), 2581 2582 TP_printk("dev = (%d,%d), comm: %s, pid: %d, lock_name: %s, " 2583 "lock_type: %s, orig_prio: %d, new_prio: %d", 2584 show_dev(__entry->dev), 2585 __entry->comm, 2586 __entry->pid, 2587 show_lock_name(__entry->lock_name), 2588 __entry->is_write ? "wlock" : "rlock", 2589 __entry->orig_prio, 2590 __entry->new_prio) 2591 ); 2592 2593 DEFINE_EVENT(f2fs_priority_update, f2fs_priority_uplift, 2594 2595 TP_PROTO(struct f2fs_sb_info *sbi, enum f2fs_lock_name lock_name, 2596 bool is_write, struct task_struct *p, int orig_prio, 2597 int new_prio), 2598 2599 TP_ARGS(sbi, lock_name, is_write, p, orig_prio, new_prio) 2600 ); 2601 2602 DEFINE_EVENT(f2fs_priority_update, f2fs_priority_restore, 2603 2604 TP_PROTO(struct f2fs_sb_info *sbi, enum f2fs_lock_name lock_name, 2605 bool is_write, struct task_struct *p, int orig_prio, 2606 int new_prio), 2607 2608 TP_ARGS(sbi, lock_name, is_write, p, orig_prio, new_prio) 2609 ); 2610 2611 TRACE_EVENT(f2fs_fault_report, 2612 2613 TP_PROTO(struct super_block *sb, unsigned int err_code, 2614 const char *func, unsigned int data), 2615 2616 TP_ARGS(sb, err_code, func, data), 2617 2618 TP_STRUCT__entry( 2619 __field(dev_t, dev) 2620 __field(unsigned int, err_code) 2621 __string(func, func) 2622 __field(unsigned int, data) 2623 ), 2624 2625 TP_fast_assign( 2626 __entry->dev = sb->s_dev; 2627 __entry->err_code = err_code; 2628 __assign_str(func); 2629 __entry->data = data; 2630 ), 2631 2632 TP_printk("dev = (%d,%d), err_code = %u, func = %s, data = %u", 2633 show_dev(__entry->dev), 2634 __entry->err_code, 2635 __get_str(func), 2636 __entry->data) 2637 ); 2638 2639 #endif /* _TRACE_F2FS_H */ 2640 2641 /* This part must be outside protection */ 2642 #include <trace/define_trace.h> 2643