Pileus Git - ~andy/linux/blob - 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 show_bio_type(type)                                             \
  20         __print_symbolic(type,                                          \
  21                 { READ,         "READ" },                               \
  22                 { READA,        "READAHEAD" },                          \
  23                 { READ_SYNC,    "READ_SYNC" },                          \
  24                 { WRITE,        "WRITE" },                              \
  25                 { WRITE_SYNC,   "WRITE_SYNC" },                         \
  26                 { WRITE_FLUSH,  "WRITE_FLUSH" },                        \
  27                 { WRITE_FUA,    "WRITE_FUA" })
  28
  29 #define show_data_type(type)                                            \
  30         __print_symbolic(type,                                          \
  31                 { CURSEG_HOT_DATA,      "Hot DATA" },                   \
  32                 { CURSEG_WARM_DATA,     "Warm DATA" },                  \
  33                 { CURSEG_COLD_DATA,     "Cold DATA" },                  \
  34                 { CURSEG_HOT_NODE,      "Hot NODE" },                   \
  35                 { CURSEG_WARM_NODE,     "Warm NODE" },                  \
  36                 { CURSEG_COLD_NODE,     "Cold NODE" },                  \
  37                 { NO_CHECK_TYPE,        "No TYPE" })
  38
  39 #define show_file_type(type)                                            \
  40         __print_symbolic(type,                                          \
  41                 { 0,            "FILE" },                               \
  42                 { 1,            "DIR" })
  43
  44 #define show_gc_type(type)                                              \
  45         __print_symbolic(type,                                          \
  46                 { FG_GC,        "Foreground GC" },                      \
  47                 { BG_GC,        "Background GC" })
  48
  49 #define show_alloc_mode(type)                                           \
  50         __print_symbolic(type,                                          \
  51                 { LFS,  "LFS-mode" },                                   \
  52                 { SSR,  "SSR-mode" })
  53
  54 #define show_victim_policy(type)                                        \
  55         __print_symbolic(type,                                          \
  56                 { GC_GREEDY,    "Greedy" },                             \
  57                 { GC_CB,        "Cost-Benefit" })
  58
  59 struct victim_sel_policy;
  60
  61 DECLARE_EVENT_CLASS(f2fs__inode,
  62
  63         TP_PROTO(struct inode *inode),
  64
  65         TP_ARGS(inode),
  66
  67         TP_STRUCT__entry(
  68                 __field(dev_t,  dev)
  69                 __field(ino_t,  ino)
  70                 __field(ino_t,  pino)
  71                 __field(umode_t, mode)
  72                 __field(loff_t, size)
  73                 __field(unsigned int, nlink)
  74                 __field(blkcnt_t, blocks)
  75                 __field(__u8,   advise)
  76         ),
  77
  78         TP_fast_assign(
  79                 __entry->dev    = inode->i_sb->s_dev;
  80                 __entry->ino    = inode->i_ino;
  81                 __entry->pino   = F2FS_I(inode)->i_pino;
  82                 __entry->mode   = inode->i_mode;
  83                 __entry->nlink  = inode->i_nlink;
  84                 __entry->size   = inode->i_size;
  85                 __entry->blocks = inode->i_blocks;
  86                 __entry->advise = F2FS_I(inode)->i_advise;
  87         ),
  88
  89         TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
  90                 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
  91                 show_dev_ino(__entry),
  92                 (unsigned long)__entry->pino,
  93                 __entry->mode,
  94                 __entry->size,
  95                 (unsigned int)__entry->nlink,
  96                 (unsigned long long)__entry->blocks,
  97                 (unsigned char)__entry->advise)
  98 );
  99
 100 DECLARE_EVENT_CLASS(f2fs__inode_exit,
 101
 102         TP_PROTO(struct inode *inode, int ret),
 103
 104         TP_ARGS(inode, ret),
 105
 106         TP_STRUCT__entry(
 107                 __field(dev_t,  dev)
 108                 __field(ino_t,  ino)
 109                 __field(int,    ret)
 110         ),
 111
 112         TP_fast_assign(
 113                 __entry->dev    = inode->i_sb->s_dev;
 114                 __entry->ino    = inode->i_ino;
 115                 __entry->ret    = ret;
 116         ),
 117
 118         TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
 119                 show_dev_ino(__entry),
 120                 __entry->ret)
 121 );
 122
 123 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
 124
 125         TP_PROTO(struct inode *inode),
 126
 127         TP_ARGS(inode)
 128 );
 129
 130 TRACE_EVENT(f2fs_sync_file_exit,
 131
 132         TP_PROTO(struct inode *inode, bool need_cp, int datasync, int ret),
 133
 134         TP_ARGS(inode, need_cp, datasync, ret),
 135
 136         TP_STRUCT__entry(
 137                 __field(dev_t,  dev)
 138                 __field(ino_t,  ino)
 139                 __field(bool,   need_cp)
 140                 __field(int,    datasync)
 141                 __field(int,    ret)
 142         ),
 143
 144         TP_fast_assign(
 145                 __entry->dev            = inode->i_sb->s_dev;
 146                 __entry->ino            = inode->i_ino;
 147                 __entry->need_cp        = need_cp;
 148                 __entry->datasync       = datasync;
 149                 __entry->ret            = ret;
 150         ),
 151
 152         TP_printk("dev = (%d,%d), ino = %lu, checkpoint is %s, "
 153                 "datasync = %d, ret = %d",
 154                 show_dev_ino(__entry),
 155                 __entry->need_cp ? "needed" : "not needed",
 156                 __entry->datasync,
 157                 __entry->ret)
 158 );
 159
 160 TRACE_EVENT(f2fs_sync_fs,
 161
 162         TP_PROTO(struct super_block *sb, int wait),
 163
 164         TP_ARGS(sb, wait),
 165
 166         TP_STRUCT__entry(
 167                 __field(dev_t,  dev)
 168                 __field(int,    dirty)
 169                 __field(int,    wait)
 170         ),
 171
 172         TP_fast_assign(
 173                 __entry->dev    = sb->s_dev;
 174                 __entry->dirty  = F2FS_SB(sb)->s_dirty;
 175                 __entry->wait   = wait;
 176         ),
 177
 178         TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
 179                 show_dev(__entry),
 180                 __entry->dirty ? "dirty" : "not dirty",
 181                 __entry->wait)
 182 );
 183
 184 DEFINE_EVENT(f2fs__inode, f2fs_iget,
 185
 186         TP_PROTO(struct inode *inode),
 187
 188         TP_ARGS(inode)
 189 );
 190
 191 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
 192
 193         TP_PROTO(struct inode *inode, int ret),
 194
 195         TP_ARGS(inode, ret)
 196 );
 197
 198 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
 199
 200         TP_PROTO(struct inode *inode),
 201
 202         TP_ARGS(inode)
 203 );
 204
 205 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode,
 206
 207         TP_PROTO(struct inode *inode, int ret),
 208
 209         TP_ARGS(inode, ret)
 210 );
 211
 212 TRACE_EVENT(f2fs_unlink_enter,
 213
 214         TP_PROTO(struct inode *dir, struct dentry *dentry),
 215
 216         TP_ARGS(dir, dentry),
 217
 218         TP_STRUCT__entry(
 219                 __field(dev_t,  dev)
 220                 __field(ino_t,  ino)
 221                 __field(loff_t, size)
 222                 __field(blkcnt_t, blocks)
 223                 __field(const char *,   name)
 224         ),
 225
 226         TP_fast_assign(
 227                 __entry->dev    = dir->i_sb->s_dev;
 228                 __entry->ino    = dir->i_ino;
 229                 __entry->size   = dir->i_size;
 230                 __entry->blocks = dir->i_blocks;
 231                 __entry->name   = dentry->d_name.name;
 232         ),
 233
 234         TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
 235                 "i_blocks = %llu, name = %s",
 236                 show_dev_ino(__entry),
 237                 __entry->size,
 238                 (unsigned long long)__entry->blocks,
 239                 __entry->name)
 240 );
 241
 242 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
 243
 244         TP_PROTO(struct inode *inode, int ret),
 245
 246         TP_ARGS(inode, ret)
 247 );
 248
 249 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
 250
 251         TP_PROTO(struct inode *inode),
 252
 253         TP_ARGS(inode)
 254 );
 255
 256 TRACE_EVENT(f2fs_truncate_data_blocks_range,
 257
 258         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
 259
 260         TP_ARGS(inode, nid,  ofs, free),
 261
 262         TP_STRUCT__entry(
 263                 __field(dev_t,  dev)
 264                 __field(ino_t,  ino)
 265                 __field(nid_t,  nid)
 266                 __field(unsigned int,   ofs)
 267                 __field(int,    free)
 268         ),
 269
 270         TP_fast_assign(
 271                 __entry->dev    = inode->i_sb->s_dev;
 272                 __entry->ino    = inode->i_ino;
 273                 __entry->nid    = nid;
 274                 __entry->ofs    = ofs;
 275                 __entry->free   = free;
 276         ),
 277
 278         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
 279                 show_dev_ino(__entry),
 280                 (unsigned int)__entry->nid,
 281                 __entry->ofs,
 282                 __entry->free)
 283 );
 284
 285 DECLARE_EVENT_CLASS(f2fs__truncate_op,
 286
 287         TP_PROTO(struct inode *inode, u64 from),
 288
 289         TP_ARGS(inode, from),
 290
 291         TP_STRUCT__entry(
 292                 __field(dev_t,  dev)
 293                 __field(ino_t,  ino)
 294                 __field(loff_t, size)
 295                 __field(blkcnt_t, blocks)
 296                 __field(u64,    from)
 297         ),
 298
 299         TP_fast_assign(
 300                 __entry->dev    = inode->i_sb->s_dev;
 301                 __entry->ino    = inode->i_ino;
 302                 __entry->size   = inode->i_size;
 303                 __entry->blocks = inode->i_blocks;
 304                 __entry->from   = from;
 305         ),
 306
 307         TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
 308                 "start file offset = %llu",
 309                 show_dev_ino(__entry),
 310                 __entry->size,
 311                 (unsigned long long)__entry->blocks,
 312                 (unsigned long long)__entry->from)
 313 );
 314
 315 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
 316
 317         TP_PROTO(struct inode *inode, u64 from),
 318
 319         TP_ARGS(inode, from)
 320 );
 321
 322 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
 323
 324         TP_PROTO(struct inode *inode, int ret),
 325
 326         TP_ARGS(inode, ret)
 327 );
 328
 329 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
 330
 331         TP_PROTO(struct inode *inode, u64 from),
 332
 333         TP_ARGS(inode, from)
 334 );
 335
 336 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
 337
 338         TP_PROTO(struct inode *inode, int ret),
 339
 340         TP_ARGS(inode, ret)
 341 );
 342
 343 DECLARE_EVENT_CLASS(f2fs__truncate_node,
 344
 345         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 346
 347         TP_ARGS(inode, nid, blk_addr),
 348
 349         TP_STRUCT__entry(
 350                 __field(dev_t,  dev)
 351                 __field(ino_t,  ino)
 352                 __field(nid_t,  nid)
 353                 __field(block_t,        blk_addr)
 354         ),
 355
 356         TP_fast_assign(
 357                 __entry->dev            = inode->i_sb->s_dev;
 358                 __entry->ino            = inode->i_ino;
 359                 __entry->nid            = nid;
 360                 __entry->blk_addr       = blk_addr;
 361         ),
 362
 363         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
 364                 show_dev_ino(__entry),
 365                 (unsigned int)__entry->nid,
 366                 (unsigned long long)__entry->blk_addr)
 367 );
 368
 369 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
 370
 371         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 372
 373         TP_ARGS(inode, nid, blk_addr)
 374 );
 375
 376 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
 377
 378         TP_PROTO(struct inode *inode, int ret),
 379
 380         TP_ARGS(inode, ret)
 381 );
 382
 383 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
 384
 385         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 386
 387         TP_ARGS(inode, nid, blk_addr)
 388 );
 389
 390 TRACE_EVENT(f2fs_truncate_partial_nodes,
 391
 392         TP_PROTO(struct inode *inode, nid_t nid[], int depth, int err),
 393
 394         TP_ARGS(inode, nid, depth, err),
 395
 396         TP_STRUCT__entry(
 397                 __field(dev_t,  dev)
 398                 __field(ino_t,  ino)
 399                 __field(nid_t,  nid[3])
 400                 __field(int,    depth)
 401                 __field(int,    err)
 402         ),
 403
 404         TP_fast_assign(
 405                 __entry->dev    = inode->i_sb->s_dev;
 406                 __entry->ino    = inode->i_ino;
 407                 __entry->nid[0] = nid[0];
 408                 __entry->nid[1] = nid[1];
 409                 __entry->nid[2] = nid[2];
 410                 __entry->depth  = depth;
 411                 __entry->err    = err;
 412         ),
 413
 414         TP_printk("dev = (%d,%d), ino = %lu, "
 415                 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
 416                 show_dev_ino(__entry),
 417                 (unsigned int)__entry->nid[0],
 418                 (unsigned int)__entry->nid[1],
 419                 (unsigned int)__entry->nid[2],
 420                 __entry->depth,
 421                 __entry->err)
 422 );
 423
 424 TRACE_EVENT_CONDITION(f2fs_readpage,
 425
 426         TP_PROTO(struct page *page, sector_t blkaddr, int type),
 427
 428         TP_ARGS(page, blkaddr, type),
 429
 430         TP_CONDITION(page->mapping),
 431
 432         TP_STRUCT__entry(
 433                 __field(dev_t,  dev)
 434                 __field(ino_t,  ino)
 435                 __field(pgoff_t,        index)
 436                 __field(sector_t,       blkaddr)
 437                 __field(int,    type)
 438         ),
 439
 440         TP_fast_assign(
 441                 __entry->dev            = page->mapping->host->i_sb->s_dev;
 442                 __entry->ino            = page->mapping->host->i_ino;
 443                 __entry->index          = page->index;
 444                 __entry->blkaddr        = blkaddr;
 445                 __entry->type           = type;
 446         ),
 447
 448         TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
 449                 "blkaddr = 0x%llx, bio_type = %s",
 450                 show_dev_ino(__entry),
 451                 (unsigned long)__entry->index,
 452                 (unsigned long long)__entry->blkaddr,
 453                 show_bio_type(__entry->type))
 454 );
 455
 456 TRACE_EVENT(f2fs_get_data_block,
 457         TP_PROTO(struct inode *inode, sector_t iblock,
 458                                 struct buffer_head *bh, int ret),
 459
 460         TP_ARGS(inode, iblock, bh, ret),
 461
 462         TP_STRUCT__entry(
 463                 __field(dev_t,  dev)
 464                 __field(ino_t,  ino)
 465                 __field(sector_t,       iblock)
 466                 __field(sector_t,       bh_start)
 467                 __field(size_t, bh_size)
 468                 __field(int,    ret)
 469         ),
 470
 471         TP_fast_assign(
 472                 __entry->dev            = inode->i_sb->s_dev;
 473                 __entry->ino            = inode->i_ino;
 474                 __entry->iblock         = iblock;
 475                 __entry->bh_start       = bh->b_blocknr;
 476                 __entry->bh_size        = bh->b_size;
 477                 __entry->ret            = ret;
 478         ),
 479
 480         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
 481                 "start blkaddr = 0x%llx, len = 0x%llx bytes, err = %d",
 482                 show_dev_ino(__entry),
 483                 (unsigned long long)__entry->iblock,
 484                 (unsigned long long)__entry->bh_start,
 485                 (unsigned long long)__entry->bh_size,
 486                 __entry->ret)
 487 );
 488
 489 TRACE_EVENT(f2fs_get_victim,
 490
 491         TP_PROTO(struct super_block *sb, int type, int gc_type,
 492                         struct victim_sel_policy *p, unsigned int pre_victim,
 493                         unsigned int prefree, unsigned int free),
 494
 495         TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
 496
 497         TP_STRUCT__entry(
 498                 __field(dev_t,  dev)
 499                 __field(int,    type)
 500                 __field(int,    gc_type)
 501                 __field(int,    alloc_mode)
 502                 __field(int,    gc_mode)
 503                 __field(unsigned int,   victim)
 504                 __field(unsigned int,   ofs_unit)
 505                 __field(unsigned int,   pre_victim)
 506                 __field(unsigned int,   prefree)
 507                 __field(unsigned int,   free)
 508         ),
 509
 510         TP_fast_assign(
 511                 __entry->dev            = sb->s_dev;
 512                 __entry->type           = type;
 513                 __entry->gc_type        = gc_type;
 514                 __entry->alloc_mode     = p->alloc_mode;
 515                 __entry->gc_mode        = p->gc_mode;
 516                 __entry->victim         = p->min_segno;
 517                 __entry->ofs_unit       = p->ofs_unit;
 518                 __entry->pre_victim     = pre_victim;
 519                 __entry->prefree        = prefree;
 520                 __entry->free           = free;
 521         ),
 522
 523         TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), victim = %u "
 524                 "ofs_unit = %u, pre_victim_secno = %d, prefree = %u, free = %u",
 525                 show_dev(__entry),
 526                 show_data_type(__entry->type),
 527                 show_gc_type(__entry->gc_type),
 528                 show_alloc_mode(__entry->alloc_mode),
 529                 show_victim_policy(__entry->gc_mode),
 530                 __entry->victim,
 531                 __entry->ofs_unit,
 532                 (int)__entry->pre_victim,
 533                 __entry->prefree,
 534                 __entry->free)
 535 );
 536
 537 TRACE_EVENT(f2fs_fallocate,
 538
 539         TP_PROTO(struct inode *inode, int mode,
 540                                 loff_t offset, loff_t len, int ret),
 541
 542         TP_ARGS(inode, mode, offset, len, ret),
 543
 544         TP_STRUCT__entry(
 545                 __field(dev_t,  dev)
 546                 __field(ino_t,  ino)
 547                 __field(int,    mode)
 548                 __field(loff_t, offset)
 549                 __field(loff_t, len)
 550                 __field(loff_t, size)
 551                 __field(blkcnt_t, blocks)
 552                 __field(int,    ret)
 553         ),
 554
 555         TP_fast_assign(
 556                 __entry->dev    = inode->i_sb->s_dev;
 557                 __entry->ino    = inode->i_ino;
 558                 __entry->mode   = mode;
 559                 __entry->offset = offset;
 560                 __entry->len    = len;
 561                 __entry->size   = inode->i_size;
 562                 __entry->blocks = inode->i_blocks;
 563                 __entry->ret    = ret;
 564         ),
 565
 566         TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
 567                 "len = %lld,  i_size = %lld, i_blocks = %llu, ret = %d",
 568                 show_dev_ino(__entry),
 569                 __entry->mode,
 570                 (unsigned long long)__entry->offset,
 571                 (unsigned long long)__entry->len,
 572                 (unsigned long long)__entry->size,
 573                 (unsigned long long)__entry->blocks,
 574                 __entry->ret)
 575 );
 576
 577 TRACE_EVENT(f2fs_reserve_new_block,
 578
 579         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node),
 580
 581         TP_ARGS(inode, nid, ofs_in_node),
 582
 583         TP_STRUCT__entry(
 584                 __field(dev_t,  dev)
 585                 __field(nid_t, nid)
 586                 __field(unsigned int, ofs_in_node)
 587         ),
 588
 589         TP_fast_assign(
 590                 __entry->dev    = inode->i_sb->s_dev;
 591                 __entry->nid    = nid;
 592                 __entry->ofs_in_node = ofs_in_node;
 593         ),
 594
 595         TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u",
 596                 show_dev(__entry),
 597                 (unsigned int)__entry->nid,
 598                 __entry->ofs_in_node)
 599 );
 600
 601 TRACE_EVENT(f2fs_do_submit_bio,
 602
 603         TP_PROTO(struct super_block *sb, int btype, bool sync, struct bio *bio),
 604
 605         TP_ARGS(sb, btype, sync, bio),
 606
 607         TP_STRUCT__entry(
 608                 __field(dev_t,  dev)
 609                 __field(int,    btype)
 610                 __field(bool,   sync)
 611                 __field(sector_t,       sector)
 612                 __field(unsigned int,   size)
 613         ),
 614
 615         TP_fast_assign(
 616                 __entry->dev            = sb->s_dev;
 617                 __entry->btype          = btype;
 618                 __entry->sync           = sync;
 619                 __entry->sector         = bio->bi_iter.bi_sector;
 620                 __entry->size           = bio->bi_iter.bi_size;
 621         ),
 622
 623         TP_printk("dev = (%d,%d), type = %s, io = %s, sector = %lld, size = %u",
 624                 show_dev(__entry),
 625                 show_block_type(__entry->btype),
 626                 __entry->sync ? "sync" : "no sync",
 627                 (unsigned long long)__entry->sector,
 628                 __entry->size)
 629 );
 630
 631 DECLARE_EVENT_CLASS(f2fs__page,
 632
 633         TP_PROTO(struct page *page, int type),
 634
 635         TP_ARGS(page, type),
 636
 637         TP_STRUCT__entry(
 638                 __field(dev_t,  dev)
 639                 __field(ino_t,  ino)
 640                 __field(int, type)
 641                 __field(int, dir)
 642                 __field(pgoff_t, index)
 643                 __field(int, dirty)
 644         ),
 645
 646         TP_fast_assign(
 647                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 648                 __entry->ino    = page->mapping->host->i_ino;
 649                 __entry->type   = type;
 650                 __entry->dir    = S_ISDIR(page->mapping->host->i_mode);
 651                 __entry->index  = page->index;
 652                 __entry->dirty  = PageDirty(page);
 653         ),
 654
 655         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, dirty = %d",
 656                 show_dev_ino(__entry),
 657                 show_block_type(__entry->type),
 658                 show_file_type(__entry->dir),
 659                 (unsigned long)__entry->index,
 660                 __entry->dirty)
 661 );
 662
 663 DEFINE_EVENT(f2fs__page, f2fs_set_page_dirty,
 664
 665         TP_PROTO(struct page *page, int type),
 666
 667         TP_ARGS(page, type)
 668 );
 669
 670 DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
 671
 672         TP_PROTO(struct page *page, int type),
 673
 674         TP_ARGS(page, type)
 675 );
 676
 677 TRACE_EVENT(f2fs_submit_write_page,
 678
 679         TP_PROTO(struct page *page, block_t blk_addr, int type),
 680
 681         TP_ARGS(page, blk_addr, type),
 682
 683         TP_STRUCT__entry(
 684                 __field(dev_t,  dev)
 685                 __field(ino_t,  ino)
 686                 __field(int, type)
 687                 __field(pgoff_t, index)
 688                 __field(block_t, block)
 689         ),
 690
 691         TP_fast_assign(
 692                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 693                 __entry->ino    = page->mapping->host->i_ino;
 694                 __entry->type   = type;
 695                 __entry->index  = page->index;
 696                 __entry->block  = blk_addr;
 697         ),
 698
 699         TP_printk("dev = (%d,%d), ino = %lu, %s, index = %lu, blkaddr = 0x%llx",
 700                 show_dev_ino(__entry),
 701                 show_block_type(__entry->type),
 702                 (unsigned long)__entry->index,
 703                 (unsigned long long)__entry->block)
 704 );
 705
 706 TRACE_EVENT(f2fs_write_checkpoint,
 707
 708         TP_PROTO(struct super_block *sb, bool is_umount, char *msg),
 709
 710         TP_ARGS(sb, is_umount, msg),
 711
 712         TP_STRUCT__entry(
 713                 __field(dev_t,  dev)
 714                 __field(bool,   is_umount)
 715                 __field(char *, msg)
 716         ),
 717
 718         TP_fast_assign(
 719                 __entry->dev            = sb->s_dev;
 720                 __entry->is_umount      = is_umount;
 721                 __entry->msg            = msg;
 722         ),
 723
 724         TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
 725                 show_dev(__entry),
 726                 __entry->is_umount ? "clean umount" : "consistency",
 727                 __entry->msg)
 728 );
 729
 730 #endif /* _TRACE_F2FS_H */
 731
 732  /* This part must be outside protection */
 733 #include <trace/define_trace.h>