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