include/trace/events/f2fs.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM f2fs
   3
   4 #if !defined(_TRACE_F2FS_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_F2FS_H
   6
   7 #include <linux/tracepoint.h>
   8
   9 #define show_dev(entry)         MAJOR(entry->dev), MINOR(entry->dev)
  10 #define show_dev_ino(entry)     show_dev(entry), (unsigned long)entry->ino
  11
  12 #define show_block_type(type)                                           \
  13         __print_symbolic(type,                                          \
  14                 { NODE,         "NODE" },                               \
  15                 { DATA,         "DATA" },                               \
  16                 { META,         "META" },                               \
  17                 { META_FLUSH,   "META_FLUSH" })
  18
  19 #define F2FS_BIO_MASK(t)        (t & (READA | WRITE_FLUSH_FUA))
  20 #define F2FS_BIO_EXTRA_MASK(t)  (t & (REQ_META | REQ_PRIO))
  21
  22 #define show_bio_type(type)     show_bio_base(type), show_bio_extra(type)
  23
  24 #define show_bio_base(type)                                             \
  25         __print_symbolic(F2FS_BIO_MASK(type),                           \
  26                 { READ,                 "READ" },                       \
  27                 { READA,                "READAHEAD" },                  \
  28                 { READ_SYNC,            "READ_SYNC" },                  \
  29                 { WRITE,                "WRITE" },                      \
  30                 { WRITE_SYNC,           "WRITE_SYNC" },                 \
  31                 { WRITE_FLUSH,          "WRITE_FLUSH" },                \
  32                 { WRITE_FUA,            "WRITE_FUA" },                  \
  33                 { WRITE_FLUSH_FUA,      "WRITE_FLUSH_FUA" })
  34
  35 #define show_bio_extra(type)                                            \
  36         __print_symbolic(F2FS_BIO_EXTRA_MASK(type),                     \
  37                 { REQ_META,             "(M)" },                        \
  38                 { REQ_PRIO,             "(P)" },                        \
  39                 { REQ_META | REQ_PRIO,  "(MP)" },                       \
  40                 { 0, " \b" })
  41
  42 #define show_data_type(type)                                            \
  43         __print_symbolic(type,                                          \
  44                 { CURSEG_HOT_DATA,      "Hot DATA" },                   \
  45                 { CURSEG_WARM_DATA,     "Warm DATA" },                  \
  46                 { CURSEG_COLD_DATA,     "Cold DATA" },                  \
  47                 { CURSEG_HOT_NODE,      "Hot NODE" },                   \
  48                 { CURSEG_WARM_NODE,     "Warm NODE" },                  \
  49                 { CURSEG_COLD_NODE,     "Cold NODE" },                  \
  50                 { NO_CHECK_TYPE,        "No TYPE" })
  51
  52 #define show_file_type(type)                                            \
  53         __print_symbolic(type,                                          \
  54                 { 0,            "FILE" },                               \
  55                 { 1,            "DIR" })
  56
  57 #define show_gc_type(type)                                              \
  58         __print_symbolic(type,                                          \
  59                 { FG_GC,        "Foreground GC" },                      \
  60                 { BG_GC,        "Background GC" })
  61
  62 #define show_alloc_mode(type)                                           \
  63         __print_symbolic(type,                                          \
  64                 { LFS,  "LFS-mode" },                                   \
  65                 { SSR,  "SSR-mode" })
  66
  67 #define show_victim_policy(type)                                        \
  68         __print_symbolic(type,                                          \
  69                 { GC_GREEDY,    "Greedy" },                             \
  70                 { GC_CB,        "Cost-Benefit" })
  71
  72 struct victim_sel_policy;
  73
  74 DECLARE_EVENT_CLASS(f2fs__inode,
  75
  76         TP_PROTO(struct inode *inode),
  77
  78         TP_ARGS(inode),
  79
  80         TP_STRUCT__entry(
  81                 __field(dev_t,  dev)
  82                 __field(ino_t,  ino)
  83                 __field(ino_t,  pino)
  84                 __field(umode_t, mode)
  85                 __field(loff_t, size)
  86                 __field(unsigned int, nlink)
  87                 __field(blkcnt_t, blocks)
  88                 __field(__u8,   advise)
  89         ),
  90
  91         TP_fast_assign(
  92                 __entry->dev    = inode->i_sb->s_dev;
  93                 __entry->ino    = inode->i_ino;
  94                 __entry->pino   = F2FS_I(inode)->i_pino;
  95                 __entry->mode   = inode->i_mode;
  96                 __entry->nlink  = inode->i_nlink;
  97                 __entry->size   = inode->i_size;
  98                 __entry->blocks = inode->i_blocks;
  99                 __entry->advise = F2FS_I(inode)->i_advise;
 100         ),
 101
 102         TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
 103                 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
 104                 show_dev_ino(__entry),
 105                 (unsigned long)__entry->pino,
 106                 __entry->mode,
 107                 __entry->size,
 108                 (unsigned int)__entry->nlink,
 109                 (unsigned long long)__entry->blocks,
 110                 (unsigned char)__entry->advise)
 111 );
 112
 113 DECLARE_EVENT_CLASS(f2fs__inode_exit,
 114
 115         TP_PROTO(struct inode *inode, int ret),
 116
 117         TP_ARGS(inode, ret),
 118
 119         TP_STRUCT__entry(
 120                 __field(dev_t,  dev)
 121                 __field(ino_t,  ino)
 122                 __field(int,    ret)
 123         ),
 124
 125         TP_fast_assign(
 126                 __entry->dev    = inode->i_sb->s_dev;
 127                 __entry->ino    = inode->i_ino;
 128                 __entry->ret    = ret;
 129         ),
 130
 131         TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
 132                 show_dev_ino(__entry),
 133                 __entry->ret)
 134 );
 135
 136 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
 137
 138         TP_PROTO(struct inode *inode),
 139
 140         TP_ARGS(inode)
 141 );
 142
 143 TRACE_EVENT(f2fs_sync_file_exit,
 144
 145         TP_PROTO(struct inode *inode, bool need_cp, int datasync, int ret),
 146
 147         TP_ARGS(inode, need_cp, datasync, ret),
 148
 149         TP_STRUCT__entry(
 150                 __field(dev_t,  dev)
 151                 __field(ino_t,  ino)
 152                 __field(bool,   need_cp)
 153                 __field(int,    datasync)
 154                 __field(int,    ret)
 155         ),
 156
 157         TP_fast_assign(
 158                 __entry->dev            = inode->i_sb->s_dev;
 159                 __entry->ino            = inode->i_ino;
 160                 __entry->need_cp        = need_cp;
 161                 __entry->datasync       = datasync;
 162                 __entry->ret            = ret;
 163         ),
 164
 165         TP_printk("dev = (%d,%d), ino = %lu, checkpoint is %s, "
 166                 "datasync = %d, ret = %d",
 167                 show_dev_ino(__entry),
 168                 __entry->need_cp ? "needed" : "not needed",
 169                 __entry->datasync,
 170                 __entry->ret)
 171 );
 172
 173 TRACE_EVENT(f2fs_sync_fs,
 174
 175         TP_PROTO(struct super_block *sb, int wait),
 176
 177         TP_ARGS(sb, wait),
 178
 179         TP_STRUCT__entry(
 180                 __field(dev_t,  dev)
 181                 __field(int,    dirty)
 182                 __field(int,    wait)
 183         ),
 184
 185         TP_fast_assign(
 186                 __entry->dev    = sb->s_dev;
 187                 __entry->dirty  = F2FS_SB(sb)->s_dirty;
 188                 __entry->wait   = wait;
 189         ),
 190
 191         TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
 192                 show_dev(__entry),
 193                 __entry->dirty ? "dirty" : "not dirty",
 194                 __entry->wait)
 195 );
 196
 197 DEFINE_EVENT(f2fs__inode, f2fs_iget,
 198
 199         TP_PROTO(struct inode *inode),
 200
 201         TP_ARGS(inode)
 202 );
 203
 204 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
 205
 206         TP_PROTO(struct inode *inode, int ret),
 207
 208         TP_ARGS(inode, ret)
 209 );
 210
 211 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
 212
 213         TP_PROTO(struct inode *inode),
 214
 215         TP_ARGS(inode)
 216 );
 217
 218 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode,
 219
 220         TP_PROTO(struct inode *inode, int ret),
 221
 222         TP_ARGS(inode, ret)
 223 );
 224
 225 TRACE_EVENT(f2fs_unlink_enter,
 226
 227         TP_PROTO(struct inode *dir, struct dentry *dentry),
 228
 229         TP_ARGS(dir, dentry),
 230
 231         TP_STRUCT__entry(
 232                 __field(dev_t,  dev)
 233                 __field(ino_t,  ino)
 234                 __field(loff_t, size)
 235                 __field(blkcnt_t, blocks)
 236                 __field(const char *,   name)
 237         ),
 238
 239         TP_fast_assign(
 240                 __entry->dev    = dir->i_sb->s_dev;
 241                 __entry->ino    = dir->i_ino;
 242                 __entry->size   = dir->i_size;
 243                 __entry->blocks = dir->i_blocks;
 244                 __entry->name   = dentry->d_name.name;
 245         ),
 246
 247         TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
 248                 "i_blocks = %llu, name = %s",
 249                 show_dev_ino(__entry),
 250                 __entry->size,
 251                 (unsigned long long)__entry->blocks,
 252                 __entry->name)
 253 );
 254
 255 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
 256
 257         TP_PROTO(struct inode *inode, int ret),
 258
 259         TP_ARGS(inode, ret)
 260 );
 261
 262 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
 263
 264         TP_PROTO(struct inode *inode),
 265
 266         TP_ARGS(inode)
 267 );
 268
 269 TRACE_EVENT(f2fs_truncate_data_blocks_range,
 270
 271         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
 272
 273         TP_ARGS(inode, nid,  ofs, free),
 274
 275         TP_STRUCT__entry(
 276                 __field(dev_t,  dev)
 277                 __field(ino_t,  ino)
 278                 __field(nid_t,  nid)
 279                 __field(unsigned int,   ofs)
 280                 __field(int,    free)
 281         ),
 282
 283         TP_fast_assign(
 284                 __entry->dev    = inode->i_sb->s_dev;
 285                 __entry->ino    = inode->i_ino;
 286                 __entry->nid    = nid;
 287                 __entry->ofs    = ofs;
 288                 __entry->free   = free;
 289         ),
 290
 291         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
 292                 show_dev_ino(__entry),
 293                 (unsigned int)__entry->nid,
 294                 __entry->ofs,
 295                 __entry->free)
 296 );
 297
 298 DECLARE_EVENT_CLASS(f2fs__truncate_op,
 299
 300         TP_PROTO(struct inode *inode, u64 from),
 301
 302         TP_ARGS(inode, from),
 303
 304         TP_STRUCT__entry(
 305                 __field(dev_t,  dev)
 306                 __field(ino_t,  ino)
 307                 __field(loff_t, size)
 308                 __field(blkcnt_t, blocks)
 309                 __field(u64,    from)
 310         ),
 311
 312         TP_fast_assign(
 313                 __entry->dev    = inode->i_sb->s_dev;
 314                 __entry->ino    = inode->i_ino;
 315                 __entry->size   = inode->i_size;
 316                 __entry->blocks = inode->i_blocks;
 317                 __entry->from   = from;
 318         ),
 319
 320         TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
 321                 "start file offset = %llu",
 322                 show_dev_ino(__entry),
 323                 __entry->size,
 324                 (unsigned long long)__entry->blocks,
 325                 (unsigned long long)__entry->from)
 326 );
 327
 328 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
 329
 330         TP_PROTO(struct inode *inode, u64 from),
 331
 332         TP_ARGS(inode, from)
 333 );
 334
 335 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
 336
 337         TP_PROTO(struct inode *inode, int ret),
 338
 339         TP_ARGS(inode, ret)
 340 );
 341
 342 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
 343
 344         TP_PROTO(struct inode *inode, u64 from),
 345
 346         TP_ARGS(inode, from)
 347 );
 348
 349 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
 350
 351         TP_PROTO(struct inode *inode, int ret),
 352
 353         TP_ARGS(inode, ret)
 354 );
 355
 356 DECLARE_EVENT_CLASS(f2fs__truncate_node,
 357
 358         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 359
 360         TP_ARGS(inode, nid, blk_addr),
 361
 362         TP_STRUCT__entry(
 363                 __field(dev_t,  dev)
 364                 __field(ino_t,  ino)
 365                 __field(nid_t,  nid)
 366                 __field(block_t,        blk_addr)
 367         ),
 368
 369         TP_fast_assign(
 370                 __entry->dev            = inode->i_sb->s_dev;
 371                 __entry->ino            = inode->i_ino;
 372                 __entry->nid            = nid;
 373                 __entry->blk_addr       = blk_addr;
 374         ),
 375
 376         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
 377                 show_dev_ino(__entry),
 378                 (unsigned int)__entry->nid,
 379                 (unsigned long long)__entry->blk_addr)
 380 );
 381
 382 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
 383
 384         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 385
 386         TP_ARGS(inode, nid, blk_addr)
 387 );
 388
 389 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
 390
 391         TP_PROTO(struct inode *inode, int ret),
 392
 393         TP_ARGS(inode, ret)
 394 );
 395
 396 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
 397
 398         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 399
 400         TP_ARGS(inode, nid, blk_addr)
 401 );
 402
 403 TRACE_EVENT(f2fs_truncate_partial_nodes,
 404
 405         TP_PROTO(struct inode *inode, nid_t nid[], int depth, int err),
 406
 407         TP_ARGS(inode, nid, depth, err),
 408
 409         TP_STRUCT__entry(
 410                 __field(dev_t,  dev)
 411                 __field(ino_t,  ino)
 412                 __field(nid_t,  nid[3])
 413                 __field(int,    depth)
 414                 __field(int,    err)
 415         ),
 416
 417         TP_fast_assign(
 418                 __entry->dev    = inode->i_sb->s_dev;
 419                 __entry->ino    = inode->i_ino;
 420                 __entry->nid[0] = nid[0];
 421                 __entry->nid[1] = nid[1];
 422                 __entry->nid[2] = nid[2];
 423                 __entry->depth  = depth;
 424                 __entry->err    = err;
 425         ),
 426
 427         TP_printk("dev = (%d,%d), ino = %lu, "
 428                 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
 429                 show_dev_ino(__entry),
 430                 (unsigned int)__entry->nid[0],
 431                 (unsigned int)__entry->nid[1],
 432                 (unsigned int)__entry->nid[2],
 433                 __entry->depth,
 434                 __entry->err)
 435 );
 436
 437 TRACE_EVENT_CONDITION(f2fs_submit_page_bio,
 438
 439         TP_PROTO(struct page *page, sector_t blkaddr, int type),
 440
 441         TP_ARGS(page, blkaddr, type),
 442
 443         TP_CONDITION(page->mapping),
 444
 445         TP_STRUCT__entry(
 446                 __field(dev_t,  dev)
 447                 __field(ino_t,  ino)
 448                 __field(pgoff_t,        index)
 449                 __field(sector_t,       blkaddr)
 450                 __field(int,    type)
 451         ),
 452
 453         TP_fast_assign(
 454                 __entry->dev            = page->mapping->host->i_sb->s_dev;
 455                 __entry->ino            = page->mapping->host->i_ino;
 456                 __entry->index          = page->index;
 457                 __entry->blkaddr        = blkaddr;
 458                 __entry->type           = type;
 459         ),
 460
 461         TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
 462                 "blkaddr = 0x%llx, bio_type = %s%s",
 463                 show_dev_ino(__entry),
 464                 (unsigned long)__entry->index,
 465                 (unsigned long long)__entry->blkaddr,
 466                 show_bio_type(__entry->type))
 467 );
 468
 469 TRACE_EVENT(f2fs_get_data_block,
 470         TP_PROTO(struct inode *inode, sector_t iblock,
 471                                 struct buffer_head *bh, int ret),
 472
 473         TP_ARGS(inode, iblock, bh, ret),
 474
 475         TP_STRUCT__entry(
 476                 __field(dev_t,  dev)
 477                 __field(ino_t,  ino)
 478                 __field(sector_t,       iblock)
 479                 __field(sector_t,       bh_start)
 480                 __field(size_t, bh_size)
 481                 __field(int,    ret)
 482         ),
 483
 484         TP_fast_assign(
 485                 __entry->dev            = inode->i_sb->s_dev;
 486                 __entry->ino            = inode->i_ino;
 487                 __entry->iblock         = iblock;
 488                 __entry->bh_start       = bh->b_blocknr;
 489                 __entry->bh_size        = bh->b_size;
 490                 __entry->ret            = ret;
 491         ),
 492
 493         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
 494                 "start blkaddr = 0x%llx, len = 0x%llx bytes, err = %d",
 495                 show_dev_ino(__entry),
 496                 (unsigned long long)__entry->iblock,
 497                 (unsigned long long)__entry->bh_start,
 498                 (unsigned long long)__entry->bh_size,
 499                 __entry->ret)
 500 );
 501
 502 TRACE_EVENT(f2fs_get_victim,
 503
 504         TP_PROTO(struct super_block *sb, int type, int gc_type,
 505                         struct victim_sel_policy *p, unsigned int pre_victim,
 506                         unsigned int prefree, unsigned int free),
 507
 508         TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
 509
 510         TP_STRUCT__entry(
 511                 __field(dev_t,  dev)
 512                 __field(int,    type)
 513                 __field(int,    gc_type)
 514                 __field(int,    alloc_mode)
 515                 __field(int,    gc_mode)
 516                 __field(unsigned int,   victim)
 517                 __field(unsigned int,   ofs_unit)
 518                 __field(unsigned int,   pre_victim)
 519                 __field(unsigned int,   prefree)
 520                 __field(unsigned int,   free)
 521         ),
 522
 523         TP_fast_assign(
 524                 __entry->dev            = sb->s_dev;
 525                 __entry->type           = type;
 526                 __entry->gc_type        = gc_type;
 527                 __entry->alloc_mode     = p->alloc_mode;
 528                 __entry->gc_mode        = p->gc_mode;
 529                 __entry->victim         = p->min_segno;
 530                 __entry->ofs_unit       = p->ofs_unit;
 531                 __entry->pre_victim     = pre_victim;
 532                 __entry->prefree        = prefree;
 533                 __entry->free           = free;
 534         ),
 535
 536         TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), victim = %u "
 537                 "ofs_unit = %u, pre_victim_secno = %d, prefree = %u, free = %u",
 538                 show_dev(__entry),
 539                 show_data_type(__entry->type),
 540                 show_gc_type(__entry->gc_type),
 541                 show_alloc_mode(__entry->alloc_mode),
 542                 show_victim_policy(__entry->gc_mode),
 543                 __entry->victim,
 544                 __entry->ofs_unit,
 545                 (int)__entry->pre_victim,
 546                 __entry->prefree,
 547                 __entry->free)
 548 );
 549
 550 TRACE_EVENT(f2fs_fallocate,
 551
 552         TP_PROTO(struct inode *inode, int mode,
 553                                 loff_t offset, loff_t len, int ret),
 554
 555         TP_ARGS(inode, mode, offset, len, ret),
 556
 557         TP_STRUCT__entry(
 558                 __field(dev_t,  dev)
 559                 __field(ino_t,  ino)
 560                 __field(int,    mode)
 561                 __field(loff_t, offset)
 562                 __field(loff_t, len)
 563                 __field(loff_t, size)
 564                 __field(blkcnt_t, blocks)
 565                 __field(int,    ret)
 566         ),
 567
 568         TP_fast_assign(
 569                 __entry->dev    = inode->i_sb->s_dev;
 570                 __entry->ino    = inode->i_ino;
 571                 __entry->mode   = mode;
 572                 __entry->offset = offset;
 573                 __entry->len    = len;
 574                 __entry->size   = inode->i_size;
 575                 __entry->blocks = inode->i_blocks;
 576                 __entry->ret    = ret;
 577         ),
 578
 579         TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
 580                 "len = %lld,  i_size = %lld, i_blocks = %llu, ret = %d",
 581                 show_dev_ino(__entry),
 582                 __entry->mode,
 583                 (unsigned long long)__entry->offset,
 584                 (unsigned long long)__entry->len,
 585                 (unsigned long long)__entry->size,
 586                 (unsigned long long)__entry->blocks,
 587                 __entry->ret)
 588 );
 589
 590 TRACE_EVENT(f2fs_direct_IO_enter,
 591
 592         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
 593
 594         TP_ARGS(inode, offset, len, rw),
 595
 596         TP_STRUCT__entry(
 597                 __field(dev_t,  dev)
 598                 __field(ino_t,  ino)
 599                 __field(loff_t, pos)
 600                 __field(unsigned long,  len)
 601                 __field(int,    rw)
 602         ),
 603
 604         TP_fast_assign(
 605                 __entry->dev    = inode->i_sb->s_dev;
 606                 __entry->ino    = inode->i_ino;
 607                 __entry->pos    = offset;
 608                 __entry->len    = len;
 609                 __entry->rw     = rw;
 610         ),
 611
 612         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu rw = %d",
 613                 show_dev_ino(__entry),
 614                 __entry->pos,
 615                 __entry->len,
 616                 __entry->rw)
 617 );
 618
 619 TRACE_EVENT(f2fs_direct_IO_exit,
 620
 621         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
 622                  int rw, int ret),
 623
 624         TP_ARGS(inode, offset, len, rw, ret),
 625
 626         TP_STRUCT__entry(
 627                 __field(dev_t,  dev)
 628                 __field(ino_t,  ino)
 629                 __field(loff_t, pos)
 630                 __field(unsigned long,  len)
 631                 __field(int,    rw)
 632                 __field(int,    ret)
 633         ),
 634
 635         TP_fast_assign(
 636                 __entry->dev    = inode->i_sb->s_dev;
 637                 __entry->ino    = inode->i_ino;
 638                 __entry->pos    = offset;
 639                 __entry->len    = len;
 640                 __entry->rw     = rw;
 641                 __entry->ret    = ret;
 642         ),
 643
 644         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu "
 645                 "rw = %d ret = %d",
 646                 show_dev_ino(__entry),
 647                 __entry->pos,
 648                 __entry->len,
 649                 __entry->rw,
 650                 __entry->ret)
 651 );
 652
 653 TRACE_EVENT(f2fs_reserve_new_block,
 654
 655         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node),
 656
 657         TP_ARGS(inode, nid, ofs_in_node),
 658
 659         TP_STRUCT__entry(
 660                 __field(dev_t,  dev)
 661                 __field(nid_t, nid)
 662                 __field(unsigned int, ofs_in_node)
 663         ),
 664
 665         TP_fast_assign(
 666                 __entry->dev    = inode->i_sb->s_dev;
 667                 __entry->nid    = nid;
 668                 __entry->ofs_in_node = ofs_in_node;
 669         ),
 670
 671         TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u",
 672                 show_dev(__entry),
 673                 (unsigned int)__entry->nid,
 674                 __entry->ofs_in_node)
 675 );
 676
 677 DECLARE_EVENT_CLASS(f2fs__submit_bio,
 678
 679         TP_PROTO(struct super_block *sb, int rw, int type, struct bio *bio),
 680
 681         TP_ARGS(sb, rw, type, bio),
 682
 683         TP_STRUCT__entry(
 684                 __field(dev_t,  dev)
 685                 __field(int,    rw)
 686                 __field(int,    type)
 687                 __field(sector_t,       sector)
 688                 __field(unsigned int,   size)
 689         ),
 690
 691         TP_fast_assign(
 692                 __entry->dev            = sb->s_dev;
 693                 __entry->rw             = rw;
 694                 __entry->type           = type;
 695                 __entry->sector         = bio->bi_iter.bi_sector;
 696                 __entry->size           = bio->bi_iter.bi_size;
 697         ),
 698
 699         TP_printk("dev = (%d,%d), %s%s, %s, sector = %lld, size = %u",
 700                 show_dev(__entry),
 701                 show_bio_type(__entry->rw),
 702                 show_block_type(__entry->type),
 703                 (unsigned long long)__entry->sector,
 704                 __entry->size)
 705 );
 706
 707 DEFINE_EVENT_CONDITION(f2fs__submit_bio, f2fs_submit_write_bio,
 708
 709         TP_PROTO(struct super_block *sb, int rw, int type, struct bio *bio),
 710
 711         TP_ARGS(sb, rw, type, bio),
 712
 713         TP_CONDITION(bio)
 714 );
 715
 716 DEFINE_EVENT_CONDITION(f2fs__submit_bio, f2fs_submit_read_bio,
 717
 718         TP_PROTO(struct super_block *sb, int rw, int type, struct bio *bio),
 719
 720         TP_ARGS(sb, rw, type, bio),
 721
 722         TP_CONDITION(bio)
 723 );
 724
 725 TRACE_EVENT(f2fs_write_begin,
 726
 727         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 728                                 unsigned int flags),
 729
 730         TP_ARGS(inode, pos, len, flags),
 731
 732         TP_STRUCT__entry(
 733                 __field(dev_t,  dev)
 734                 __field(ino_t,  ino)
 735                 __field(loff_t, pos)
 736                 __field(unsigned int, len)
 737                 __field(unsigned int, flags)
 738         ),
 739
 740         TP_fast_assign(
 741                 __entry->dev    = inode->i_sb->s_dev;
 742                 __entry->ino    = inode->i_ino;
 743                 __entry->pos    = pos;
 744                 __entry->len    = len;
 745                 __entry->flags  = flags;
 746         ),
 747
 748         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, flags = %u",
 749                 show_dev_ino(__entry),
 750                 (unsigned long long)__entry->pos,
 751                 __entry->len,
 752                 __entry->flags)
 753 );
 754
 755 TRACE_EVENT(f2fs_write_end,
 756
 757         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 758                                 unsigned int copied),
 759
 760         TP_ARGS(inode, pos, len, copied),
 761
 762         TP_STRUCT__entry(
 763                 __field(dev_t,  dev)
 764                 __field(ino_t,  ino)
 765                 __field(loff_t, pos)
 766                 __field(unsigned int, len)
 767                 __field(unsigned int, copied)
 768         ),
 769
 770         TP_fast_assign(
 771                 __entry->dev    = inode->i_sb->s_dev;
 772                 __entry->ino    = inode->i_ino;
 773                 __entry->pos    = pos;
 774                 __entry->len    = len;
 775                 __entry->copied = copied;
 776         ),
 777
 778         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, copied = %u",
 779                 show_dev_ino(__entry),
 780                 (unsigned long long)__entry->pos,
 781                 __entry->len,
 782                 __entry->copied)
 783 );
 784
 785 DECLARE_EVENT_CLASS(f2fs__page,
 786
 787         TP_PROTO(struct page *page, int type),
 788
 789         TP_ARGS(page, type),
 790
 791         TP_STRUCT__entry(
 792                 __field(dev_t,  dev)
 793                 __field(ino_t,  ino)
 794                 __field(int, type)
 795                 __field(int, dir)
 796                 __field(pgoff_t, index)
 797                 __field(int, dirty)
 798                 __field(int, uptodate)
 799         ),
 800
 801         TP_fast_assign(
 802                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 803                 __entry->ino    = page->mapping->host->i_ino;
 804                 __entry->type   = type;
 805                 __entry->dir    = S_ISDIR(page->mapping->host->i_mode);
 806                 __entry->index  = page->index;
 807                 __entry->dirty  = PageDirty(page);
 808                 __entry->uptodate = PageUptodate(page);
 809         ),
 810
 811         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, "
 812                 "dirty = %d, uptodate = %d",
 813                 show_dev_ino(__entry),
 814                 show_block_type(__entry->type),
 815                 show_file_type(__entry->dir),
 816                 (unsigned long)__entry->index,
 817                 __entry->dirty,
 818                 __entry->uptodate)
 819 );
 820
 821 DEFINE_EVENT(f2fs__page, f2fs_writepage,
 822
 823         TP_PROTO(struct page *page, int type),
 824
 825         TP_ARGS(page, type)
 826 );
 827
 828 DEFINE_EVENT(f2fs__page, f2fs_readpage,
 829
 830         TP_PROTO(struct page *page, int type),
 831
 832         TP_ARGS(page, type)
 833 );
 834
 835 DEFINE_EVENT(f2fs__page, f2fs_set_page_dirty,
 836
 837         TP_PROTO(struct page *page, int type),
 838
 839         TP_ARGS(page, type)
 840 );
 841
 842 DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
 843
 844         TP_PROTO(struct page *page, int type),
 845
 846         TP_ARGS(page, type)
 847 );
 848
 849 TRACE_EVENT(f2fs_writepages,
 850
 851         TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type),
 852
 853         TP_ARGS(inode, wbc, type),
 854
 855         TP_STRUCT__entry(
 856                 __field(dev_t,  dev)
 857                 __field(ino_t,  ino)
 858                 __field(int,    type)
 859                 __field(int,    dir)
 860                 __field(long,   nr_to_write)
 861                 __field(long,   pages_skipped)
 862                 __field(loff_t, range_start)
 863                 __field(loff_t, range_end)
 864                 __field(pgoff_t, writeback_index)
 865                 __field(int,    sync_mode)
 866                 __field(char,   for_kupdate)
 867                 __field(char,   for_background)
 868                 __field(char,   tagged_writepages)
 869                 __field(char,   for_reclaim)
 870                 __field(char,   range_cyclic)
 871                 __field(char,   for_sync)
 872         ),
 873
 874         TP_fast_assign(
 875                 __entry->dev            = inode->i_sb->s_dev;
 876                 __entry->ino            = inode->i_ino;
 877                 __entry->type           = type;
 878                 __entry->dir            = S_ISDIR(inode->i_mode);
 879                 __entry->nr_to_write    = wbc->nr_to_write;
 880                 __entry->pages_skipped  = wbc->pages_skipped;
 881                 __entry->range_start    = wbc->range_start;
 882                 __entry->range_end      = wbc->range_end;
 883                 __entry->writeback_index = inode->i_mapping->writeback_index;
 884                 __entry->sync_mode      = wbc->sync_mode;
 885                 __entry->for_kupdate    = wbc->for_kupdate;
 886                 __entry->for_background = wbc->for_background;
 887                 __entry->tagged_writepages      = wbc->tagged_writepages;
 888                 __entry->for_reclaim    = wbc->for_reclaim;
 889                 __entry->range_cyclic   = wbc->range_cyclic;
 890                 __entry->for_sync       = wbc->for_sync;
 891         ),
 892
 893         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, nr_to_write %ld, "
 894                 "skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, "
 895                 "kupdate %u background %u tagged %u reclaim %u cyclic %u sync %u",
 896                 show_dev_ino(__entry),
 897                 show_block_type(__entry->type),
 898                 show_file_type(__entry->dir),
 899                 __entry->nr_to_write,
 900                 __entry->pages_skipped,
 901                 __entry->range_start,
 902                 __entry->range_end,
 903                 (unsigned long)__entry->writeback_index,
 904                 __entry->sync_mode,
 905                 __entry->for_kupdate,
 906                 __entry->for_background,
 907                 __entry->tagged_writepages,
 908                 __entry->for_reclaim,
 909                 __entry->range_cyclic,
 910                 __entry->for_sync)
 911 );
 912
 913 TRACE_EVENT(f2fs_submit_page_mbio,
 914
 915         TP_PROTO(struct page *page, int rw, int type, block_t blk_addr),
 916
 917         TP_ARGS(page, rw, type, blk_addr),
 918
 919         TP_STRUCT__entry(
 920                 __field(dev_t,  dev)
 921                 __field(ino_t,  ino)
 922                 __field(int, rw)
 923                 __field(int, type)
 924                 __field(pgoff_t, index)
 925                 __field(block_t, block)
 926         ),
 927
 928         TP_fast_assign(
 929                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 930                 __entry->ino    = page->mapping->host->i_ino;
 931                 __entry->rw     = rw;
 932                 __entry->type   = type;
 933                 __entry->index  = page->index;
 934                 __entry->block  = blk_addr;
 935         ),
 936
 937         TP_printk("dev = (%d,%d), ino = %lu, %s%s, %s, index = %lu, blkaddr = 0x%llx",
 938                 show_dev_ino(__entry),
 939                 show_bio_type(__entry->rw),
 940                 show_block_type(__entry->type),
 941                 (unsigned long)__entry->index,
 942                 (unsigned long long)__entry->block)
 943 );
 944
 945 TRACE_EVENT(f2fs_write_checkpoint,
 946
 947         TP_PROTO(struct super_block *sb, bool is_umount, char *msg),
 948
 949         TP_ARGS(sb, is_umount, msg),
 950
 951         TP_STRUCT__entry(
 952                 __field(dev_t,  dev)
 953                 __field(bool,   is_umount)
 954                 __field(char *, msg)
 955         ),
 956
 957         TP_fast_assign(
 958                 __entry->dev            = sb->s_dev;
 959                 __entry->is_umount      = is_umount;
 960                 __entry->msg            = msg;
 961         ),
 962
 963         TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
 964                 show_dev(__entry),
 965                 __entry->is_umount ? "clean umount" : "consistency",
 966                 __entry->msg)
 967 );
 968
 969 TRACE_EVENT(f2fs_issue_discard,
 970
 971         TP_PROTO(struct super_block *sb, block_t blkstart, block_t blklen),
 972
 973         TP_ARGS(sb, blkstart, blklen),
 974
 975         TP_STRUCT__entry(
 976                 __field(dev_t,  dev)
 977                 __field(block_t, blkstart)
 978                 __field(block_t, blklen)
 979         ),
 980
 981         TP_fast_assign(
 982                 __entry->dev    = sb->s_dev;
 983                 __entry->blkstart = blkstart;
 984                 __entry->blklen = blklen;
 985         ),
 986
 987         TP_printk("dev = (%d,%d), blkstart = 0x%llx, blklen = 0x%llx",
 988                 show_dev(__entry),
 989                 (unsigned long long)__entry->blkstart,
 990                 (unsigned long long)__entry->blklen)
 991 );
 992
 993 TRACE_EVENT(f2fs_issue_flush,
 994
 995         TP_PROTO(struct super_block *sb, bool nobarrier, bool flush_merge),
 996
 997         TP_ARGS(sb, nobarrier, flush_merge),
 998
 999         TP_STRUCT__entry(
1000                 __field(dev_t,  dev)
1001                 __field(bool, nobarrier)
1002                 __field(bool, flush_merge)
1003         ),
1004
1005         TP_fast_assign(
1006                 __entry->dev    = sb->s_dev;
1007                 __entry->nobarrier = nobarrier;
1008                 __entry->flush_merge = flush_merge;
1009         ),
1010
1011         TP_printk("dev = (%d,%d), %s %s",
1012                 show_dev(__entry),
1013                 __entry->nobarrier ? "skip (nobarrier)" : "issue",
1014                 __entry->flush_merge ? " with flush_merge" : "")
1015 );
1016 #endif /* _TRACE_F2FS_H */
1017
1018  /* This part must be outside protection */
1019 #include <trace/define_trace.h>