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 #define show_bio_type(type)                                             \
  12         __print_symbolic(type,                                          \
  13                 { READ,         "READ" },                               \
  14                 { READA,        "READAHEAD" },                          \
  15                 { READ_SYNC,    "READ_SYNC" },                          \
  16                 { WRITE,        "WRITE" },                              \
  17                 { WRITE_SYNC,   "WRITE_SYNC" },                         \
  18                 { WRITE_FLUSH,  "WRITE_FLUSH" },                        \
  19                 { WRITE_FUA,    "WRITE_FUA" })
  20
  21 #define show_data_type(type)                                            \
  22         __print_symbolic(type,                                          \
  23                 { CURSEG_HOT_DATA,      "Hot DATA" },                   \
  24                 { CURSEG_WARM_DATA,     "Warm DATA" },                  \
  25                 { CURSEG_COLD_DATA,     "Cold DATA" },                  \
  26                 { CURSEG_HOT_NODE,      "Hot NODE" },                   \
  27                 { CURSEG_WARM_NODE,     "Warm NODE" },                  \
  28                 { CURSEG_COLD_NODE,     "Cold NODE" },                  \
  29                 { NO_CHECK_TYPE,        "No TYPE" })
  30
  31 #define show_gc_type(type)                                              \
  32         __print_symbolic(type,                                          \
  33                 { FG_GC,        "Foreground GC" },                      \
  34                 { BG_GC,        "Background GC" })
  35
  36 #define show_alloc_mode(type)                                           \
  37         __print_symbolic(type,                                          \
  38                 { LFS,  "LFS-mode" },                                   \
  39                 { SSR,  "SSR-mode" })
  40
  41 #define show_victim_policy(type)                                        \
  42         __print_symbolic(type,                                          \
  43                 { GC_GREEDY,    "Greedy" },                             \
  44                 { GC_CB,        "Cost-Benefit" })
  45
  46 struct victim_sel_policy;
  47
  48 DECLARE_EVENT_CLASS(f2fs__inode,
  49
  50         TP_PROTO(struct inode *inode),
  51
  52         TP_ARGS(inode),
  53
  54         TP_STRUCT__entry(
  55                 __field(dev_t,  dev)
  56                 __field(ino_t,  ino)
  57                 __field(ino_t,  pino)
  58                 __field(umode_t, mode)
  59                 __field(loff_t, size)
  60                 __field(unsigned int, nlink)
  61                 __field(blkcnt_t, blocks)
  62                 __field(__u8,   advise)
  63         ),
  64
  65         TP_fast_assign(
  66                 __entry->dev    = inode->i_sb->s_dev;
  67                 __entry->ino    = inode->i_ino;
  68                 __entry->pino   = F2FS_I(inode)->i_pino;
  69                 __entry->mode   = inode->i_mode;
  70                 __entry->nlink  = inode->i_nlink;
  71                 __entry->size   = inode->i_size;
  72                 __entry->blocks = inode->i_blocks;
  73                 __entry->advise = F2FS_I(inode)->i_advise;
  74         ),
  75
  76         TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
  77                 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
  78                 show_dev_ino(__entry),
  79                 (unsigned long)__entry->pino,
  80                 __entry->mode,
  81                 __entry->size,
  82                 (unsigned int)__entry->nlink,
  83                 (unsigned long long)__entry->blocks,
  84                 (unsigned char)__entry->advise)
  85 );
  86
  87 DECLARE_EVENT_CLASS(f2fs__inode_exit,
  88
  89         TP_PROTO(struct inode *inode, int ret),
  90
  91         TP_ARGS(inode, ret),
  92
  93         TP_STRUCT__entry(
  94                 __field(dev_t,  dev)
  95                 __field(ino_t,  ino)
  96                 __field(int,    ret)
  97         ),
  98
  99         TP_fast_assign(
 100                 __entry->dev    = inode->i_sb->s_dev;
 101                 __entry->ino    = inode->i_ino;
 102                 __entry->ret    = ret;
 103         ),
 104
 105         TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
 106                 show_dev_ino(__entry),
 107                 __entry->ret)
 108 );
 109
 110 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
 111
 112         TP_PROTO(struct inode *inode),
 113
 114         TP_ARGS(inode)
 115 );
 116
 117 TRACE_EVENT(f2fs_sync_file_exit,
 118
 119         TP_PROTO(struct inode *inode, bool need_cp, int datasync, int ret),
 120
 121         TP_ARGS(inode, need_cp, datasync, ret),
 122
 123         TP_STRUCT__entry(
 124                 __field(dev_t,  dev)
 125                 __field(ino_t,  ino)
 126                 __field(bool,   need_cp)
 127                 __field(int,    datasync)
 128                 __field(int,    ret)
 129         ),
 130
 131         TP_fast_assign(
 132                 __entry->dev            = inode->i_sb->s_dev;
 133                 __entry->ino            = inode->i_ino;
 134                 __entry->need_cp        = need_cp;
 135                 __entry->datasync       = datasync;
 136                 __entry->ret            = ret;
 137         ),
 138
 139         TP_printk("dev = (%d,%d), ino = %lu, checkpoint is %s, "
 140                 "datasync = %d, ret = %d",
 141                 show_dev_ino(__entry),
 142                 __entry->need_cp ? "needed" : "not needed",
 143                 __entry->datasync,
 144                 __entry->ret)
 145 );
 146
 147 TRACE_EVENT(f2fs_sync_fs,
 148
 149         TP_PROTO(struct super_block *sb, int wait),
 150
 151         TP_ARGS(sb, wait),
 152
 153         TP_STRUCT__entry(
 154                 __field(dev_t,  dev)
 155                 __field(int,    dirty)
 156                 __field(int,    wait)
 157         ),
 158
 159         TP_fast_assign(
 160                 __entry->dev    = sb->s_dev;
 161                 __entry->dirty  = F2FS_SB(sb)->s_dirty;
 162                 __entry->wait   = wait;
 163         ),
 164
 165         TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
 166                 show_dev(__entry),
 167                 __entry->dirty ? "dirty" : "not dirty",
 168                 __entry->wait)
 169 );
 170
 171 DEFINE_EVENT(f2fs__inode, f2fs_iget,
 172
 173         TP_PROTO(struct inode *inode),
 174
 175         TP_ARGS(inode)
 176 );
 177
 178 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
 179
 180         TP_PROTO(struct inode *inode, int ret),
 181
 182         TP_ARGS(inode, ret)
 183 );
 184
 185 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
 186
 187         TP_PROTO(struct inode *inode),
 188
 189         TP_ARGS(inode)
 190 );
 191
 192 TRACE_EVENT(f2fs_unlink_enter,
 193
 194         TP_PROTO(struct inode *dir, struct dentry *dentry),
 195
 196         TP_ARGS(dir, dentry),
 197
 198         TP_STRUCT__entry(
 199                 __field(dev_t,  dev)
 200                 __field(ino_t,  ino)
 201                 __field(loff_t, size)
 202                 __field(blkcnt_t, blocks)
 203                 __field(const char *,   name)
 204         ),
 205
 206         TP_fast_assign(
 207                 __entry->dev    = dir->i_sb->s_dev;
 208                 __entry->ino    = dir->i_ino;
 209                 __entry->size   = dir->i_size;
 210                 __entry->blocks = dir->i_blocks;
 211                 __entry->name   = dentry->d_name.name;
 212         ),
 213
 214         TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
 215                 "i_blocks = %llu, name = %s",
 216                 show_dev_ino(__entry),
 217                 __entry->size,
 218                 (unsigned long long)__entry->blocks,
 219                 __entry->name)
 220 );
 221
 222 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
 223
 224         TP_PROTO(struct inode *inode, int ret),
 225
 226         TP_ARGS(inode, ret)
 227 );
 228
 229 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
 230
 231         TP_PROTO(struct inode *inode),
 232
 233         TP_ARGS(inode)
 234 );
 235
 236 TRACE_EVENT(f2fs_truncate_data_blocks_range,
 237
 238         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
 239
 240         TP_ARGS(inode, nid,  ofs, free),
 241
 242         TP_STRUCT__entry(
 243                 __field(dev_t,  dev)
 244                 __field(ino_t,  ino)
 245                 __field(nid_t,  nid)
 246                 __field(unsigned int,   ofs)
 247                 __field(int,    free)
 248         ),
 249
 250         TP_fast_assign(
 251                 __entry->dev    = inode->i_sb->s_dev;
 252                 __entry->ino    = inode->i_ino;
 253                 __entry->nid    = nid;
 254                 __entry->ofs    = ofs;
 255                 __entry->free   = free;
 256         ),
 257
 258         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
 259                 show_dev_ino(__entry),
 260                 (unsigned int)__entry->nid,
 261                 __entry->ofs,
 262                 __entry->free)
 263 );
 264
 265 DECLARE_EVENT_CLASS(f2fs__truncate_op,
 266
 267         TP_PROTO(struct inode *inode, u64 from),
 268
 269         TP_ARGS(inode, from),
 270
 271         TP_STRUCT__entry(
 272                 __field(dev_t,  dev)
 273                 __field(ino_t,  ino)
 274                 __field(loff_t, size)
 275                 __field(blkcnt_t, blocks)
 276                 __field(u64,    from)
 277         ),
 278
 279         TP_fast_assign(
 280                 __entry->dev    = inode->i_sb->s_dev;
 281                 __entry->ino    = inode->i_ino;
 282                 __entry->size   = inode->i_size;
 283                 __entry->blocks = inode->i_blocks;
 284                 __entry->from   = from;
 285         ),
 286
 287         TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
 288                 "start file offset = %llu",
 289                 show_dev_ino(__entry),
 290                 __entry->size,
 291                 (unsigned long long)__entry->blocks,
 292                 (unsigned long long)__entry->from)
 293 );
 294
 295 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
 296
 297         TP_PROTO(struct inode *inode, u64 from),
 298
 299         TP_ARGS(inode, from)
 300 );
 301
 302 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
 303
 304         TP_PROTO(struct inode *inode, int ret),
 305
 306         TP_ARGS(inode, ret)
 307 );
 308
 309 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
 310
 311         TP_PROTO(struct inode *inode, u64 from),
 312
 313         TP_ARGS(inode, from)
 314 );
 315
 316 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
 317
 318         TP_PROTO(struct inode *inode, int ret),
 319
 320         TP_ARGS(inode, ret)
 321 );
 322
 323 DECLARE_EVENT_CLASS(f2fs__truncate_node,
 324
 325         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 326
 327         TP_ARGS(inode, nid, blk_addr),
 328
 329         TP_STRUCT__entry(
 330                 __field(dev_t,  dev)
 331                 __field(ino_t,  ino)
 332                 __field(nid_t,  nid)
 333                 __field(block_t,        blk_addr)
 334         ),
 335
 336         TP_fast_assign(
 337                 __entry->dev            = inode->i_sb->s_dev;
 338                 __entry->ino            = inode->i_ino;
 339                 __entry->nid            = nid;
 340                 __entry->blk_addr       = blk_addr;
 341         ),
 342
 343         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
 344                 show_dev_ino(__entry),
 345                 (unsigned int)__entry->nid,
 346                 (unsigned long long)__entry->blk_addr)
 347 );
 348
 349 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
 350
 351         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 352
 353         TP_ARGS(inode, nid, blk_addr)
 354 );
 355
 356 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
 357
 358         TP_PROTO(struct inode *inode, int ret),
 359
 360         TP_ARGS(inode, ret)
 361 );
 362
 363 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
 364
 365         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 366
 367         TP_ARGS(inode, nid, blk_addr)
 368 );
 369
 370 TRACE_EVENT(f2fs_truncate_partial_nodes,
 371
 372         TP_PROTO(struct inode *inode, nid_t nid[], int depth, int err),
 373
 374         TP_ARGS(inode, nid, depth, err),
 375
 376         TP_STRUCT__entry(
 377                 __field(dev_t,  dev)
 378                 __field(ino_t,  ino)
 379                 __field(nid_t,  nid[3])
 380                 __field(int,    depth)
 381                 __field(int,    err)
 382         ),
 383
 384         TP_fast_assign(
 385                 __entry->dev    = inode->i_sb->s_dev;
 386                 __entry->ino    = inode->i_ino;
 387                 __entry->nid[0] = nid[0];
 388                 __entry->nid[1] = nid[1];
 389                 __entry->nid[2] = nid[2];
 390                 __entry->depth  = depth;
 391                 __entry->err    = err;
 392         ),
 393
 394         TP_printk("dev = (%d,%d), ino = %lu, "
 395                 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
 396                 show_dev_ino(__entry),
 397                 (unsigned int)__entry->nid[0],
 398                 (unsigned int)__entry->nid[1],
 399                 (unsigned int)__entry->nid[2],
 400                 __entry->depth,
 401                 __entry->err)
 402 );
 403
 404 TRACE_EVENT_CONDITION(f2fs_readpage,
 405
 406         TP_PROTO(struct page *page, sector_t blkaddr, int type),
 407
 408         TP_ARGS(page, blkaddr, type),
 409
 410         TP_CONDITION(page->mapping),
 411
 412         TP_STRUCT__entry(
 413                 __field(dev_t,  dev)
 414                 __field(ino_t,  ino)
 415                 __field(pgoff_t,        index)
 416                 __field(sector_t,       blkaddr)
 417                 __field(int,    type)
 418         ),
 419
 420         TP_fast_assign(
 421                 __entry->dev            = page->mapping->host->i_sb->s_dev;
 422                 __entry->ino            = page->mapping->host->i_ino;
 423                 __entry->index          = page->index;
 424                 __entry->blkaddr        = blkaddr;
 425                 __entry->type           = type;
 426         ),
 427
 428         TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
 429                 "blkaddr = 0x%llx, bio_type = %s",
 430                 show_dev_ino(__entry),
 431                 (unsigned long)__entry->index,
 432                 (unsigned long long)__entry->blkaddr,
 433                 show_bio_type(__entry->type))
 434 );
 435
 436 TRACE_EVENT(f2fs_get_data_block,
 437         TP_PROTO(struct inode *inode, sector_t iblock,
 438                                 struct buffer_head *bh, int ret),
 439
 440         TP_ARGS(inode, iblock, bh, ret),
 441
 442         TP_STRUCT__entry(
 443                 __field(dev_t,  dev)
 444                 __field(ino_t,  ino)
 445                 __field(sector_t,       iblock)
 446                 __field(sector_t,       bh_start)
 447                 __field(size_t, bh_size)
 448                 __field(int,    ret)
 449         ),
 450
 451         TP_fast_assign(
 452                 __entry->dev            = inode->i_sb->s_dev;
 453                 __entry->ino            = inode->i_ino;
 454                 __entry->iblock         = iblock;
 455                 __entry->bh_start       = bh->b_blocknr;
 456                 __entry->bh_size        = bh->b_size;
 457                 __entry->ret            = ret;
 458         ),
 459
 460         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
 461                 "start blkaddr = 0x%llx, len = 0x%llx bytes, err = %d",
 462                 show_dev_ino(__entry),
 463                 (unsigned long long)__entry->iblock,
 464                 (unsigned long long)__entry->bh_start,
 465                 (unsigned long long)__entry->bh_size,
 466                 __entry->ret)
 467 );
 468
 469 TRACE_EVENT(f2fs_get_victim,
 470
 471         TP_PROTO(struct super_block *sb, int type, int gc_type,
 472                         struct victim_sel_policy *p, unsigned int pre_victim,
 473                         unsigned int prefree, unsigned int free),
 474
 475         TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
 476
 477         TP_STRUCT__entry(
 478                 __field(dev_t,  dev)
 479                 __field(int,    type)
 480                 __field(int,    gc_type)
 481                 __field(int,    alloc_mode)
 482                 __field(int,    gc_mode)
 483                 __field(unsigned int,   victim)
 484                 __field(unsigned int,   ofs_unit)
 485                 __field(unsigned int,   pre_victim)
 486                 __field(unsigned int,   prefree)
 487                 __field(unsigned int,   free)
 488         ),
 489
 490         TP_fast_assign(
 491                 __entry->dev            = sb->s_dev;
 492                 __entry->type           = type;
 493                 __entry->gc_type        = gc_type;
 494                 __entry->alloc_mode     = p->alloc_mode;
 495                 __entry->gc_mode        = p->gc_mode;
 496                 __entry->victim         = p->min_segno;
 497                 __entry->ofs_unit       = p->ofs_unit;
 498                 __entry->pre_victim     = pre_victim;
 499                 __entry->prefree        = prefree;
 500                 __entry->free           = free;
 501         ),
 502
 503         TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), victim = %u "
 504                 "ofs_unit = %u, pre_victim_secno = %d, prefree = %u, free = %u",
 505                 show_dev(__entry),
 506                 show_data_type(__entry->type),
 507                 show_gc_type(__entry->gc_type),
 508                 show_alloc_mode(__entry->alloc_mode),
 509                 show_victim_policy(__entry->gc_mode),
 510                 __entry->victim,
 511                 __entry->ofs_unit,
 512                 (int)__entry->pre_victim,
 513                 __entry->prefree,
 514                 __entry->free)
 515 );
 516
 517 #endif /* _TRACE_F2FS_H */
 518
 519  /* This part must be outside protection */
 520 #include <trace/define_trace.h>