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