LCOV - code coverage report
Current view: top level - include/trace/events - ext4.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 54 121 44.6 %
Date: 2022-03-28 15:32:58 Functions: 54 345 15.7 %
Branches: 54 930 5.8 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #undef TRACE_SYSTEM
       3                 :            : #define TRACE_SYSTEM ext4
       4                 :            : 
       5                 :            : #if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
       6                 :            : #define _TRACE_EXT4_H
       7                 :            : 
       8                 :            : #include <linux/writeback.h>
       9                 :            : #include <linux/tracepoint.h>
      10                 :            : 
      11                 :            : struct ext4_allocation_context;
      12                 :            : struct ext4_allocation_request;
      13                 :            : struct ext4_extent;
      14                 :            : struct ext4_prealloc_space;
      15                 :            : struct ext4_inode_info;
      16                 :            : struct mpage_da_data;
      17                 :            : struct ext4_map_blocks;
      18                 :            : struct extent_status;
      19                 :            : struct ext4_fsmap;
      20                 :            : struct partial_cluster;
      21                 :            : 
      22                 :            : #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
      23                 :            : 
      24                 :            : #define show_mballoc_flags(flags) __print_flags(flags, "|",   \
      25                 :            :         { EXT4_MB_HINT_MERGE,           "HINT_MERGE" },               \
      26                 :            :         { EXT4_MB_HINT_RESERVED,        "HINT_RESV" },                \
      27                 :            :         { EXT4_MB_HINT_METADATA,        "HINT_MDATA" },               \
      28                 :            :         { EXT4_MB_HINT_FIRST,           "HINT_FIRST" },               \
      29                 :            :         { EXT4_MB_HINT_BEST,            "HINT_BEST" },                \
      30                 :            :         { EXT4_MB_HINT_DATA,            "HINT_DATA" },                \
      31                 :            :         { EXT4_MB_HINT_NOPREALLOC,      "HINT_NOPREALLOC" },  \
      32                 :            :         { EXT4_MB_HINT_GROUP_ALLOC,     "HINT_GRP_ALLOC" },   \
      33                 :            :         { EXT4_MB_HINT_GOAL_ONLY,       "HINT_GOAL_ONLY" },   \
      34                 :            :         { EXT4_MB_HINT_TRY_GOAL,        "HINT_TRY_GOAL" },    \
      35                 :            :         { EXT4_MB_DELALLOC_RESERVED,    "DELALLOC_RESV" },    \
      36                 :            :         { EXT4_MB_STREAM_ALLOC,         "STREAM_ALLOC" },     \
      37                 :            :         { EXT4_MB_USE_ROOT_BLOCKS,      "USE_ROOT_BLKS" },    \
      38                 :            :         { EXT4_MB_USE_RESERVED,         "USE_RESV" })
      39                 :            : 
      40                 :            : #define show_map_flags(flags) __print_flags(flags, "|",                       \
      41                 :            :         { EXT4_GET_BLOCKS_CREATE,               "CREATE" },           \
      42                 :            :         { EXT4_GET_BLOCKS_UNWRIT_EXT,           "UNWRIT" },           \
      43                 :            :         { EXT4_GET_BLOCKS_DELALLOC_RESERVE,     "DELALLOC" },         \
      44                 :            :         { EXT4_GET_BLOCKS_PRE_IO,               "PRE_IO" },           \
      45                 :            :         { EXT4_GET_BLOCKS_CONVERT,              "CONVERT" },          \
      46                 :            :         { EXT4_GET_BLOCKS_METADATA_NOFAIL,      "METADATA_NOFAIL" },  \
      47                 :            :         { EXT4_GET_BLOCKS_NO_NORMALIZE,         "NO_NORMALIZE" },     \
      48                 :            :         { EXT4_GET_BLOCKS_KEEP_SIZE,            "KEEP_SIZE" },                \
      49                 :            :         { EXT4_GET_BLOCKS_ZERO,                 "ZERO" })
      50                 :            : 
      51                 :            : /*
      52                 :            :  * __print_flags() requires that all enum values be wrapped in the
      53                 :            :  * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
      54                 :            :  * ring buffer.
      55                 :            :  */
      56                 :            : TRACE_DEFINE_ENUM(BH_New);
      57                 :            : TRACE_DEFINE_ENUM(BH_Mapped);
      58                 :            : TRACE_DEFINE_ENUM(BH_Unwritten);
      59                 :            : TRACE_DEFINE_ENUM(BH_Boundary);
      60                 :            : 
      61                 :            : #define show_mflags(flags) __print_flags(flags, "",   \
      62                 :            :         { EXT4_MAP_NEW,         "N" },                        \
      63                 :            :         { EXT4_MAP_MAPPED,      "M" },                        \
      64                 :            :         { EXT4_MAP_UNWRITTEN,   "U" },                        \
      65                 :            :         { EXT4_MAP_BOUNDARY,    "B" })
      66                 :            : 
      67                 :            : #define show_free_flags(flags) __print_flags(flags, "|",      \
      68                 :            :         { EXT4_FREE_BLOCKS_METADATA,            "METADATA" }, \
      69                 :            :         { EXT4_FREE_BLOCKS_FORGET,              "FORGET" },   \
      70                 :            :         { EXT4_FREE_BLOCKS_VALIDATED,           "VALIDATED" },        \
      71                 :            :         { EXT4_FREE_BLOCKS_NO_QUOT_UPDATE,      "NO_QUOTA" }, \
      72                 :            :         { EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER,"1ST_CLUSTER" },\
      73                 :            :         { EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER, "LAST_CLUSTER" })
      74                 :            : 
      75                 :            : TRACE_DEFINE_ENUM(ES_WRITTEN_B);
      76                 :            : TRACE_DEFINE_ENUM(ES_UNWRITTEN_B);
      77                 :            : TRACE_DEFINE_ENUM(ES_DELAYED_B);
      78                 :            : TRACE_DEFINE_ENUM(ES_HOLE_B);
      79                 :            : TRACE_DEFINE_ENUM(ES_REFERENCED_B);
      80                 :            : 
      81                 :            : #define show_extent_status(status) __print_flags(status, "",  \
      82                 :            :         { EXTENT_STATUS_WRITTEN,        "W" },                        \
      83                 :            :         { EXTENT_STATUS_UNWRITTEN,      "U" },                        \
      84                 :            :         { EXTENT_STATUS_DELAYED,        "D" },                        \
      85                 :            :         { EXTENT_STATUS_HOLE,           "H" },                        \
      86                 :            :         { EXTENT_STATUS_REFERENCED,     "R" })
      87                 :            : 
      88                 :            : #define show_falloc_mode(mode) __print_flags(mode, "|",               \
      89                 :            :         { FALLOC_FL_KEEP_SIZE,          "KEEP_SIZE"},         \
      90                 :            :         { FALLOC_FL_PUNCH_HOLE,         "PUNCH_HOLE"},                \
      91                 :            :         { FALLOC_FL_NO_HIDE_STALE,      "NO_HIDE_STALE"},     \
      92                 :            :         { FALLOC_FL_COLLAPSE_RANGE,     "COLLAPSE_RANGE"},    \
      93                 :            :         { FALLOC_FL_ZERO_RANGE,         "ZERO_RANGE"})
      94                 :            : 
      95                 :            : 
      96   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_other_inode_update_time,
             #  #  #  # ]
      97                 :            :         TP_PROTO(struct inode *inode, ino_t orig_ino),
      98                 :            : 
      99                 :            :         TP_ARGS(inode, orig_ino),
     100                 :            : 
     101                 :            :         TP_STRUCT__entry(
     102                 :            :                 __field(        dev_t,  dev                     )
     103                 :            :                 __field(        ino_t,  ino                     )
     104                 :            :                 __field(        ino_t,  orig_ino                )
     105                 :            :                 __field(        uid_t,  uid                     )
     106                 :            :                 __field(        gid_t,  gid                     )
     107                 :            :                 __field(        __u16, mode                     )
     108                 :            :         ),
     109                 :            : 
     110                 :            :         TP_fast_assign(
     111                 :            :                 __entry->orig_ino = orig_ino;
     112                 :            :                 __entry->dev = inode->i_sb->s_dev;
     113                 :            :                 __entry->ino = inode->i_ino;
     114                 :            :                 __entry->uid = i_uid_read(inode);
     115                 :            :                 __entry->gid = i_gid_read(inode);
     116                 :            :                 __entry->mode        = inode->i_mode;
     117                 :            :         ),
     118                 :            : 
     119                 :            :         TP_printk("dev %d,%d orig_ino %lu ino %lu mode 0%o uid %u gid %u",
     120                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     121                 :            :                   (unsigned long) __entry->orig_ino,
     122                 :            :                   (unsigned long) __entry->ino, __entry->mode,
     123                 :            :                   __entry->uid, __entry->gid)
     124                 :            : );
     125                 :            : 
     126   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_free_inode,
             -  -  -  - ]
     127                 :            :         TP_PROTO(struct inode *inode),
     128                 :            : 
     129                 :            :         TP_ARGS(inode),
     130                 :            : 
     131                 :            :         TP_STRUCT__entry(
     132                 :            :                 __field(        dev_t,  dev                     )
     133                 :            :                 __field(        ino_t,  ino                     )
     134                 :            :                 __field(        uid_t,  uid                     )
     135                 :            :                 __field(        gid_t,  gid                     )
     136                 :            :                 __field(        __u64, blocks                   )
     137                 :            :                 __field(        __u16, mode                     )
     138                 :            :         ),
     139                 :            : 
     140                 :            :         TP_fast_assign(
     141                 :            :                 __entry->dev = inode->i_sb->s_dev;
     142                 :            :                 __entry->ino = inode->i_ino;
     143                 :            :                 __entry->uid = i_uid_read(inode);
     144                 :            :                 __entry->gid = i_gid_read(inode);
     145                 :            :                 __entry->blocks      = inode->i_blocks;
     146                 :            :                 __entry->mode        = inode->i_mode;
     147                 :            :         ),
     148                 :            : 
     149                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
     150                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     151                 :            :                   (unsigned long) __entry->ino, __entry->mode,
     152                 :            :                   __entry->uid, __entry->gid, __entry->blocks)
     153                 :            : );
     154                 :            : 
     155   [ -  +  -  -  :      19292 : TRACE_EVENT(ext4_request_inode,
             -  -  -  - ]
     156                 :            :         TP_PROTO(struct inode *dir, int mode),
     157                 :            : 
     158                 :            :         TP_ARGS(dir, mode),
     159                 :            : 
     160                 :            :         TP_STRUCT__entry(
     161                 :            :                 __field(        dev_t,  dev                     )
     162                 :            :                 __field(        ino_t,  dir                     )
     163                 :            :                 __field(        __u16, mode                     )
     164                 :            :         ),
     165                 :            : 
     166                 :            :         TP_fast_assign(
     167                 :            :                 __entry->dev = dir->i_sb->s_dev;
     168                 :            :                 __entry->dir = dir->i_ino;
     169                 :            :                 __entry->mode        = mode;
     170                 :            :         ),
     171                 :            : 
     172                 :            :         TP_printk("dev %d,%d dir %lu mode 0%o",
     173                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     174                 :            :                   (unsigned long) __entry->dir, __entry->mode)
     175                 :            : );
     176                 :            : 
     177   [ -  +  -  -  :      19292 : TRACE_EVENT(ext4_allocate_inode,
             -  -  -  - ]
     178                 :            :         TP_PROTO(struct inode *inode, struct inode *dir, int mode),
     179                 :            : 
     180                 :            :         TP_ARGS(inode, dir, mode),
     181                 :            : 
     182                 :            :         TP_STRUCT__entry(
     183                 :            :                 __field(        dev_t,  dev                     )
     184                 :            :                 __field(        ino_t,  ino                     )
     185                 :            :                 __field(        ino_t,  dir                     )
     186                 :            :                 __field(        __u16,  mode                    )
     187                 :            :         ),
     188                 :            : 
     189                 :            :         TP_fast_assign(
     190                 :            :                 __entry->dev = inode->i_sb->s_dev;
     191                 :            :                 __entry->ino = inode->i_ino;
     192                 :            :                 __entry->dir = dir->i_ino;
     193                 :            :                 __entry->mode        = mode;
     194                 :            :         ),
     195                 :            : 
     196                 :            :         TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
     197                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     198                 :            :                   (unsigned long) __entry->ino,
     199                 :            :                   (unsigned long) __entry->dir, __entry->mode)
     200                 :            : );
     201                 :            : 
     202   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_evict_inode,
             -  -  -  - ]
     203                 :            :         TP_PROTO(struct inode *inode),
     204                 :            : 
     205                 :            :         TP_ARGS(inode),
     206                 :            : 
     207                 :            :         TP_STRUCT__entry(
     208                 :            :                 __field(        dev_t,  dev                     )
     209                 :            :                 __field(        ino_t,  ino                     )
     210                 :            :                 __field(        int,    nlink                   )
     211                 :            :         ),
     212                 :            : 
     213                 :            :         TP_fast_assign(
     214                 :            :                 __entry->dev = inode->i_sb->s_dev;
     215                 :            :                 __entry->ino = inode->i_ino;
     216                 :            :                 __entry->nlink       = inode->i_nlink;
     217                 :            :         ),
     218                 :            : 
     219                 :            :         TP_printk("dev %d,%d ino %lu nlink %d",
     220                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     221                 :            :                   (unsigned long) __entry->ino, __entry->nlink)
     222                 :            : );
     223                 :            : 
     224   [ -  +  -  -  :       7865 : TRACE_EVENT(ext4_drop_inode,
             -  -  -  - ]
     225                 :            :         TP_PROTO(struct inode *inode, int drop),
     226                 :            : 
     227                 :            :         TP_ARGS(inode, drop),
     228                 :            : 
     229                 :            :         TP_STRUCT__entry(
     230                 :            :                 __field(        dev_t,  dev                     )
     231                 :            :                 __field(        ino_t,  ino                     )
     232                 :            :                 __field(        int,    drop                    )
     233                 :            :         ),
     234                 :            : 
     235                 :            :         TP_fast_assign(
     236                 :            :                 __entry->dev = inode->i_sb->s_dev;
     237                 :            :                 __entry->ino = inode->i_ino;
     238                 :            :                 __entry->drop        = drop;
     239                 :            :         ),
     240                 :            : 
     241                 :            :         TP_printk("dev %d,%d ino %lu drop %d",
     242                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     243                 :            :                   (unsigned long) __entry->ino, __entry->drop)
     244                 :            : );
     245                 :            : 
     246   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_nfs_commit_metadata,
             #  #  #  # ]
     247                 :            :         TP_PROTO(struct inode *inode),
     248                 :            : 
     249                 :            :         TP_ARGS(inode),
     250                 :            : 
     251                 :            :         TP_STRUCT__entry(
     252                 :            :                 __field(        dev_t,  dev                     )
     253                 :            :                 __field(        ino_t,  ino                     )
     254                 :            :         ),
     255                 :            : 
     256                 :            :         TP_fast_assign(
     257                 :            :                 __entry->dev = inode->i_sb->s_dev;
     258                 :            :                 __entry->ino = inode->i_ino;
     259                 :            :         ),
     260                 :            : 
     261                 :            :         TP_printk("dev %d,%d ino %lu",
     262                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     263                 :            :                   (unsigned long) __entry->ino)
     264                 :            : );
     265                 :            : 
     266   [ -  +  -  -  :     149576 : TRACE_EVENT(ext4_mark_inode_dirty,
             -  -  -  - ]
     267                 :            :         TP_PROTO(struct inode *inode, unsigned long IP),
     268                 :            : 
     269                 :            :         TP_ARGS(inode, IP),
     270                 :            : 
     271                 :            :         TP_STRUCT__entry(
     272                 :            :                 __field(        dev_t,  dev                     )
     273                 :            :                 __field(        ino_t,  ino                     )
     274                 :            :                 __field(unsigned long,  ip                      )
     275                 :            :         ),
     276                 :            : 
     277                 :            :         TP_fast_assign(
     278                 :            :                 __entry->dev = inode->i_sb->s_dev;
     279                 :            :                 __entry->ino = inode->i_ino;
     280                 :            :                 __entry->ip  = IP;
     281                 :            :         ),
     282                 :            : 
     283                 :            :         TP_printk("dev %d,%d ino %lu caller %pS",
     284                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     285                 :            :                   (unsigned long) __entry->ino, (void *)__entry->ip)
     286                 :            : );
     287                 :            : 
     288   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_begin_ordered_truncate,
             -  -  -  - ]
     289                 :            :         TP_PROTO(struct inode *inode, loff_t new_size),
     290                 :            : 
     291                 :            :         TP_ARGS(inode, new_size),
     292                 :            : 
     293                 :            :         TP_STRUCT__entry(
     294                 :            :                 __field(        dev_t,  dev                     )
     295                 :            :                 __field(        ino_t,  ino                     )
     296                 :            :                 __field(        loff_t, new_size                )
     297                 :            :         ),
     298                 :            : 
     299                 :            :         TP_fast_assign(
     300                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     301                 :            :                 __entry->ino         = inode->i_ino;
     302                 :            :                 __entry->new_size    = new_size;
     303                 :            :         ),
     304                 :            : 
     305                 :            :         TP_printk("dev %d,%d ino %lu new_size %lld",
     306                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     307                 :            :                   (unsigned long) __entry->ino,
     308                 :            :                   __entry->new_size)
     309                 :            : );
     310                 :            : 
     311   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__write_begin,
                   #  # ]
     312                 :            : 
     313                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     314                 :            :                  unsigned int flags),
     315                 :            : 
     316                 :            :         TP_ARGS(inode, pos, len, flags),
     317                 :            : 
     318                 :            :         TP_STRUCT__entry(
     319                 :            :                 __field(        dev_t,  dev                     )
     320                 :            :                 __field(        ino_t,  ino                     )
     321                 :            :                 __field(        loff_t, pos                     )
     322                 :            :                 __field(        unsigned int, len               )
     323                 :            :                 __field(        unsigned int, flags             )
     324                 :            :         ),
     325                 :            : 
     326                 :            :         TP_fast_assign(
     327                 :            :                 __entry->dev = inode->i_sb->s_dev;
     328                 :            :                 __entry->ino = inode->i_ino;
     329                 :            :                 __entry->pos = pos;
     330                 :            :                 __entry->len = len;
     331                 :            :                 __entry->flags       = flags;
     332                 :            :         ),
     333                 :            : 
     334                 :            :         TP_printk("dev %d,%d ino %lu pos %lld len %u flags %u",
     335                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     336                 :            :                   (unsigned long) __entry->ino,
     337                 :            :                   __entry->pos, __entry->len, __entry->flags)
     338                 :            : );
     339                 :            : 
     340   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
             #  #  #  # ]
     341                 :            : 
     342                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     343                 :            :                  unsigned int flags),
     344                 :            : 
     345                 :            :         TP_ARGS(inode, pos, len, flags)
     346                 :            : );
     347                 :            : 
     348   [ -  +  -  -  :      26495 : DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
             -  -  -  - ]
     349                 :            : 
     350                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     351                 :            :                  unsigned int flags),
     352                 :            : 
     353                 :            :         TP_ARGS(inode, pos, len, flags)
     354                 :            : );
     355                 :            : 
     356   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__write_end,
                   #  # ]
     357                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     358                 :            :                         unsigned int copied),
     359                 :            : 
     360                 :            :         TP_ARGS(inode, pos, len, copied),
     361                 :            : 
     362                 :            :         TP_STRUCT__entry(
     363                 :            :                 __field(        dev_t,  dev                     )
     364                 :            :                 __field(        ino_t,  ino                     )
     365                 :            :                 __field(        loff_t, pos                     )
     366                 :            :                 __field(        unsigned int, len               )
     367                 :            :                 __field(        unsigned int, copied            )
     368                 :            :         ),
     369                 :            : 
     370                 :            :         TP_fast_assign(
     371                 :            :                 __entry->dev = inode->i_sb->s_dev;
     372                 :            :                 __entry->ino = inode->i_ino;
     373                 :            :                 __entry->pos = pos;
     374                 :            :                 __entry->len = len;
     375                 :            :                 __entry->copied      = copied;
     376                 :            :         ),
     377                 :            : 
     378                 :            :         TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
     379                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     380                 :            :                   (unsigned long) __entry->ino,
     381                 :            :                   __entry->pos, __entry->len, __entry->copied)
     382                 :            : );
     383                 :            : 
     384   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__write_end, ext4_write_end,
             #  #  #  # ]
     385                 :            : 
     386                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     387                 :            :                  unsigned int copied),
     388                 :            : 
     389                 :            :         TP_ARGS(inode, pos, len, copied)
     390                 :            : );
     391                 :            : 
     392   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
             #  #  #  # ]
     393                 :            : 
     394                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     395                 :            :                  unsigned int copied),
     396                 :            : 
     397                 :            :         TP_ARGS(inode, pos, len, copied)
     398                 :            : );
     399                 :            : 
     400   [ -  +  -  -  :      26495 : DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
             -  -  -  - ]
     401                 :            : 
     402                 :            :         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
     403                 :            :                  unsigned int copied),
     404                 :            : 
     405                 :            :         TP_ARGS(inode, pos, len, copied)
     406                 :            : );
     407                 :            : 
     408   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_writepages,
             -  -  -  - ]
     409                 :            :         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
     410                 :            : 
     411                 :            :         TP_ARGS(inode, wbc),
     412                 :            : 
     413                 :            :         TP_STRUCT__entry(
     414                 :            :                 __field(        dev_t,  dev                     )
     415                 :            :                 __field(        ino_t,  ino                     )
     416                 :            :                 __field(        long,   nr_to_write             )
     417                 :            :                 __field(        long,   pages_skipped           )
     418                 :            :                 __field(        loff_t, range_start             )
     419                 :            :                 __field(        loff_t, range_end               )
     420                 :            :                 __field(       pgoff_t, writeback_index         )
     421                 :            :                 __field(        int,    sync_mode               )
     422                 :            :                 __field(        char,   for_kupdate             )
     423                 :            :                 __field(        char,   range_cyclic            )
     424                 :            :         ),
     425                 :            : 
     426                 :            :         TP_fast_assign(
     427                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     428                 :            :                 __entry->ino         = inode->i_ino;
     429                 :            :                 __entry->nr_to_write = wbc->nr_to_write;
     430                 :            :                 __entry->pages_skipped       = wbc->pages_skipped;
     431                 :            :                 __entry->range_start = wbc->range_start;
     432                 :            :                 __entry->range_end   = wbc->range_end;
     433                 :            :                 __entry->writeback_index = inode->i_mapping->writeback_index;
     434                 :            :                 __entry->sync_mode   = wbc->sync_mode;
     435                 :            :                 __entry->for_kupdate = wbc->for_kupdate;
     436                 :            :                 __entry->range_cyclic        = wbc->range_cyclic;
     437                 :            :         ),
     438                 :            : 
     439                 :            :         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
     440                 :            :                   "range_start %lld range_end %lld sync_mode %d "
     441                 :            :                   "for_kupdate %d range_cyclic %d writeback_index %lu",
     442                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     443                 :            :                   (unsigned long) __entry->ino, __entry->nr_to_write,
     444                 :            :                   __entry->pages_skipped, __entry->range_start,
     445                 :            :                   __entry->range_end, __entry->sync_mode,
     446                 :            :                   __entry->for_kupdate, __entry->range_cyclic,
     447                 :            :                   (unsigned long) __entry->writeback_index)
     448                 :            : );
     449                 :            : 
     450   [ -  +  -  -  :        448 : TRACE_EVENT(ext4_da_write_pages,
             -  -  -  - ]
     451                 :            :         TP_PROTO(struct inode *inode, pgoff_t first_page,
     452                 :            :                  struct writeback_control *wbc),
     453                 :            : 
     454                 :            :         TP_ARGS(inode, first_page, wbc),
     455                 :            : 
     456                 :            :         TP_STRUCT__entry(
     457                 :            :                 __field(        dev_t,  dev                     )
     458                 :            :                 __field(        ino_t,  ino                     )
     459                 :            :                 __field(      pgoff_t,  first_page              )
     460                 :            :                 __field(         long,  nr_to_write             )
     461                 :            :                 __field(          int,  sync_mode               )
     462                 :            :         ),
     463                 :            : 
     464                 :            :         TP_fast_assign(
     465                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     466                 :            :                 __entry->ino         = inode->i_ino;
     467                 :            :                 __entry->first_page  = first_page;
     468                 :            :                 __entry->nr_to_write = wbc->nr_to_write;
     469                 :            :                 __entry->sync_mode   = wbc->sync_mode;
     470                 :            :         ),
     471                 :            : 
     472                 :            :         TP_printk("dev %d,%d ino %lu first_page %lu nr_to_write %ld "
     473                 :            :                   "sync_mode %d",
     474                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     475                 :            :                   (unsigned long) __entry->ino, __entry->first_page,
     476                 :            :                   __entry->nr_to_write, __entry->sync_mode)
     477                 :            : );
     478                 :            : 
     479   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_da_write_pages_extent,
             -  -  -  - ]
     480                 :            :         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
     481                 :            : 
     482                 :            :         TP_ARGS(inode, map),
     483                 :            : 
     484                 :            :         TP_STRUCT__entry(
     485                 :            :                 __field(        dev_t,  dev                     )
     486                 :            :                 __field(        ino_t,  ino                     )
     487                 :            :                 __field(        __u64,  lblk                    )
     488                 :            :                 __field(        __u32,  len                     )
     489                 :            :                 __field(        __u32,  flags                   )
     490                 :            :         ),
     491                 :            : 
     492                 :            :         TP_fast_assign(
     493                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     494                 :            :                 __entry->ino         = inode->i_ino;
     495                 :            :                 __entry->lblk                = map->m_lblk;
     496                 :            :                 __entry->len         = map->m_len;
     497                 :            :                 __entry->flags               = map->m_flags;
     498                 :            :         ),
     499                 :            : 
     500                 :            :         TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
     501                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     502                 :            :                   (unsigned long) __entry->ino, __entry->lblk, __entry->len,
     503                 :            :                   show_mflags(__entry->flags))
     504                 :            : );
     505                 :            : 
     506   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_writepages_result,
             -  -  -  - ]
     507                 :            :         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
     508                 :            :                         int ret, int pages_written),
     509                 :            : 
     510                 :            :         TP_ARGS(inode, wbc, ret, pages_written),
     511                 :            : 
     512                 :            :         TP_STRUCT__entry(
     513                 :            :                 __field(        dev_t,  dev                     )
     514                 :            :                 __field(        ino_t,  ino                     )
     515                 :            :                 __field(        int,    ret                     )
     516                 :            :                 __field(        int,    pages_written           )
     517                 :            :                 __field(        long,   pages_skipped           )
     518                 :            :                 __field(       pgoff_t, writeback_index         )
     519                 :            :                 __field(        int,    sync_mode               )
     520                 :            :         ),
     521                 :            : 
     522                 :            :         TP_fast_assign(
     523                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     524                 :            :                 __entry->ino         = inode->i_ino;
     525                 :            :                 __entry->ret         = ret;
     526                 :            :                 __entry->pages_written       = pages_written;
     527                 :            :                 __entry->pages_skipped       = wbc->pages_skipped;
     528                 :            :                 __entry->writeback_index = inode->i_mapping->writeback_index;
     529                 :            :                 __entry->sync_mode   = wbc->sync_mode;
     530                 :            :         ),
     531                 :            : 
     532                 :            :         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
     533                 :            :                   "sync_mode %d writeback_index %lu",
     534                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     535                 :            :                   (unsigned long) __entry->ino, __entry->ret,
     536                 :            :                   __entry->pages_written, __entry->pages_skipped,
     537                 :            :                   __entry->sync_mode,
     538                 :            :                   (unsigned long) __entry->writeback_index)
     539                 :            : );
     540                 :            : 
     541   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__page_op,
                   #  # ]
     542                 :            :         TP_PROTO(struct page *page),
     543                 :            : 
     544                 :            :         TP_ARGS(page),
     545                 :            : 
     546                 :            :         TP_STRUCT__entry(
     547                 :            :                 __field(        dev_t,  dev                     )
     548                 :            :                 __field(        ino_t,  ino                     )
     549                 :            :                 __field(        pgoff_t, index                  )
     550                 :            : 
     551                 :            :         ),
     552                 :            : 
     553                 :            :         TP_fast_assign(
     554                 :            :                 __entry->dev = page->mapping->host->i_sb->s_dev;
     555                 :            :                 __entry->ino = page->mapping->host->i_ino;
     556                 :            :                 __entry->index       = page->index;
     557                 :            :         ),
     558                 :            : 
     559                 :            :         TP_printk("dev %d,%d ino %lu page_index %lu",
     560                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     561                 :            :                   (unsigned long) __entry->ino,
     562                 :            :                   (unsigned long) __entry->index)
     563                 :            : );
     564                 :            : 
     565   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__page_op, ext4_writepage,
             #  #  #  # ]
     566                 :            : 
     567                 :            :         TP_PROTO(struct page *page),
     568                 :            : 
     569                 :            :         TP_ARGS(page)
     570                 :            : );
     571                 :            : 
     572   [ -  +  -  -  :         28 : DEFINE_EVENT(ext4__page_op, ext4_readpage,
             -  -  -  - ]
     573                 :            : 
     574                 :            :         TP_PROTO(struct page *page),
     575                 :            : 
     576                 :            :         TP_ARGS(page)
     577                 :            : );
     578                 :            : 
     579   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__page_op, ext4_releasepage,
             #  #  #  # ]
     580                 :            : 
     581                 :            :         TP_PROTO(struct page *page),
     582                 :            : 
     583                 :            :         TP_ARGS(page)
     584                 :            : );
     585                 :            : 
     586   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
                   #  # ]
     587                 :            :         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
     588                 :            : 
     589                 :            :         TP_ARGS(page, offset, length),
     590                 :            : 
     591                 :            :         TP_STRUCT__entry(
     592                 :            :                 __field(        dev_t,  dev                     )
     593                 :            :                 __field(        ino_t,  ino                     )
     594                 :            :                 __field(        pgoff_t, index                  )
     595                 :            :                 __field(        unsigned int, offset            )
     596                 :            :                 __field(        unsigned int, length            )
     597                 :            :         ),
     598                 :            : 
     599                 :            :         TP_fast_assign(
     600                 :            :                 __entry->dev = page->mapping->host->i_sb->s_dev;
     601                 :            :                 __entry->ino = page->mapping->host->i_ino;
     602                 :            :                 __entry->index       = page->index;
     603                 :            :                 __entry->offset      = offset;
     604                 :            :                 __entry->length      = length;
     605                 :            :         ),
     606                 :            : 
     607                 :            :         TP_printk("dev %d,%d ino %lu page_index %lu offset %u length %u",
     608                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     609                 :            :                   (unsigned long) __entry->ino,
     610                 :            :                   (unsigned long) __entry->index,
     611                 :            :                   __entry->offset, __entry->length)
     612                 :            : );
     613                 :            : 
     614   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4_invalidatepage_op, ext4_invalidatepage,
             #  #  #  # ]
     615                 :            :         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
     616                 :            : 
     617                 :            :         TP_ARGS(page, offset, length)
     618                 :            : );
     619                 :            : 
     620   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4_invalidatepage_op, ext4_journalled_invalidatepage,
             #  #  #  # ]
     621                 :            :         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
     622                 :            : 
     623                 :            :         TP_ARGS(page, offset, length)
     624                 :            : );
     625                 :            : 
     626   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_discard_blocks,
             #  #  #  # ]
     627                 :            :         TP_PROTO(struct super_block *sb, unsigned long long blk,
     628                 :            :                         unsigned long long count),
     629                 :            : 
     630                 :            :         TP_ARGS(sb, blk, count),
     631                 :            : 
     632                 :            :         TP_STRUCT__entry(
     633                 :            :                 __field(        dev_t,  dev                     )
     634                 :            :                 __field(        __u64,  blk                     )
     635                 :            :                 __field(        __u64,  count                   )
     636                 :            : 
     637                 :            :         ),
     638                 :            : 
     639                 :            :         TP_fast_assign(
     640                 :            :                 __entry->dev = sb->s_dev;
     641                 :            :                 __entry->blk = blk;
     642                 :            :                 __entry->count       = count;
     643                 :            :         ),
     644                 :            : 
     645                 :            :         TP_printk("dev %d,%d blk %llu count %llu",
     646                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     647                 :            :                   __entry->blk, __entry->count)
     648                 :            : );
     649                 :            : 
     650   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__mb_new_pa,
                   #  # ]
     651                 :            :         TP_PROTO(struct ext4_allocation_context *ac,
     652                 :            :                  struct ext4_prealloc_space *pa),
     653                 :            : 
     654                 :            :         TP_ARGS(ac, pa),
     655                 :            : 
     656                 :            :         TP_STRUCT__entry(
     657                 :            :                 __field(        dev_t,  dev                     )
     658                 :            :                 __field(        ino_t,  ino                     )
     659                 :            :                 __field(        __u64,  pa_pstart               )
     660                 :            :                 __field(        __u64,  pa_lstart               )
     661                 :            :                 __field(        __u32,  pa_len                  )
     662                 :            : 
     663                 :            :         ),
     664                 :            : 
     665                 :            :         TP_fast_assign(
     666                 :            :                 __entry->dev         = ac->ac_sb->s_dev;
     667                 :            :                 __entry->ino         = ac->ac_inode->i_ino;
     668                 :            :                 __entry->pa_pstart   = pa->pa_pstart;
     669                 :            :                 __entry->pa_lstart   = pa->pa_lstart;
     670                 :            :                 __entry->pa_len              = pa->pa_len;
     671                 :            :         ),
     672                 :            : 
     673                 :            :         TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
     674                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     675                 :            :                   (unsigned long) __entry->ino,
     676                 :            :                   __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
     677                 :            : );
     678                 :            : 
     679   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
             #  #  #  # ]
     680                 :            : 
     681                 :            :         TP_PROTO(struct ext4_allocation_context *ac,
     682                 :            :                  struct ext4_prealloc_space *pa),
     683                 :            : 
     684                 :            :         TP_ARGS(ac, pa)
     685                 :            : );
     686                 :            : 
     687   [ -  +  -  -  :         28 : DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
             -  -  -  - ]
     688                 :            : 
     689                 :            :         TP_PROTO(struct ext4_allocation_context *ac,
     690                 :            :                  struct ext4_prealloc_space *pa),
     691                 :            : 
     692                 :            :         TP_ARGS(ac, pa)
     693                 :            : );
     694                 :            : 
     695   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_mb_release_inode_pa,
             #  #  #  # ]
     696                 :            :         TP_PROTO(struct ext4_prealloc_space *pa,
     697                 :            :                  unsigned long long block, unsigned int count),
     698                 :            : 
     699                 :            :         TP_ARGS(pa, block, count),
     700                 :            : 
     701                 :            :         TP_STRUCT__entry(
     702                 :            :                 __field(        dev_t,  dev                     )
     703                 :            :                 __field(        ino_t,  ino                     )
     704                 :            :                 __field(        __u64,  block                   )
     705                 :            :                 __field(        __u32,  count                   )
     706                 :            : 
     707                 :            :         ),
     708                 :            : 
     709                 :            :         TP_fast_assign(
     710                 :            :                 __entry->dev         = pa->pa_inode->i_sb->s_dev;
     711                 :            :                 __entry->ino         = pa->pa_inode->i_ino;
     712                 :            :                 __entry->block               = block;
     713                 :            :                 __entry->count               = count;
     714                 :            :         ),
     715                 :            : 
     716                 :            :         TP_printk("dev %d,%d ino %lu block %llu count %u",
     717                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     718                 :            :                   (unsigned long) __entry->ino,
     719                 :            :                   __entry->block, __entry->count)
     720                 :            : );
     721                 :            : 
     722   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_mb_release_group_pa,
             #  #  #  # ]
     723                 :            :         TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
     724                 :            : 
     725                 :            :         TP_ARGS(sb, pa),
     726                 :            : 
     727                 :            :         TP_STRUCT__entry(
     728                 :            :                 __field(        dev_t,  dev                     )
     729                 :            :                 __field(        __u64,  pa_pstart               )
     730                 :            :                 __field(        __u32,  pa_len                  )
     731                 :            : 
     732                 :            :         ),
     733                 :            : 
     734                 :            :         TP_fast_assign(
     735                 :            :                 __entry->dev         = sb->s_dev;
     736                 :            :                 __entry->pa_pstart   = pa->pa_pstart;
     737                 :            :                 __entry->pa_len              = pa->pa_len;
     738                 :            :         ),
     739                 :            : 
     740                 :            :         TP_printk("dev %d,%d pstart %llu len %u",
     741                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     742                 :            :                   __entry->pa_pstart, __entry->pa_len)
     743                 :            : );
     744                 :            : 
     745   [ -  +  -  -  :        980 : TRACE_EVENT(ext4_discard_preallocations,
             -  -  -  - ]
     746                 :            :         TP_PROTO(struct inode *inode),
     747                 :            : 
     748                 :            :         TP_ARGS(inode),
     749                 :            : 
     750                 :            :         TP_STRUCT__entry(
     751                 :            :                 __field(        dev_t,  dev                     )
     752                 :            :                 __field(        ino_t,  ino                     )
     753                 :            : 
     754                 :            :         ),
     755                 :            : 
     756                 :            :         TP_fast_assign(
     757                 :            :                 __entry->dev = inode->i_sb->s_dev;
     758                 :            :                 __entry->ino = inode->i_ino;
     759                 :            :         ),
     760                 :            : 
     761                 :            :         TP_printk("dev %d,%d ino %lu",
     762                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     763                 :            :                   (unsigned long) __entry->ino)
     764                 :            : );
     765                 :            : 
     766   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_mb_discard_preallocations,
             #  #  #  # ]
     767                 :            :         TP_PROTO(struct super_block *sb, int needed),
     768                 :            : 
     769                 :            :         TP_ARGS(sb, needed),
     770                 :            : 
     771                 :            :         TP_STRUCT__entry(
     772                 :            :                 __field(        dev_t,  dev                     )
     773                 :            :                 __field(        int,    needed                  )
     774                 :            : 
     775                 :            :         ),
     776                 :            : 
     777                 :            :         TP_fast_assign(
     778                 :            :                 __entry->dev = sb->s_dev;
     779                 :            :                 __entry->needed      = needed;
     780                 :            :         ),
     781                 :            : 
     782                 :            :         TP_printk("dev %d,%d needed %d",
     783                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     784                 :            :                   __entry->needed)
     785                 :            : );
     786                 :            : 
     787   [ -  +  -  -  :       7224 : TRACE_EVENT(ext4_request_blocks,
             -  -  -  - ]
     788                 :            :         TP_PROTO(struct ext4_allocation_request *ar),
     789                 :            : 
     790                 :            :         TP_ARGS(ar),
     791                 :            : 
     792                 :            :         TP_STRUCT__entry(
     793                 :            :                 __field(        dev_t,  dev                     )
     794                 :            :                 __field(        ino_t,  ino                     )
     795                 :            :                 __field(        unsigned int, len               )
     796                 :            :                 __field(        __u32,  logical                 )
     797                 :            :                 __field(        __u32,  lleft                   )
     798                 :            :                 __field(        __u32,  lright                  )
     799                 :            :                 __field(        __u64,  goal                    )
     800                 :            :                 __field(        __u64,  pleft                   )
     801                 :            :                 __field(        __u64,  pright                  )
     802                 :            :                 __field(        unsigned int, flags             )
     803                 :            :         ),
     804                 :            : 
     805                 :            :         TP_fast_assign(
     806                 :            :                 __entry->dev = ar->inode->i_sb->s_dev;
     807                 :            :                 __entry->ino = ar->inode->i_ino;
     808                 :            :                 __entry->len = ar->len;
     809                 :            :                 __entry->logical = ar->logical;
     810                 :            :                 __entry->goal        = ar->goal;
     811                 :            :                 __entry->lleft       = ar->lleft;
     812                 :            :                 __entry->lright      = ar->lright;
     813                 :            :                 __entry->pleft       = ar->pleft;
     814                 :            :                 __entry->pright      = ar->pright;
     815                 :            :                 __entry->flags       = ar->flags;
     816                 :            :         ),
     817                 :            : 
     818                 :            :         TP_printk("dev %d,%d ino %lu flags %s len %u lblk %u goal %llu "
     819                 :            :                   "lleft %u lright %u pleft %llu pright %llu ",
     820                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     821                 :            :                   (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
     822                 :            :                   __entry->len, __entry->logical, __entry->goal,
     823                 :            :                   __entry->lleft, __entry->lright, __entry->pleft,
     824                 :            :                   __entry->pright)
     825                 :            : );
     826                 :            : 
     827   [ -  +  -  -  :       7224 : TRACE_EVENT(ext4_allocate_blocks,
             -  -  -  - ]
     828                 :            :         TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
     829                 :            : 
     830                 :            :         TP_ARGS(ar, block),
     831                 :            : 
     832                 :            :         TP_STRUCT__entry(
     833                 :            :                 __field(        dev_t,  dev                     )
     834                 :            :                 __field(        ino_t,  ino                     )
     835                 :            :                 __field(        __u64,  block                   )
     836                 :            :                 __field(        unsigned int, len               )
     837                 :            :                 __field(        __u32,  logical                 )
     838                 :            :                 __field(        __u32,  lleft                   )
     839                 :            :                 __field(        __u32,  lright                  )
     840                 :            :                 __field(        __u64,  goal                    )
     841                 :            :                 __field(        __u64,  pleft                   )
     842                 :            :                 __field(        __u64,  pright                  )
     843                 :            :                 __field(        unsigned int, flags             )
     844                 :            :         ),
     845                 :            : 
     846                 :            :         TP_fast_assign(
     847                 :            :                 __entry->dev = ar->inode->i_sb->s_dev;
     848                 :            :                 __entry->ino = ar->inode->i_ino;
     849                 :            :                 __entry->block       = block;
     850                 :            :                 __entry->len = ar->len;
     851                 :            :                 __entry->logical = ar->logical;
     852                 :            :                 __entry->goal        = ar->goal;
     853                 :            :                 __entry->lleft       = ar->lleft;
     854                 :            :                 __entry->lright      = ar->lright;
     855                 :            :                 __entry->pleft       = ar->pleft;
     856                 :            :                 __entry->pright      = ar->pright;
     857                 :            :                 __entry->flags       = ar->flags;
     858                 :            :         ),
     859                 :            : 
     860                 :            :         TP_printk("dev %d,%d ino %lu flags %s len %u block %llu lblk %u "
     861                 :            :                   "goal %llu lleft %u lright %u pleft %llu pright %llu",
     862                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     863                 :            :                   (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
     864                 :            :                   __entry->len, __entry->block, __entry->logical,
     865                 :            :                   __entry->goal,  __entry->lleft, __entry->lright,
     866                 :            :                   __entry->pleft, __entry->pright)
     867                 :            : );
     868                 :            : 
     869   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_free_blocks,
             -  -  -  - ]
     870                 :            :         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
     871                 :            :                  int flags),
     872                 :            : 
     873                 :            :         TP_ARGS(inode, block, count, flags),
     874                 :            : 
     875                 :            :         TP_STRUCT__entry(
     876                 :            :                 __field(        dev_t,  dev                     )
     877                 :            :                 __field(        ino_t,  ino                     )
     878                 :            :                 __field(        __u64,  block                   )
     879                 :            :                 __field(        unsigned long,  count           )
     880                 :            :                 __field(        int,    flags                   )
     881                 :            :                 __field(        __u16,  mode                    )
     882                 :            :         ),
     883                 :            : 
     884                 :            :         TP_fast_assign(
     885                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     886                 :            :                 __entry->ino         = inode->i_ino;
     887                 :            :                 __entry->block               = block;
     888                 :            :                 __entry->count               = count;
     889                 :            :                 __entry->flags               = flags;
     890                 :            :                 __entry->mode                = inode->i_mode;
     891                 :            :         ),
     892                 :            : 
     893                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %s",
     894                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     895                 :            :                   (unsigned long) __entry->ino,
     896                 :            :                   __entry->mode, __entry->block, __entry->count,
     897                 :            :                   show_free_flags(__entry->flags))
     898                 :            : );
     899                 :            : 
     900   [ -  +  -  -  :        392 : TRACE_EVENT(ext4_sync_file_enter,
             -  -  -  - ]
     901                 :            :         TP_PROTO(struct file *file, int datasync),
     902                 :            : 
     903                 :            :         TP_ARGS(file, datasync),
     904                 :            : 
     905                 :            :         TP_STRUCT__entry(
     906                 :            :                 __field(        dev_t,  dev                     )
     907                 :            :                 __field(        ino_t,  ino                     )
     908                 :            :                 __field(        ino_t,  parent                  )
     909                 :            :                 __field(        int,    datasync                )
     910                 :            :         ),
     911                 :            : 
     912                 :            :         TP_fast_assign(
     913                 :            :                 struct dentry *dentry = file->f_path.dentry;
     914                 :            : 
     915                 :            :                 __entry->dev         = dentry->d_sb->s_dev;
     916                 :            :                 __entry->ino         = d_inode(dentry)->i_ino;
     917                 :            :                 __entry->datasync    = datasync;
     918                 :            :                 __entry->parent              = d_inode(dentry->d_parent)->i_ino;
     919                 :            :         ),
     920                 :            : 
     921                 :            :         TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
     922                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     923                 :            :                   (unsigned long) __entry->ino,
     924                 :            :                   (unsigned long) __entry->parent, __entry->datasync)
     925                 :            : );
     926                 :            : 
     927   [ -  +  -  -  :        392 : TRACE_EVENT(ext4_sync_file_exit,
             -  -  -  - ]
     928                 :            :         TP_PROTO(struct inode *inode, int ret),
     929                 :            : 
     930                 :            :         TP_ARGS(inode, ret),
     931                 :            : 
     932                 :            :         TP_STRUCT__entry(
     933                 :            :                 __field(        dev_t,  dev                     )
     934                 :            :                 __field(        ino_t,  ino                     )
     935                 :            :                 __field(        int,    ret                     )
     936                 :            :         ),
     937                 :            : 
     938                 :            :         TP_fast_assign(
     939                 :            :                 __entry->dev         = inode->i_sb->s_dev;
     940                 :            :                 __entry->ino         = inode->i_ino;
     941                 :            :                 __entry->ret         = ret;
     942                 :            :         ),
     943                 :            : 
     944                 :            :         TP_printk("dev %d,%d ino %lu ret %d",
     945                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     946                 :            :                   (unsigned long) __entry->ino,
     947                 :            :                   __entry->ret)
     948                 :            : );
     949                 :            : 
     950   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_sync_fs,
             #  #  #  # ]
     951                 :            :         TP_PROTO(struct super_block *sb, int wait),
     952                 :            : 
     953                 :            :         TP_ARGS(sb, wait),
     954                 :            : 
     955                 :            :         TP_STRUCT__entry(
     956                 :            :                 __field(        dev_t,  dev                     )
     957                 :            :                 __field(        int,    wait                    )
     958                 :            : 
     959                 :            :         ),
     960                 :            : 
     961                 :            :         TP_fast_assign(
     962                 :            :                 __entry->dev = sb->s_dev;
     963                 :            :                 __entry->wait        = wait;
     964                 :            :         ),
     965                 :            : 
     966                 :            :         TP_printk("dev %d,%d wait %d",
     967                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     968                 :            :                   __entry->wait)
     969                 :            : );
     970                 :            : 
     971   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_alloc_da_blocks,
             -  -  -  - ]
     972                 :            :         TP_PROTO(struct inode *inode),
     973                 :            : 
     974                 :            :         TP_ARGS(inode),
     975                 :            : 
     976                 :            :         TP_STRUCT__entry(
     977                 :            :                 __field(        dev_t,  dev                     )
     978                 :            :                 __field(        ino_t,  ino                     )
     979                 :            :                 __field( unsigned int,  data_blocks             )
     980                 :            :         ),
     981                 :            : 
     982                 :            :         TP_fast_assign(
     983                 :            :                 __entry->dev = inode->i_sb->s_dev;
     984                 :            :                 __entry->ino = inode->i_ino;
     985                 :            :                 __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
     986                 :            :         ),
     987                 :            : 
     988                 :            :         TP_printk("dev %d,%d ino %lu reserved_data_blocks %u",
     989                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
     990                 :            :                   (unsigned long) __entry->ino,
     991                 :            :                   __entry->data_blocks)
     992                 :            : );
     993                 :            : 
     994   [ -  +  -  -  :       7028 : TRACE_EVENT(ext4_mballoc_alloc,
             -  -  -  - ]
     995                 :            :         TP_PROTO(struct ext4_allocation_context *ac),
     996                 :            : 
     997                 :            :         TP_ARGS(ac),
     998                 :            : 
     999                 :            :         TP_STRUCT__entry(
    1000                 :            :                 __field(        dev_t,  dev                     )
    1001                 :            :                 __field(        ino_t,  ino                     )
    1002                 :            :                 __field(        __u32,  orig_logical            )
    1003                 :            :                 __field(          int,  orig_start              )
    1004                 :            :                 __field(        __u32,  orig_group              )
    1005                 :            :                 __field(          int,  orig_len                )
    1006                 :            :                 __field(        __u32,  goal_logical            )
    1007                 :            :                 __field(          int,  goal_start              )
    1008                 :            :                 __field(        __u32,  goal_group              )
    1009                 :            :                 __field(          int,  goal_len                )
    1010                 :            :                 __field(        __u32,  result_logical          )
    1011                 :            :                 __field(          int,  result_start            )
    1012                 :            :                 __field(        __u32,  result_group            )
    1013                 :            :                 __field(          int,  result_len              )
    1014                 :            :                 __field(        __u16,  found                   )
    1015                 :            :                 __field(        __u16,  groups                  )
    1016                 :            :                 __field(        __u16,  buddy                   )
    1017                 :            :                 __field(        __u16,  flags                   )
    1018                 :            :                 __field(        __u16,  tail                    )
    1019                 :            :                 __field(        __u8,   cr                      )
    1020                 :            :         ),
    1021                 :            : 
    1022                 :            :         TP_fast_assign(
    1023                 :            :                 __entry->dev         = ac->ac_inode->i_sb->s_dev;
    1024                 :            :                 __entry->ino         = ac->ac_inode->i_ino;
    1025                 :            :                 __entry->orig_logical        = ac->ac_o_ex.fe_logical;
    1026                 :            :                 __entry->orig_start  = ac->ac_o_ex.fe_start;
    1027                 :            :                 __entry->orig_group  = ac->ac_o_ex.fe_group;
    1028                 :            :                 __entry->orig_len    = ac->ac_o_ex.fe_len;
    1029                 :            :                 __entry->goal_logical        = ac->ac_g_ex.fe_logical;
    1030                 :            :                 __entry->goal_start  = ac->ac_g_ex.fe_start;
    1031                 :            :                 __entry->goal_group  = ac->ac_g_ex.fe_group;
    1032                 :            :                 __entry->goal_len    = ac->ac_g_ex.fe_len;
    1033                 :            :                 __entry->result_logical      = ac->ac_f_ex.fe_logical;
    1034                 :            :                 __entry->result_start        = ac->ac_f_ex.fe_start;
    1035                 :            :                 __entry->result_group        = ac->ac_f_ex.fe_group;
    1036                 :            :                 __entry->result_len  = ac->ac_f_ex.fe_len;
    1037                 :            :                 __entry->found               = ac->ac_found;
    1038                 :            :                 __entry->flags               = ac->ac_flags;
    1039                 :            :                 __entry->groups              = ac->ac_groups_scanned;
    1040                 :            :                 __entry->buddy               = ac->ac_buddy;
    1041                 :            :                 __entry->tail                = ac->ac_tail;
    1042                 :            :                 __entry->cr          = ac->ac_criteria;
    1043                 :            :         ),
    1044                 :            : 
    1045                 :            :         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
    1046                 :            :                   "result %u/%d/%u@%u blks %u grps %u cr %u flags %s "
    1047                 :            :                   "tail %u broken %u",
    1048                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1049                 :            :                   (unsigned long) __entry->ino,
    1050                 :            :                   __entry->orig_group, __entry->orig_start,
    1051                 :            :                   __entry->orig_len, __entry->orig_logical,
    1052                 :            :                   __entry->goal_group, __entry->goal_start,
    1053                 :            :                   __entry->goal_len, __entry->goal_logical,
    1054                 :            :                   __entry->result_group, __entry->result_start,
    1055                 :            :                   __entry->result_len, __entry->result_logical,
    1056                 :            :                   __entry->found, __entry->groups, __entry->cr,
    1057                 :            :                   show_mballoc_flags(__entry->flags), __entry->tail,
    1058                 :            :                   __entry->buddy ? 1 << __entry->buddy : 0)
    1059                 :            : );
    1060                 :            : 
    1061   [ -  +  -  -  :        196 : TRACE_EVENT(ext4_mballoc_prealloc,
             -  -  -  - ]
    1062                 :            :         TP_PROTO(struct ext4_allocation_context *ac),
    1063                 :            : 
    1064                 :            :         TP_ARGS(ac),
    1065                 :            : 
    1066                 :            :         TP_STRUCT__entry(
    1067                 :            :                 __field(        dev_t,  dev                     )
    1068                 :            :                 __field(        ino_t,  ino                     )
    1069                 :            :                 __field(        __u32,  orig_logical            )
    1070                 :            :                 __field(          int,  orig_start              )
    1071                 :            :                 __field(        __u32,  orig_group              )
    1072                 :            :                 __field(          int,  orig_len                )
    1073                 :            :                 __field(        __u32,  result_logical          )
    1074                 :            :                 __field(          int,  result_start            )
    1075                 :            :                 __field(        __u32,  result_group            )
    1076                 :            :                 __field(          int,  result_len              )
    1077                 :            :         ),
    1078                 :            : 
    1079                 :            :         TP_fast_assign(
    1080                 :            :                 __entry->dev         = ac->ac_inode->i_sb->s_dev;
    1081                 :            :                 __entry->ino         = ac->ac_inode->i_ino;
    1082                 :            :                 __entry->orig_logical        = ac->ac_o_ex.fe_logical;
    1083                 :            :                 __entry->orig_start  = ac->ac_o_ex.fe_start;
    1084                 :            :                 __entry->orig_group  = ac->ac_o_ex.fe_group;
    1085                 :            :                 __entry->orig_len    = ac->ac_o_ex.fe_len;
    1086                 :            :                 __entry->result_logical      = ac->ac_b_ex.fe_logical;
    1087                 :            :                 __entry->result_start        = ac->ac_b_ex.fe_start;
    1088                 :            :                 __entry->result_group        = ac->ac_b_ex.fe_group;
    1089                 :            :                 __entry->result_len  = ac->ac_b_ex.fe_len;
    1090                 :            :         ),
    1091                 :            : 
    1092                 :            :         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
    1093                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1094                 :            :                   (unsigned long) __entry->ino,
    1095                 :            :                   __entry->orig_group, __entry->orig_start,
    1096                 :            :                   __entry->orig_len, __entry->orig_logical,
    1097                 :            :                   __entry->result_group, __entry->result_start,
    1098                 :            :                   __entry->result_len, __entry->result_logical)
    1099                 :            : );
    1100                 :            : 
    1101   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__mballoc,
             #  #  #  # ]
    1102                 :            :         TP_PROTO(struct super_block *sb,
    1103                 :            :                  struct inode *inode,
    1104                 :            :                  ext4_group_t group,
    1105                 :            :                  ext4_grpblk_t start,
    1106                 :            :                  ext4_grpblk_t len),
    1107                 :            : 
    1108                 :            :         TP_ARGS(sb, inode, group, start, len),
    1109                 :            : 
    1110                 :            :         TP_STRUCT__entry(
    1111                 :            :                 __field(        dev_t,  dev                     )
    1112                 :            :                 __field(        ino_t,  ino                     )
    1113                 :            :                 __field(          int,  result_start            )
    1114                 :            :                 __field(        __u32,  result_group            )
    1115                 :            :                 __field(          int,  result_len              )
    1116                 :            :         ),
    1117                 :            : 
    1118                 :            :         TP_fast_assign(
    1119                 :            :                 __entry->dev         = sb->s_dev;
    1120                 :            :                 __entry->ino         = inode ? inode->i_ino : 0;
    1121                 :            :                 __entry->result_start        = start;
    1122                 :            :                 __entry->result_group        = group;
    1123                 :            :                 __entry->result_len  = len;
    1124                 :            :         ),
    1125                 :            : 
    1126                 :            :         TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
    1127                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1128                 :            :                   (unsigned long) __entry->ino,
    1129                 :            :                   __entry->result_group, __entry->result_start,
    1130                 :            :                   __entry->result_len)
    1131                 :            : );
    1132                 :            : 
    1133   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
             #  #  #  # ]
    1134                 :            : 
    1135                 :            :         TP_PROTO(struct super_block *sb,
    1136                 :            :                  struct inode *inode,
    1137                 :            :                  ext4_group_t group,
    1138                 :            :                  ext4_grpblk_t start,
    1139                 :            :                  ext4_grpblk_t len),
    1140                 :            : 
    1141                 :            :         TP_ARGS(sb, inode, group, start, len)
    1142                 :            : );
    1143                 :            : 
    1144   [ -  +  -  -  :        280 : DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
             -  -  -  - ]
    1145                 :            : 
    1146                 :            :         TP_PROTO(struct super_block *sb,
    1147                 :            :                  struct inode *inode,
    1148                 :            :                  ext4_group_t group,
    1149                 :            :                  ext4_grpblk_t start,
    1150                 :            :                  ext4_grpblk_t len),
    1151                 :            : 
    1152                 :            :         TP_ARGS(sb, inode, group, start, len)
    1153                 :            : );
    1154                 :            : 
    1155   [ -  +  -  -  :         56 : TRACE_EVENT(ext4_forget,
             -  -  -  - ]
    1156                 :            :         TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
    1157                 :            : 
    1158                 :            :         TP_ARGS(inode, is_metadata, block),
    1159                 :            : 
    1160                 :            :         TP_STRUCT__entry(
    1161                 :            :                 __field(        dev_t,  dev                     )
    1162                 :            :                 __field(        ino_t,  ino                     )
    1163                 :            :                 __field(        __u64,  block                   )
    1164                 :            :                 __field(        int,    is_metadata             )
    1165                 :            :                 __field(        __u16,  mode                    )
    1166                 :            :         ),
    1167                 :            : 
    1168                 :            :         TP_fast_assign(
    1169                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1170                 :            :                 __entry->ino = inode->i_ino;
    1171                 :            :                 __entry->block       = block;
    1172                 :            :                 __entry->is_metadata = is_metadata;
    1173                 :            :                 __entry->mode        = inode->i_mode;
    1174                 :            :         ),
    1175                 :            : 
    1176                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
    1177                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1178                 :            :                   (unsigned long) __entry->ino,
    1179                 :            :                   __entry->mode, __entry->is_metadata, __entry->block)
    1180                 :            : );
    1181                 :            : 
    1182   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_da_update_reserve_space,
             -  -  -  - ]
    1183                 :            :         TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
    1184                 :            : 
    1185                 :            :         TP_ARGS(inode, used_blocks, quota_claim),
    1186                 :            : 
    1187                 :            :         TP_STRUCT__entry(
    1188                 :            :                 __field(        dev_t,  dev                     )
    1189                 :            :                 __field(        ino_t,  ino                     )
    1190                 :            :                 __field(        __u64,  i_blocks                )
    1191                 :            :                 __field(        int,    used_blocks             )
    1192                 :            :                 __field(        int,    reserved_data_blocks    )
    1193                 :            :                 __field(        int,    quota_claim             )
    1194                 :            :                 __field(        __u16,  mode                    )
    1195                 :            :         ),
    1196                 :            : 
    1197                 :            :         TP_fast_assign(
    1198                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1199                 :            :                 __entry->ino = inode->i_ino;
    1200                 :            :                 __entry->i_blocks = inode->i_blocks;
    1201                 :            :                 __entry->used_blocks = used_blocks;
    1202                 :            :                 __entry->reserved_data_blocks =
    1203                 :            :                                 EXT4_I(inode)->i_reserved_data_blocks;
    1204                 :            :                 __entry->quota_claim = quota_claim;
    1205                 :            :                 __entry->mode        = inode->i_mode;
    1206                 :            :         ),
    1207                 :            : 
    1208                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
    1209                 :            :                   "reserved_data_blocks %d quota_claim %d",
    1210                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1211                 :            :                   (unsigned long) __entry->ino,
    1212                 :            :                   __entry->mode, __entry->i_blocks,
    1213                 :            :                   __entry->used_blocks, __entry->reserved_data_blocks,
    1214                 :            :                   __entry->quota_claim)
    1215                 :            : );
    1216                 :            : 
    1217   [ -  +  -  -  :      20647 : TRACE_EVENT(ext4_da_reserve_space,
             -  -  -  - ]
    1218                 :            :         TP_PROTO(struct inode *inode),
    1219                 :            : 
    1220                 :            :         TP_ARGS(inode),
    1221                 :            : 
    1222                 :            :         TP_STRUCT__entry(
    1223                 :            :                 __field(        dev_t,  dev                     )
    1224                 :            :                 __field(        ino_t,  ino                     )
    1225                 :            :                 __field(        __u64,  i_blocks                )
    1226                 :            :                 __field(        int,    reserved_data_blocks    )
    1227                 :            :                 __field(        __u16,  mode                    )
    1228                 :            :         ),
    1229                 :            : 
    1230                 :            :         TP_fast_assign(
    1231                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1232                 :            :                 __entry->ino = inode->i_ino;
    1233                 :            :                 __entry->i_blocks = inode->i_blocks;
    1234                 :            :                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
    1235                 :            :                 __entry->mode        = inode->i_mode;
    1236                 :            :         ),
    1237                 :            : 
    1238                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu "
    1239                 :            :                   "reserved_data_blocks %d",
    1240                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1241                 :            :                   (unsigned long) __entry->ino,
    1242                 :            :                   __entry->mode, __entry->i_blocks,
    1243                 :            :                   __entry->reserved_data_blocks)
    1244                 :            : );
    1245                 :            : 
    1246   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_da_release_space,
             #  #  #  # ]
    1247                 :            :         TP_PROTO(struct inode *inode, int freed_blocks),
    1248                 :            : 
    1249                 :            :         TP_ARGS(inode, freed_blocks),
    1250                 :            : 
    1251                 :            :         TP_STRUCT__entry(
    1252                 :            :                 __field(        dev_t,  dev                     )
    1253                 :            :                 __field(        ino_t,  ino                     )
    1254                 :            :                 __field(        __u64,  i_blocks                )
    1255                 :            :                 __field(        int,    freed_blocks            )
    1256                 :            :                 __field(        int,    reserved_data_blocks    )
    1257                 :            :                 __field(        __u16,  mode                    )
    1258                 :            :         ),
    1259                 :            : 
    1260                 :            :         TP_fast_assign(
    1261                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1262                 :            :                 __entry->ino = inode->i_ino;
    1263                 :            :                 __entry->i_blocks = inode->i_blocks;
    1264                 :            :                 __entry->freed_blocks = freed_blocks;
    1265                 :            :                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
    1266                 :            :                 __entry->mode        = inode->i_mode;
    1267                 :            :         ),
    1268                 :            : 
    1269                 :            :         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
    1270                 :            :                   "reserved_data_blocks %d",
    1271                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1272                 :            :                   (unsigned long) __entry->ino,
    1273                 :            :                   __entry->mode, __entry->i_blocks,
    1274                 :            :                   __entry->freed_blocks, __entry->reserved_data_blocks)
    1275                 :            : );
    1276                 :            : 
    1277   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__bitmap_load,
                   #  # ]
    1278                 :            :         TP_PROTO(struct super_block *sb, unsigned long group),
    1279                 :            : 
    1280                 :            :         TP_ARGS(sb, group),
    1281                 :            : 
    1282                 :            :         TP_STRUCT__entry(
    1283                 :            :                 __field(        dev_t,  dev                     )
    1284                 :            :                 __field(        __u32,  group                   )
    1285                 :            : 
    1286                 :            :         ),
    1287                 :            : 
    1288                 :            :         TP_fast_assign(
    1289                 :            :                 __entry->dev = sb->s_dev;
    1290                 :            :                 __entry->group       = group;
    1291                 :            :         ),
    1292                 :            : 
    1293                 :            :         TP_printk("dev %d,%d group %u",
    1294                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1295                 :            :                   __entry->group)
    1296                 :            : );
    1297                 :            : 
    1298   [ -  +  -  -  :         84 : DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
             -  -  -  - ]
    1299                 :            : 
    1300                 :            :         TP_PROTO(struct super_block *sb, unsigned long group),
    1301                 :            : 
    1302                 :            :         TP_ARGS(sb, group)
    1303                 :            : );
    1304                 :            : 
    1305   [ -  +  -  -  :         84 : DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
             -  -  -  - ]
    1306                 :            : 
    1307                 :            :         TP_PROTO(struct super_block *sb, unsigned long group),
    1308                 :            : 
    1309                 :            :         TP_ARGS(sb, group)
    1310                 :            : );
    1311                 :            : 
    1312   [ -  +  -  -  :         84 : DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
             -  -  -  - ]
    1313                 :            : 
    1314                 :            :         TP_PROTO(struct super_block *sb, unsigned long group),
    1315                 :            : 
    1316                 :            :         TP_ARGS(sb, group)
    1317                 :            : );
    1318                 :            : 
    1319   [ -  +  -  -  :         28 : DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
             -  -  -  - ]
    1320                 :            : 
    1321                 :            :         TP_PROTO(struct super_block *sb, unsigned long group),
    1322                 :            : 
    1323                 :            :         TP_ARGS(sb, group)
    1324                 :            : );
    1325                 :            : 
    1326   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_direct_IO_enter,
                   #  # ]
    1327                 :            :         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
    1328                 :            : 
    1329                 :            :         TP_ARGS(inode, offset, len, rw),
    1330                 :            : 
    1331                 :            :         TP_STRUCT__entry(
    1332                 :            :                 __field(        dev_t,  dev                     )
    1333                 :            :                 __field(        ino_t,  ino                     )
    1334                 :            :                 __field(        loff_t, pos                     )
    1335                 :            :                 __field(        unsigned long,  len             )
    1336                 :            :                 __field(        int,    rw                      )
    1337                 :            :         ),
    1338                 :            : 
    1339                 :            :         TP_fast_assign(
    1340                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1341                 :            :                 __entry->ino = inode->i_ino;
    1342                 :            :                 __entry->pos = offset;
    1343                 :            :                 __entry->len = len;
    1344                 :            :                 __entry->rw  = rw;
    1345                 :            :         ),
    1346                 :            : 
    1347                 :            :         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
    1348                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1349                 :            :                   (unsigned long) __entry->ino,
    1350                 :            :                   __entry->pos, __entry->len, __entry->rw)
    1351                 :            : );
    1352                 :            : 
    1353   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_direct_IO_exit,
                   #  # ]
    1354                 :            :         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
    1355                 :            :                  int rw, int ret),
    1356                 :            : 
    1357                 :            :         TP_ARGS(inode, offset, len, rw, ret),
    1358                 :            : 
    1359                 :            :         TP_STRUCT__entry(
    1360                 :            :                 __field(        dev_t,  dev                     )
    1361                 :            :                 __field(        ino_t,  ino                     )
    1362                 :            :                 __field(        loff_t, pos                     )
    1363                 :            :                 __field(        unsigned long,  len             )
    1364                 :            :                 __field(        int,    rw                      )
    1365                 :            :                 __field(        int,    ret                     )
    1366                 :            :         ),
    1367                 :            : 
    1368                 :            :         TP_fast_assign(
    1369                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1370                 :            :                 __entry->ino = inode->i_ino;
    1371                 :            :                 __entry->pos = offset;
    1372                 :            :                 __entry->len = len;
    1373                 :            :                 __entry->rw  = rw;
    1374                 :            :                 __entry->ret = ret;
    1375                 :            :         ),
    1376                 :            : 
    1377                 :            :         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
    1378                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1379                 :            :                   (unsigned long) __entry->ino,
    1380                 :            :                   __entry->pos, __entry->len,
    1381                 :            :                   __entry->rw, __entry->ret)
    1382                 :            : );
    1383                 :            : 
    1384   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__fallocate_mode,
                   #  # ]
    1385                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
    1386                 :            : 
    1387                 :            :         TP_ARGS(inode, offset, len, mode),
    1388                 :            : 
    1389                 :            :         TP_STRUCT__entry(
    1390                 :            :                 __field(        dev_t,  dev                     )
    1391                 :            :                 __field(        ino_t,  ino                     )
    1392                 :            :                 __field(        loff_t, offset                  )
    1393                 :            :                 __field(        loff_t, len                     )
    1394                 :            :                 __field(        int,    mode                    )
    1395                 :            :         ),
    1396                 :            : 
    1397                 :            :         TP_fast_assign(
    1398                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1399                 :            :                 __entry->ino = inode->i_ino;
    1400                 :            :                 __entry->offset      = offset;
    1401                 :            :                 __entry->len = len;
    1402                 :            :                 __entry->mode        = mode;
    1403                 :            :         ),
    1404                 :            : 
    1405                 :            :         TP_printk("dev %d,%d ino %lu offset %lld len %lld mode %s",
    1406                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1407                 :            :                   (unsigned long) __entry->ino,
    1408                 :            :                   __entry->offset, __entry->len,
    1409                 :            :                   show_falloc_mode(__entry->mode))
    1410                 :            : );
    1411                 :            : 
    1412   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__fallocate_mode, ext4_fallocate_enter,
             #  #  #  # ]
    1413                 :            : 
    1414                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
    1415                 :            : 
    1416                 :            :         TP_ARGS(inode, offset, len, mode)
    1417                 :            : );
    1418                 :            : 
    1419   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__fallocate_mode, ext4_punch_hole,
             #  #  #  # ]
    1420                 :            : 
    1421                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
    1422                 :            : 
    1423                 :            :         TP_ARGS(inode, offset, len, mode)
    1424                 :            : );
    1425                 :            : 
    1426   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__fallocate_mode, ext4_zero_range,
             #  #  #  # ]
    1427                 :            : 
    1428                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
    1429                 :            : 
    1430                 :            :         TP_ARGS(inode, offset, len, mode)
    1431                 :            : );
    1432                 :            : 
    1433   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_fallocate_exit,
             #  #  #  # ]
    1434                 :            :         TP_PROTO(struct inode *inode, loff_t offset,
    1435                 :            :                  unsigned int max_blocks, int ret),
    1436                 :            : 
    1437                 :            :         TP_ARGS(inode, offset, max_blocks, ret),
    1438                 :            : 
    1439                 :            :         TP_STRUCT__entry(
    1440                 :            :                 __field(        dev_t,  dev                     )
    1441                 :            :                 __field(        ino_t,  ino                     )
    1442                 :            :                 __field(        loff_t, pos                     )
    1443                 :            :                 __field(        unsigned int,   blocks          )
    1444                 :            :                 __field(        int,    ret                     )
    1445                 :            :         ),
    1446                 :            : 
    1447                 :            :         TP_fast_assign(
    1448                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1449                 :            :                 __entry->ino = inode->i_ino;
    1450                 :            :                 __entry->pos = offset;
    1451                 :            :                 __entry->blocks      = max_blocks;
    1452                 :            :                 __entry->ret = ret;
    1453                 :            :         ),
    1454                 :            : 
    1455                 :            :         TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
    1456                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1457                 :            :                   (unsigned long) __entry->ino,
    1458                 :            :                   __entry->pos, __entry->blocks,
    1459                 :            :                   __entry->ret)
    1460                 :            : );
    1461                 :            : 
    1462   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_unlink_enter,
             #  #  #  # ]
    1463                 :            :         TP_PROTO(struct inode *parent, struct dentry *dentry),
    1464                 :            : 
    1465                 :            :         TP_ARGS(parent, dentry),
    1466                 :            : 
    1467                 :            :         TP_STRUCT__entry(
    1468                 :            :                 __field(        dev_t,  dev                     )
    1469                 :            :                 __field(        ino_t,  ino                     )
    1470                 :            :                 __field(        ino_t,  parent                  )
    1471                 :            :                 __field(        loff_t, size                    )
    1472                 :            :         ),
    1473                 :            : 
    1474                 :            :         TP_fast_assign(
    1475                 :            :                 __entry->dev         = dentry->d_sb->s_dev;
    1476                 :            :                 __entry->ino         = d_inode(dentry)->i_ino;
    1477                 :            :                 __entry->parent              = parent->i_ino;
    1478                 :            :                 __entry->size                = d_inode(dentry)->i_size;
    1479                 :            :         ),
    1480                 :            : 
    1481                 :            :         TP_printk("dev %d,%d ino %lu size %lld parent %lu",
    1482                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1483                 :            :                   (unsigned long) __entry->ino, __entry->size,
    1484                 :            :                   (unsigned long) __entry->parent)
    1485                 :            : );
    1486                 :            : 
    1487   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_unlink_exit,
             #  #  #  # ]
    1488                 :            :         TP_PROTO(struct dentry *dentry, int ret),
    1489                 :            : 
    1490                 :            :         TP_ARGS(dentry, ret),
    1491                 :            : 
    1492                 :            :         TP_STRUCT__entry(
    1493                 :            :                 __field(        dev_t,  dev                     )
    1494                 :            :                 __field(        ino_t,  ino                     )
    1495                 :            :                 __field(        int,    ret                     )
    1496                 :            :         ),
    1497                 :            : 
    1498                 :            :         TP_fast_assign(
    1499                 :            :                 __entry->dev         = dentry->d_sb->s_dev;
    1500                 :            :                 __entry->ino         = d_inode(dentry)->i_ino;
    1501                 :            :                 __entry->ret         = ret;
    1502                 :            :         ),
    1503                 :            : 
    1504                 :            :         TP_printk("dev %d,%d ino %lu ret %d",
    1505                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1506                 :            :                   (unsigned long) __entry->ino,
    1507                 :            :                   __entry->ret)
    1508                 :            : );
    1509                 :            : 
    1510   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__truncate,
                   #  # ]
    1511                 :            :         TP_PROTO(struct inode *inode),
    1512                 :            : 
    1513                 :            :         TP_ARGS(inode),
    1514                 :            : 
    1515                 :            :         TP_STRUCT__entry(
    1516                 :            :                 __field(        dev_t,          dev             )
    1517                 :            :                 __field(        ino_t,          ino             )
    1518                 :            :                 __field(        __u64,          blocks          )
    1519                 :            :         ),
    1520                 :            : 
    1521                 :            :         TP_fast_assign(
    1522                 :            :                 __entry->dev    = inode->i_sb->s_dev;
    1523                 :            :                 __entry->ino    = inode->i_ino;
    1524                 :            :                 __entry->blocks      = inode->i_blocks;
    1525                 :            :         ),
    1526                 :            : 
    1527                 :            :         TP_printk("dev %d,%d ino %lu blocks %llu",
    1528                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1529                 :            :                   (unsigned long) __entry->ino, __entry->blocks)
    1530                 :            : );
    1531                 :            : 
    1532   [ -  +  -  -  :        280 : DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
             -  -  -  - ]
    1533                 :            : 
    1534                 :            :         TP_PROTO(struct inode *inode),
    1535                 :            : 
    1536                 :            :         TP_ARGS(inode)
    1537                 :            : );
    1538                 :            : 
    1539   [ -  +  -  -  :        280 : DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
             -  -  -  - ]
    1540                 :            : 
    1541                 :            :         TP_PROTO(struct inode *inode),
    1542                 :            : 
    1543                 :            :         TP_ARGS(inode)
    1544                 :            : );
    1545                 :            : 
    1546                 :            : /* 'ux' is the unwritten extent. */
    1547   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
             #  #  #  # ]
    1548                 :            :         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
    1549                 :            :                  struct ext4_extent *ux),
    1550                 :            : 
    1551                 :            :         TP_ARGS(inode, map, ux),
    1552                 :            : 
    1553                 :            :         TP_STRUCT__entry(
    1554                 :            :                 __field(        dev_t,          dev     )
    1555                 :            :                 __field(        ino_t,          ino     )
    1556                 :            :                 __field(        ext4_lblk_t,    m_lblk  )
    1557                 :            :                 __field(        unsigned,       m_len   )
    1558                 :            :                 __field(        ext4_lblk_t,    u_lblk  )
    1559                 :            :                 __field(        unsigned,       u_len   )
    1560                 :            :                 __field(        ext4_fsblk_t,   u_pblk  )
    1561                 :            :         ),
    1562                 :            : 
    1563                 :            :         TP_fast_assign(
    1564                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    1565                 :            :                 __entry->ino         = inode->i_ino;
    1566                 :            :                 __entry->m_lblk              = map->m_lblk;
    1567                 :            :                 __entry->m_len               = map->m_len;
    1568                 :            :                 __entry->u_lblk              = le32_to_cpu(ux->ee_block);
    1569                 :            :                 __entry->u_len               = ext4_ext_get_actual_len(ux);
    1570                 :            :                 __entry->u_pblk              = ext4_ext_pblock(ux);
    1571                 :            :         ),
    1572                 :            : 
    1573                 :            :         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
    1574                 :            :                   "u_pblk %llu",
    1575                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1576                 :            :                   (unsigned long) __entry->ino,
    1577                 :            :                   __entry->m_lblk, __entry->m_len,
    1578                 :            :                   __entry->u_lblk, __entry->u_len, __entry->u_pblk)
    1579                 :            : );
    1580                 :            : 
    1581                 :            : /*
    1582                 :            :  * 'ux' is the unwritten extent.
    1583                 :            :  * 'ix' is the initialized extent to which blocks are transferred.
    1584                 :            :  */
    1585   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
          #  #  #  #  #  
                      # ]
    1586                 :            :         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
    1587                 :            :                  struct ext4_extent *ux, struct ext4_extent *ix),
    1588                 :            : 
    1589                 :            :         TP_ARGS(inode, map, ux, ix),
    1590                 :            : 
    1591                 :            :         TP_STRUCT__entry(
    1592                 :            :                 __field(        dev_t,          dev     )
    1593                 :            :                 __field(        ino_t,          ino     )
    1594                 :            :                 __field(        ext4_lblk_t,    m_lblk  )
    1595                 :            :                 __field(        unsigned,       m_len   )
    1596                 :            :                 __field(        ext4_lblk_t,    u_lblk  )
    1597                 :            :                 __field(        unsigned,       u_len   )
    1598                 :            :                 __field(        ext4_fsblk_t,   u_pblk  )
    1599                 :            :                 __field(        ext4_lblk_t,    i_lblk  )
    1600                 :            :                 __field(        unsigned,       i_len   )
    1601                 :            :                 __field(        ext4_fsblk_t,   i_pblk  )
    1602                 :            :         ),
    1603                 :            : 
    1604                 :            :         TP_fast_assign(
    1605                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    1606                 :            :                 __entry->ino         = inode->i_ino;
    1607                 :            :                 __entry->m_lblk              = map->m_lblk;
    1608                 :            :                 __entry->m_len               = map->m_len;
    1609                 :            :                 __entry->u_lblk              = le32_to_cpu(ux->ee_block);
    1610                 :            :                 __entry->u_len               = ext4_ext_get_actual_len(ux);
    1611                 :            :                 __entry->u_pblk              = ext4_ext_pblock(ux);
    1612                 :            :                 __entry->i_lblk              = le32_to_cpu(ix->ee_block);
    1613                 :            :                 __entry->i_len               = ext4_ext_get_actual_len(ix);
    1614                 :            :                 __entry->i_pblk              = ext4_ext_pblock(ix);
    1615                 :            :         ),
    1616                 :            : 
    1617                 :            :         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
    1618                 :            :                   "u_lblk %u u_len %u u_pblk %llu "
    1619                 :            :                   "i_lblk %u i_len %u i_pblk %llu ",
    1620                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1621                 :            :                   (unsigned long) __entry->ino,
    1622                 :            :                   __entry->m_lblk, __entry->m_len,
    1623                 :            :                   __entry->u_lblk, __entry->u_len, __entry->u_pblk,
    1624                 :            :                   __entry->i_lblk, __entry->i_len, __entry->i_pblk)
    1625                 :            : );
    1626                 :            : 
    1627   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
                   #  # ]
    1628                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
    1629                 :            :                  unsigned int len, unsigned int flags),
    1630                 :            : 
    1631                 :            :         TP_ARGS(inode, lblk, len, flags),
    1632                 :            : 
    1633                 :            :         TP_STRUCT__entry(
    1634                 :            :                 __field(        dev_t,          dev             )
    1635                 :            :                 __field(        ino_t,          ino             )
    1636                 :            :                 __field(        ext4_lblk_t,    lblk            )
    1637                 :            :                 __field(        unsigned int,   len             )
    1638                 :            :                 __field(        unsigned int,   flags           )
    1639                 :            :         ),
    1640                 :            : 
    1641                 :            :         TP_fast_assign(
    1642                 :            :                 __entry->dev    = inode->i_sb->s_dev;
    1643                 :            :                 __entry->ino    = inode->i_ino;
    1644                 :            :                 __entry->lblk        = lblk;
    1645                 :            :                 __entry->len = len;
    1646                 :            :                 __entry->flags       = flags;
    1647                 :            :         ),
    1648                 :            : 
    1649                 :            :         TP_printk("dev %d,%d ino %lu lblk %u len %u flags %s",
    1650                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1651                 :            :                   (unsigned long) __entry->ino,
    1652                 :            :                   __entry->lblk, __entry->len, show_map_flags(__entry->flags))
    1653                 :            : );
    1654                 :            : 
    1655   [ -  +  -  -  :      38276 : DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
             -  -  -  - ]
    1656                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
    1657                 :            :                  unsigned len, unsigned flags),
    1658                 :            : 
    1659                 :            :         TP_ARGS(inode, lblk, len, flags)
    1660                 :            : );
    1661                 :            : 
    1662   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
             #  #  #  # ]
    1663                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
    1664                 :            :                  unsigned len, unsigned flags),
    1665                 :            : 
    1666                 :            :         TP_ARGS(inode, lblk, len, flags)
    1667                 :            : );
    1668                 :            : 
    1669   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
                   #  # ]
    1670                 :            :         TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
    1671                 :            :                  int ret),
    1672                 :            : 
    1673                 :            :         TP_ARGS(inode, flags, map, ret),
    1674                 :            : 
    1675                 :            :         TP_STRUCT__entry(
    1676                 :            :                 __field(        dev_t,          dev             )
    1677                 :            :                 __field(        ino_t,          ino             )
    1678                 :            :                 __field(        unsigned int,   flags           )
    1679                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    1680                 :            :                 __field(        ext4_lblk_t,    lblk            )
    1681                 :            :                 __field(        unsigned int,   len             )
    1682                 :            :                 __field(        unsigned int,   mflags          )
    1683                 :            :                 __field(        int,            ret             )
    1684                 :            :         ),
    1685                 :            : 
    1686                 :            :         TP_fast_assign(
    1687                 :            :                 __entry->dev    = inode->i_sb->s_dev;
    1688                 :            :                 __entry->ino    = inode->i_ino;
    1689                 :            :                 __entry->flags       = flags;
    1690                 :            :                 __entry->pblk        = map->m_pblk;
    1691                 :            :                 __entry->lblk        = map->m_lblk;
    1692                 :            :                 __entry->len = map->m_len;
    1693                 :            :                 __entry->mflags      = map->m_flags;
    1694                 :            :                 __entry->ret = ret;
    1695                 :            :         ),
    1696                 :            : 
    1697                 :            :         TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
    1698                 :            :                   "mflags %s ret %d",
    1699                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1700                 :            :                   (unsigned long) __entry->ino,
    1701                 :            :                   show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
    1702                 :            :                   __entry->len, show_mflags(__entry->mflags), __entry->ret)
    1703                 :            : );
    1704                 :            : 
    1705   [ -  +  -  -  :      38276 : DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
             -  -  -  - ]
    1706                 :            :         TP_PROTO(struct inode *inode, unsigned flags,
    1707                 :            :                  struct ext4_map_blocks *map, int ret),
    1708                 :            : 
    1709                 :            :         TP_ARGS(inode, flags, map, ret)
    1710                 :            : );
    1711                 :            : 
    1712   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
             #  #  #  # ]
    1713                 :            :         TP_PROTO(struct inode *inode, unsigned flags,
    1714                 :            :                  struct ext4_map_blocks *map, int ret),
    1715                 :            : 
    1716                 :            :         TP_ARGS(inode, flags, map, ret)
    1717                 :            : );
    1718                 :            : 
    1719   [ -  +  -  -  :         28 : TRACE_EVENT(ext4_ext_load_extent,
             -  -  -  - ]
    1720                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
    1721                 :            : 
    1722                 :            :         TP_ARGS(inode, lblk, pblk),
    1723                 :            : 
    1724                 :            :         TP_STRUCT__entry(
    1725                 :            :                 __field(        dev_t,          dev             )
    1726                 :            :                 __field(        ino_t,          ino             )
    1727                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    1728                 :            :                 __field(        ext4_lblk_t,    lblk            )
    1729                 :            :         ),
    1730                 :            : 
    1731                 :            :         TP_fast_assign(
    1732                 :            :                 __entry->dev    = inode->i_sb->s_dev;
    1733                 :            :                 __entry->ino    = inode->i_ino;
    1734                 :            :                 __entry->pblk        = pblk;
    1735                 :            :                 __entry->lblk        = lblk;
    1736                 :            :         ),
    1737                 :            : 
    1738                 :            :         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
    1739                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1740                 :            :                   (unsigned long) __entry->ino,
    1741                 :            :                   __entry->lblk, __entry->pblk)
    1742                 :            : );
    1743                 :            : 
    1744   [ -  +  -  -  :        476 : TRACE_EVENT(ext4_load_inode,
             -  -  -  - ]
    1745                 :            :         TP_PROTO(struct inode *inode),
    1746                 :            : 
    1747                 :            :         TP_ARGS(inode),
    1748                 :            : 
    1749                 :            :         TP_STRUCT__entry(
    1750                 :            :                 __field(        dev_t,  dev             )
    1751                 :            :                 __field(        ino_t,  ino             )
    1752                 :            :         ),
    1753                 :            : 
    1754                 :            :         TP_fast_assign(
    1755                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    1756                 :            :                 __entry->ino         = inode->i_ino;
    1757                 :            :         ),
    1758                 :            : 
    1759                 :            :         TP_printk("dev %d,%d ino %ld",
    1760                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1761                 :            :                   (unsigned long) __entry->ino)
    1762                 :            : );
    1763                 :            : 
    1764   [ -  +  -  -  :     100580 : TRACE_EVENT(ext4_journal_start,
             -  -  -  - ]
    1765                 :            :         TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
    1766                 :            :                  int revoke_creds, unsigned long IP),
    1767                 :            : 
    1768                 :            :         TP_ARGS(sb, blocks, rsv_blocks, revoke_creds, IP),
    1769                 :            : 
    1770                 :            :         TP_STRUCT__entry(
    1771                 :            :                 __field(        dev_t,  dev                     )
    1772                 :            :                 __field(unsigned long,  ip                      )
    1773                 :            :                 __field(          int,  blocks                  )
    1774                 :            :                 __field(          int,  rsv_blocks              )
    1775                 :            :                 __field(          int,  revoke_creds            )
    1776                 :            :         ),
    1777                 :            : 
    1778                 :            :         TP_fast_assign(
    1779                 :            :                 __entry->dev          = sb->s_dev;
    1780                 :            :                 __entry->ip           = IP;
    1781                 :            :                 __entry->blocks               = blocks;
    1782                 :            :                 __entry->rsv_blocks   = rsv_blocks;
    1783                 :            :                 __entry->revoke_creds         = revoke_creds;
    1784                 :            :         ),
    1785                 :            : 
    1786                 :            :         TP_printk("dev %d,%d blocks %d, rsv_blocks %d, revoke_creds %d, "
    1787                 :            :                   "caller %pS", MAJOR(__entry->dev), MINOR(__entry->dev),
    1788                 :            :                   __entry->blocks, __entry->rsv_blocks, __entry->revoke_creds,
    1789                 :            :                   (void *)__entry->ip)
    1790                 :            : );
    1791                 :            : 
    1792   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_journal_start_reserved,
             -  -  -  - ]
    1793                 :            :         TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
    1794                 :            : 
    1795                 :            :         TP_ARGS(sb, blocks, IP),
    1796                 :            : 
    1797                 :            :         TP_STRUCT__entry(
    1798                 :            :                 __field(        dev_t,  dev                     )
    1799                 :            :                 __field(unsigned long,  ip                      )
    1800                 :            :                 __field(          int,  blocks                  )
    1801                 :            :         ),
    1802                 :            : 
    1803                 :            :         TP_fast_assign(
    1804                 :            :                 __entry->dev          = sb->s_dev;
    1805                 :            :                 __entry->ip           = IP;
    1806                 :            :                 __entry->blocks               = blocks;
    1807                 :            :         ),
    1808                 :            : 
    1809                 :            :         TP_printk("dev %d,%d blocks, %d caller %pS",
    1810                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1811                 :            :                   __entry->blocks, (void *)__entry->ip)
    1812                 :            : );
    1813                 :            : 
    1814   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__trim,
                   #  # ]
    1815                 :            :         TP_PROTO(struct super_block *sb,
    1816                 :            :                  ext4_group_t group,
    1817                 :            :                  ext4_grpblk_t start,
    1818                 :            :                  ext4_grpblk_t len),
    1819                 :            : 
    1820                 :            :         TP_ARGS(sb, group, start, len),
    1821                 :            : 
    1822                 :            :         TP_STRUCT__entry(
    1823                 :            :                 __field(        int,    dev_major               )
    1824                 :            :                 __field(        int,    dev_minor               )
    1825                 :            :                 __field(        __u32,  group                   )
    1826                 :            :                 __field(        int,    start                   )
    1827                 :            :                 __field(        int,    len                     )
    1828                 :            :         ),
    1829                 :            : 
    1830                 :            :         TP_fast_assign(
    1831                 :            :                 __entry->dev_major   = MAJOR(sb->s_dev);
    1832                 :            :                 __entry->dev_minor   = MINOR(sb->s_dev);
    1833                 :            :                 __entry->group               = group;
    1834                 :            :                 __entry->start               = start;
    1835                 :            :                 __entry->len         = len;
    1836                 :            :         ),
    1837                 :            : 
    1838                 :            :         TP_printk("dev %d,%d group %u, start %d, len %d",
    1839                 :            :                   __entry->dev_major, __entry->dev_minor,
    1840                 :            :                   __entry->group, __entry->start, __entry->len)
    1841                 :            : );
    1842                 :            : 
    1843   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__trim, ext4_trim_extent,
             #  #  #  # ]
    1844                 :            : 
    1845                 :            :         TP_PROTO(struct super_block *sb,
    1846                 :            :                  ext4_group_t group,
    1847                 :            :                  ext4_grpblk_t start,
    1848                 :            :                  ext4_grpblk_t len),
    1849                 :            : 
    1850                 :            :         TP_ARGS(sb, group, start, len)
    1851                 :            : );
    1852                 :            : 
    1853   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
             #  #  #  # ]
    1854                 :            : 
    1855                 :            :         TP_PROTO(struct super_block *sb,
    1856                 :            :                  ext4_group_t group,
    1857                 :            :                  ext4_grpblk_t start,
    1858                 :            :                  ext4_grpblk_t len),
    1859                 :            : 
    1860                 :            :         TP_ARGS(sb, group, start, len)
    1861                 :            : );
    1862                 :            : 
    1863   [ -  +  -  -  :        224 : TRACE_EVENT(ext4_ext_handle_unwritten_extents,
             -  -  -  - ]
    1864                 :            :         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
    1865                 :            :                  unsigned int allocated, ext4_fsblk_t newblock),
    1866                 :            : 
    1867                 :            :         TP_ARGS(inode, map, flags, allocated, newblock),
    1868                 :            : 
    1869                 :            :         TP_STRUCT__entry(
    1870                 :            :                 __field(        dev_t,          dev             )
    1871                 :            :                 __field(        ino_t,          ino             )
    1872                 :            :                 __field(        int,            flags           )
    1873                 :            :                 __field(        ext4_lblk_t,    lblk            )
    1874                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    1875                 :            :                 __field(        unsigned int,   len             )
    1876                 :            :                 __field(        unsigned int,   allocated       )
    1877                 :            :                 __field(        ext4_fsblk_t,   newblk          )
    1878                 :            :         ),
    1879                 :            : 
    1880                 :            :         TP_fast_assign(
    1881                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    1882                 :            :                 __entry->ino         = inode->i_ino;
    1883                 :            :                 __entry->flags               = flags;
    1884                 :            :                 __entry->lblk                = map->m_lblk;
    1885                 :            :                 __entry->pblk                = map->m_pblk;
    1886                 :            :                 __entry->len         = map->m_len;
    1887                 :            :                 __entry->allocated   = allocated;
    1888                 :            :                 __entry->newblk              = newblock;
    1889                 :            :         ),
    1890                 :            : 
    1891                 :            :         TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %s "
    1892                 :            :                   "allocated %d newblock %llu",
    1893                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1894                 :            :                   (unsigned long) __entry->ino,
    1895                 :            :                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
    1896                 :            :                   __entry->len, show_map_flags(__entry->flags),
    1897                 :            :                   (unsigned int) __entry->allocated,
    1898                 :            :                   (unsigned long long) __entry->newblk)
    1899                 :            : );
    1900                 :            : 
    1901   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
             #  #  #  # ]
    1902                 :            :         TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
    1903                 :            : 
    1904                 :            :         TP_ARGS(sb, map, ret),
    1905                 :            : 
    1906                 :            :         TP_STRUCT__entry(
    1907                 :            :                 __field(        dev_t,          dev     )
    1908                 :            :                 __field(        unsigned int,   flags   )
    1909                 :            :                 __field(        ext4_lblk_t,    lblk    )
    1910                 :            :                 __field(        ext4_fsblk_t,   pblk    )
    1911                 :            :                 __field(        unsigned int,   len     )
    1912                 :            :                 __field(        int,            ret     )
    1913                 :            :         ),
    1914                 :            : 
    1915                 :            :         TP_fast_assign(
    1916                 :            :                 __entry->dev = sb->s_dev;
    1917                 :            :                 __entry->flags       = map->m_flags;
    1918                 :            :                 __entry->lblk        = map->m_lblk;
    1919                 :            :                 __entry->pblk        = map->m_pblk;
    1920                 :            :                 __entry->len = map->m_len;
    1921                 :            :                 __entry->ret = ret;
    1922                 :            :         ),
    1923                 :            : 
    1924                 :            :         TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %s ret %d",
    1925                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1926                 :            :                   __entry->lblk, (unsigned long long) __entry->pblk,
    1927                 :            :                   __entry->len, show_mflags(__entry->flags), __entry->ret)
    1928                 :            : );
    1929                 :            : 
    1930   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_ext_put_in_cache,
                   #  # ]
    1931                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
    1932                 :            :                  ext4_fsblk_t start),
    1933                 :            : 
    1934                 :            :         TP_ARGS(inode, lblk, len, start),
    1935                 :            : 
    1936                 :            :         TP_STRUCT__entry(
    1937                 :            :                 __field(        dev_t,          dev     )
    1938                 :            :                 __field(        ino_t,          ino     )
    1939                 :            :                 __field(        ext4_lblk_t,    lblk    )
    1940                 :            :                 __field(        unsigned int,   len     )
    1941                 :            :                 __field(        ext4_fsblk_t,   start   )
    1942                 :            :         ),
    1943                 :            : 
    1944                 :            :         TP_fast_assign(
    1945                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1946                 :            :                 __entry->ino = inode->i_ino;
    1947                 :            :                 __entry->lblk        = lblk;
    1948                 :            :                 __entry->len = len;
    1949                 :            :                 __entry->start       = start;
    1950                 :            :         ),
    1951                 :            : 
    1952                 :            :         TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
    1953                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1954                 :            :                   (unsigned long) __entry->ino,
    1955                 :            :                   (unsigned) __entry->lblk,
    1956                 :            :                   __entry->len,
    1957                 :            :                   (unsigned long long) __entry->start)
    1958                 :            : );
    1959                 :            : 
    1960   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_ext_in_cache,
                   #  # ]
    1961                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
    1962                 :            : 
    1963                 :            :         TP_ARGS(inode, lblk, ret),
    1964                 :            : 
    1965                 :            :         TP_STRUCT__entry(
    1966                 :            :                 __field(        dev_t,          dev     )
    1967                 :            :                 __field(        ino_t,          ino     )
    1968                 :            :                 __field(        ext4_lblk_t,    lblk    )
    1969                 :            :                 __field(        int,            ret     )
    1970                 :            :         ),
    1971                 :            : 
    1972                 :            :         TP_fast_assign(
    1973                 :            :                 __entry->dev = inode->i_sb->s_dev;
    1974                 :            :                 __entry->ino = inode->i_ino;
    1975                 :            :                 __entry->lblk        = lblk;
    1976                 :            :                 __entry->ret = ret;
    1977                 :            :         ),
    1978                 :            : 
    1979                 :            :         TP_printk("dev %d,%d ino %lu lblk %u ret %d",
    1980                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    1981                 :            :                   (unsigned long) __entry->ino,
    1982                 :            :                   (unsigned) __entry->lblk,
    1983                 :            :                   __entry->ret)
    1984                 :            : 
    1985                 :            : );
    1986                 :            : 
    1987   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_find_delalloc_range,
                   #  # ]
    1988                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
    1989                 :            :                 int reverse, int found, ext4_lblk_t found_blk),
    1990                 :            : 
    1991                 :            :         TP_ARGS(inode, from, to, reverse, found, found_blk),
    1992                 :            : 
    1993                 :            :         TP_STRUCT__entry(
    1994                 :            :                 __field(        dev_t,          dev             )
    1995                 :            :                 __field(        ino_t,          ino             )
    1996                 :            :                 __field(        ext4_lblk_t,    from            )
    1997                 :            :                 __field(        ext4_lblk_t,    to              )
    1998                 :            :                 __field(        int,            reverse         )
    1999                 :            :                 __field(        int,            found           )
    2000                 :            :                 __field(        ext4_lblk_t,    found_blk       )
    2001                 :            :         ),
    2002                 :            : 
    2003                 :            :         TP_fast_assign(
    2004                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    2005                 :            :                 __entry->ino         = inode->i_ino;
    2006                 :            :                 __entry->from                = from;
    2007                 :            :                 __entry->to          = to;
    2008                 :            :                 __entry->reverse     = reverse;
    2009                 :            :                 __entry->found               = found;
    2010                 :            :                 __entry->found_blk   = found_blk;
    2011                 :            :         ),
    2012                 :            : 
    2013                 :            :         TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
    2014                 :            :                   "(blk = %u)",
    2015                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2016                 :            :                   (unsigned long) __entry->ino,
    2017                 :            :                   (unsigned) __entry->from, (unsigned) __entry->to,
    2018                 :            :                   __entry->reverse, __entry->found,
    2019                 :            :                   (unsigned) __entry->found_blk)
    2020                 :            : );
    2021                 :            : 
    2022   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_get_reserved_cluster_alloc,
                   #  # ]
    2023                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
    2024                 :            : 
    2025                 :            :         TP_ARGS(inode, lblk, len),
    2026                 :            : 
    2027                 :            :         TP_STRUCT__entry(
    2028                 :            :                 __field(        dev_t,          dev     )
    2029                 :            :                 __field(        ino_t,          ino     )
    2030                 :            :                 __field(        ext4_lblk_t,    lblk    )
    2031                 :            :                 __field(        unsigned int,   len     )
    2032                 :            :         ),
    2033                 :            : 
    2034                 :            :         TP_fast_assign(
    2035                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2036                 :            :                 __entry->ino = inode->i_ino;
    2037                 :            :                 __entry->lblk        = lblk;
    2038                 :            :                 __entry->len = len;
    2039                 :            :         ),
    2040                 :            : 
    2041                 :            :         TP_printk("dev %d,%d ino %lu lblk %u len %u",
    2042                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2043                 :            :                   (unsigned long) __entry->ino,
    2044                 :            :                   (unsigned) __entry->lblk,
    2045                 :            :                   __entry->len)
    2046                 :            : );
    2047                 :            : 
    2048   [ -  +  -  -  :      12040 : TRACE_EVENT(ext4_ext_show_extent,
             -  -  -  - ]
    2049                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
    2050                 :            :                  unsigned short len),
    2051                 :            : 
    2052                 :            :         TP_ARGS(inode, lblk, pblk, len),
    2053                 :            : 
    2054                 :            :         TP_STRUCT__entry(
    2055                 :            :                 __field(        dev_t,          dev     )
    2056                 :            :                 __field(        ino_t,          ino     )
    2057                 :            :                 __field(        ext4_fsblk_t,   pblk    )
    2058                 :            :                 __field(        ext4_lblk_t,    lblk    )
    2059                 :            :                 __field(        unsigned short, len     )
    2060                 :            :         ),
    2061                 :            : 
    2062                 :            :         TP_fast_assign(
    2063                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2064                 :            :                 __entry->ino = inode->i_ino;
    2065                 :            :                 __entry->pblk        = pblk;
    2066                 :            :                 __entry->lblk        = lblk;
    2067                 :            :                 __entry->len = len;
    2068                 :            :         ),
    2069                 :            : 
    2070                 :            :         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
    2071                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2072                 :            :                   (unsigned long) __entry->ino,
    2073                 :            :                   (unsigned) __entry->lblk,
    2074                 :            :                   (unsigned long long) __entry->pblk,
    2075                 :            :                   (unsigned short) __entry->len)
    2076                 :            : );
    2077                 :            : 
    2078   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_remove_blocks,
             -  -  -  - ]
    2079                 :            :         TP_PROTO(struct inode *inode, struct ext4_extent *ex,
    2080                 :            :                  ext4_lblk_t from, ext4_fsblk_t to,
    2081                 :            :                  struct partial_cluster *pc),
    2082                 :            : 
    2083                 :            :         TP_ARGS(inode, ex, from, to, pc),
    2084                 :            : 
    2085                 :            :         TP_STRUCT__entry(
    2086                 :            :                 __field(        dev_t,          dev     )
    2087                 :            :                 __field(        ino_t,          ino     )
    2088                 :            :                 __field(        ext4_lblk_t,    from    )
    2089                 :            :                 __field(        ext4_lblk_t,    to      )
    2090                 :            :                 __field(        ext4_fsblk_t,   ee_pblk )
    2091                 :            :                 __field(        ext4_lblk_t,    ee_lblk )
    2092                 :            :                 __field(        unsigned short, ee_len  )
    2093                 :            :                 __field(        ext4_fsblk_t,   pc_pclu )
    2094                 :            :                 __field(        ext4_lblk_t,    pc_lblk )
    2095                 :            :                 __field(        int,            pc_state)
    2096                 :            :         ),
    2097                 :            : 
    2098                 :            :         TP_fast_assign(
    2099                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    2100                 :            :                 __entry->ino         = inode->i_ino;
    2101                 :            :                 __entry->from                = from;
    2102                 :            :                 __entry->to          = to;
    2103                 :            :                 __entry->ee_pblk     = ext4_ext_pblock(ex);
    2104                 :            :                 __entry->ee_lblk     = le32_to_cpu(ex->ee_block);
    2105                 :            :                 __entry->ee_len              = ext4_ext_get_actual_len(ex);
    2106                 :            :                 __entry->pc_pclu     = pc->pclu;
    2107                 :            :                 __entry->pc_lblk     = pc->lblk;
    2108                 :            :                 __entry->pc_state    = pc->state;
    2109                 :            :         ),
    2110                 :            : 
    2111                 :            :         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
    2112                 :            :                   "from %u to %u partial [pclu %lld lblk %u state %d]",
    2113                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2114                 :            :                   (unsigned long) __entry->ino,
    2115                 :            :                   (unsigned) __entry->ee_lblk,
    2116                 :            :                   (unsigned long long) __entry->ee_pblk,
    2117                 :            :                   (unsigned short) __entry->ee_len,
    2118                 :            :                   (unsigned) __entry->from,
    2119                 :            :                   (unsigned) __entry->to,
    2120                 :            :                   (long long) __entry->pc_pclu,
    2121                 :            :                   (unsigned int) __entry->pc_lblk,
    2122                 :            :                   (int) __entry->pc_state)
    2123                 :            : );
    2124                 :            : 
    2125   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_ext_rm_leaf,
             -  -  -  - ]
    2126                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t start,
    2127                 :            :                  struct ext4_extent *ex,
    2128                 :            :                  struct partial_cluster *pc),
    2129                 :            : 
    2130                 :            :         TP_ARGS(inode, start, ex, pc),
    2131                 :            : 
    2132                 :            :         TP_STRUCT__entry(
    2133                 :            :                 __field(        dev_t,          dev     )
    2134                 :            :                 __field(        ino_t,          ino     )
    2135                 :            :                 __field(        ext4_lblk_t,    start   )
    2136                 :            :                 __field(        ext4_lblk_t,    ee_lblk )
    2137                 :            :                 __field(        ext4_fsblk_t,   ee_pblk )
    2138                 :            :                 __field(        short,          ee_len  )
    2139                 :            :                 __field(        ext4_fsblk_t,   pc_pclu )
    2140                 :            :                 __field(        ext4_lblk_t,    pc_lblk )
    2141                 :            :                 __field(        int,            pc_state)
    2142                 :            :         ),
    2143                 :            : 
    2144                 :            :         TP_fast_assign(
    2145                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    2146                 :            :                 __entry->ino         = inode->i_ino;
    2147                 :            :                 __entry->start               = start;
    2148                 :            :                 __entry->ee_lblk     = le32_to_cpu(ex->ee_block);
    2149                 :            :                 __entry->ee_pblk     = ext4_ext_pblock(ex);
    2150                 :            :                 __entry->ee_len              = ext4_ext_get_actual_len(ex);
    2151                 :            :                 __entry->pc_pclu     = pc->pclu;
    2152                 :            :                 __entry->pc_lblk     = pc->lblk;
    2153                 :            :                 __entry->pc_state    = pc->state;
    2154                 :            :         ),
    2155                 :            : 
    2156                 :            :         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
    2157                 :            :                   "partial [pclu %lld lblk %u state %d]",
    2158                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2159                 :            :                   (unsigned long) __entry->ino,
    2160                 :            :                   (unsigned) __entry->start,
    2161                 :            :                   (unsigned) __entry->ee_lblk,
    2162                 :            :                   (unsigned long long) __entry->ee_pblk,
    2163                 :            :                   (unsigned short) __entry->ee_len,
    2164                 :            :                   (long long) __entry->pc_pclu,
    2165                 :            :                   (unsigned int) __entry->pc_lblk,
    2166                 :            :                   (int) __entry->pc_state)
    2167                 :            : );
    2168                 :            : 
    2169   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_ext_rm_idx,
             #  #  #  # ]
    2170                 :            :         TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
    2171                 :            : 
    2172                 :            :         TP_ARGS(inode, pblk),
    2173                 :            : 
    2174                 :            :         TP_STRUCT__entry(
    2175                 :            :                 __field(        dev_t,          dev     )
    2176                 :            :                 __field(        ino_t,          ino     )
    2177                 :            :                 __field(        ext4_fsblk_t,   pblk    )
    2178                 :            :         ),
    2179                 :            : 
    2180                 :            :         TP_fast_assign(
    2181                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2182                 :            :                 __entry->ino = inode->i_ino;
    2183                 :            :                 __entry->pblk        = pblk;
    2184                 :            :         ),
    2185                 :            : 
    2186                 :            :         TP_printk("dev %d,%d ino %lu index_pblk %llu",
    2187                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2188                 :            :                   (unsigned long) __entry->ino,
    2189                 :            :                   (unsigned long long) __entry->pblk)
    2190                 :            : );
    2191                 :            : 
    2192   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_ext_remove_space,
             -  -  -  - ]
    2193                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t start,
    2194                 :            :                  ext4_lblk_t end, int depth),
    2195                 :            : 
    2196                 :            :         TP_ARGS(inode, start, end, depth),
    2197                 :            : 
    2198                 :            :         TP_STRUCT__entry(
    2199                 :            :                 __field(        dev_t,          dev     )
    2200                 :            :                 __field(        ino_t,          ino     )
    2201                 :            :                 __field(        ext4_lblk_t,    start   )
    2202                 :            :                 __field(        ext4_lblk_t,    end     )
    2203                 :            :                 __field(        int,            depth   )
    2204                 :            :         ),
    2205                 :            : 
    2206                 :            :         TP_fast_assign(
    2207                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2208                 :            :                 __entry->ino = inode->i_ino;
    2209                 :            :                 __entry->start       = start;
    2210                 :            :                 __entry->end = end;
    2211                 :            :                 __entry->depth       = depth;
    2212                 :            :         ),
    2213                 :            : 
    2214                 :            :         TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
    2215                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2216                 :            :                   (unsigned long) __entry->ino,
    2217                 :            :                   (unsigned) __entry->start,
    2218                 :            :                   (unsigned) __entry->end,
    2219                 :            :                   __entry->depth)
    2220                 :            : );
    2221                 :            : 
    2222   [ -  +  -  -  :        280 : TRACE_EVENT(ext4_ext_remove_space_done,
             -  -  -  - ]
    2223                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
    2224                 :            :                  int depth, struct partial_cluster *pc, __le16 eh_entries),
    2225                 :            : 
    2226                 :            :         TP_ARGS(inode, start, end, depth, pc, eh_entries),
    2227                 :            : 
    2228                 :            :         TP_STRUCT__entry(
    2229                 :            :                 __field(        dev_t,          dev             )
    2230                 :            :                 __field(        ino_t,          ino             )
    2231                 :            :                 __field(        ext4_lblk_t,    start           )
    2232                 :            :                 __field(        ext4_lblk_t,    end             )
    2233                 :            :                 __field(        int,            depth           )
    2234                 :            :                 __field(        ext4_fsblk_t,   pc_pclu         )
    2235                 :            :                 __field(        ext4_lblk_t,    pc_lblk         )
    2236                 :            :                 __field(        int,            pc_state        )
    2237                 :            :                 __field(        unsigned short, eh_entries      )
    2238                 :            :         ),
    2239                 :            : 
    2240                 :            :         TP_fast_assign(
    2241                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    2242                 :            :                 __entry->ino         = inode->i_ino;
    2243                 :            :                 __entry->start               = start;
    2244                 :            :                 __entry->end         = end;
    2245                 :            :                 __entry->depth               = depth;
    2246                 :            :                 __entry->pc_pclu     = pc->pclu;
    2247                 :            :                 __entry->pc_lblk     = pc->lblk;
    2248                 :            :                 __entry->pc_state    = pc->state;
    2249                 :            :                 __entry->eh_entries  = le16_to_cpu(eh_entries);
    2250                 :            :         ),
    2251                 :            : 
    2252                 :            :         TP_printk("dev %d,%d ino %lu since %u end %u depth %d "
    2253                 :            :                   "partial [pclu %lld lblk %u state %d] "
    2254                 :            :                   "remaining_entries %u",
    2255                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2256                 :            :                   (unsigned long) __entry->ino,
    2257                 :            :                   (unsigned) __entry->start,
    2258                 :            :                   (unsigned) __entry->end,
    2259                 :            :                   __entry->depth,
    2260                 :            :                   (long long) __entry->pc_pclu,
    2261                 :            :                   (unsigned int) __entry->pc_lblk,
    2262                 :            :                   (int) __entry->pc_state,
    2263                 :            :                   (unsigned short) __entry->eh_entries)
    2264                 :            : );
    2265                 :            : 
    2266   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__es_extent,
             #  #  #  # ]
    2267                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es),
    2268                 :            : 
    2269                 :            :         TP_ARGS(inode, es),
    2270                 :            : 
    2271                 :            :         TP_STRUCT__entry(
    2272                 :            :                 __field(        dev_t,          dev             )
    2273                 :            :                 __field(        ino_t,          ino             )
    2274                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2275                 :            :                 __field(        ext4_lblk_t,    len             )
    2276                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    2277                 :            :                 __field(        char, status    )
    2278                 :            :         ),
    2279                 :            : 
    2280                 :            :         TP_fast_assign(
    2281                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2282                 :            :                 __entry->ino = inode->i_ino;
    2283                 :            :                 __entry->lblk        = es->es_lblk;
    2284                 :            :                 __entry->len = es->es_len;
    2285                 :            :                 __entry->pblk        = ext4_es_show_pblock(es);
    2286                 :            :                 __entry->status      = ext4_es_status(es);
    2287                 :            :         ),
    2288                 :            : 
    2289                 :            :         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
    2290                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2291                 :            :                   (unsigned long) __entry->ino,
    2292                 :            :                   __entry->lblk, __entry->len,
    2293                 :            :                   __entry->pblk, show_extent_status(__entry->status))
    2294                 :            : );
    2295                 :            : 
    2296   [ -  +  -  -  :      38304 : DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
             -  -  -  - ]
    2297                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es),
    2298                 :            : 
    2299                 :            :         TP_ARGS(inode, es)
    2300                 :            : );
    2301                 :            : 
    2302   [ -  +  -  -  :      12712 : DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
             -  -  -  - ]
    2303                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es),
    2304                 :            : 
    2305                 :            :         TP_ARGS(inode, es)
    2306                 :            : );
    2307                 :            : 
    2308   [ -  +  -  -  :        560 : TRACE_EVENT(ext4_es_remove_extent,
             -  -  -  - ]
    2309                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
    2310                 :            : 
    2311                 :            :         TP_ARGS(inode, lblk, len),
    2312                 :            : 
    2313                 :            :         TP_STRUCT__entry(
    2314                 :            :                 __field(        dev_t,  dev                     )
    2315                 :            :                 __field(        ino_t,  ino                     )
    2316                 :            :                 __field(        loff_t, lblk                    )
    2317                 :            :                 __field(        loff_t, len                     )
    2318                 :            :         ),
    2319                 :            : 
    2320                 :            :         TP_fast_assign(
    2321                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2322                 :            :                 __entry->ino = inode->i_ino;
    2323                 :            :                 __entry->lblk        = lblk;
    2324                 :            :                 __entry->len = len;
    2325                 :            :         ),
    2326                 :            : 
    2327                 :            :         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
    2328                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2329                 :            :                   (unsigned long) __entry->ino,
    2330                 :            :                   __entry->lblk, __entry->len)
    2331                 :            : );
    2332                 :            : 
    2333   [ -  +  -  -  :      19068 : TRACE_EVENT(ext4_es_find_extent_range_enter,
             -  -  -  - ]
    2334                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
    2335                 :            : 
    2336                 :            :         TP_ARGS(inode, lblk),
    2337                 :            : 
    2338                 :            :         TP_STRUCT__entry(
    2339                 :            :                 __field(        dev_t,          dev             )
    2340                 :            :                 __field(        ino_t,          ino             )
    2341                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2342                 :            :         ),
    2343                 :            : 
    2344                 :            :         TP_fast_assign(
    2345                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2346                 :            :                 __entry->ino = inode->i_ino;
    2347                 :            :                 __entry->lblk        = lblk;
    2348                 :            :         ),
    2349                 :            : 
    2350                 :            :         TP_printk("dev %d,%d ino %lu lblk %u",
    2351                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2352                 :            :                   (unsigned long) __entry->ino, __entry->lblk)
    2353                 :            : );
    2354                 :            : 
    2355   [ -  +  -  -  :      19068 : TRACE_EVENT(ext4_es_find_extent_range_exit,
             -  -  -  - ]
    2356                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es),
    2357                 :            : 
    2358                 :            :         TP_ARGS(inode, es),
    2359                 :            : 
    2360                 :            :         TP_STRUCT__entry(
    2361                 :            :                 __field(        dev_t,          dev             )
    2362                 :            :                 __field(        ino_t,          ino             )
    2363                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2364                 :            :                 __field(        ext4_lblk_t,    len             )
    2365                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    2366                 :            :                 __field(        char, status    )
    2367                 :            :         ),
    2368                 :            : 
    2369                 :            :         TP_fast_assign(
    2370                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2371                 :            :                 __entry->ino = inode->i_ino;
    2372                 :            :                 __entry->lblk        = es->es_lblk;
    2373                 :            :                 __entry->len = es->es_len;
    2374                 :            :                 __entry->pblk        = ext4_es_show_pblock(es);
    2375                 :            :                 __entry->status      = ext4_es_status(es);
    2376                 :            :         ),
    2377                 :            : 
    2378                 :            :         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
    2379                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2380                 :            :                   (unsigned long) __entry->ino,
    2381                 :            :                   __entry->lblk, __entry->len,
    2382                 :            :                   __entry->pblk, show_extent_status(__entry->status))
    2383                 :            : );
    2384                 :            : 
    2385   [ -  +  -  -  :     146666 : TRACE_EVENT(ext4_es_lookup_extent_enter,
             -  -  -  - ]
    2386                 :            :         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
    2387                 :            : 
    2388                 :            :         TP_ARGS(inode, lblk),
    2389                 :            : 
    2390                 :            :         TP_STRUCT__entry(
    2391                 :            :                 __field(        dev_t,          dev             )
    2392                 :            :                 __field(        ino_t,          ino             )
    2393                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2394                 :            :         ),
    2395                 :            : 
    2396                 :            :         TP_fast_assign(
    2397                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2398                 :            :                 __entry->ino = inode->i_ino;
    2399                 :            :                 __entry->lblk        = lblk;
    2400                 :            :         ),
    2401                 :            : 
    2402                 :            :         TP_printk("dev %d,%d ino %lu lblk %u",
    2403                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2404                 :            :                   (unsigned long) __entry->ino, __entry->lblk)
    2405                 :            : );
    2406                 :            : 
    2407   [ -  +  -  -  :     146666 : TRACE_EVENT(ext4_es_lookup_extent_exit,
             -  -  -  - ]
    2408                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es,
    2409                 :            :                  int found),
    2410                 :            : 
    2411                 :            :         TP_ARGS(inode, es, found),
    2412                 :            : 
    2413                 :            :         TP_STRUCT__entry(
    2414                 :            :                 __field(        dev_t,          dev             )
    2415                 :            :                 __field(        ino_t,          ino             )
    2416                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2417                 :            :                 __field(        ext4_lblk_t,    len             )
    2418                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    2419                 :            :                 __field(        char,           status          )
    2420                 :            :                 __field(        int,            found           )
    2421                 :            :         ),
    2422                 :            : 
    2423                 :            :         TP_fast_assign(
    2424                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2425                 :            :                 __entry->ino = inode->i_ino;
    2426                 :            :                 __entry->lblk        = es->es_lblk;
    2427                 :            :                 __entry->len = es->es_len;
    2428                 :            :                 __entry->pblk        = ext4_es_show_pblock(es);
    2429                 :            :                 __entry->status      = ext4_es_status(es);
    2430                 :            :                 __entry->found       = found;
    2431                 :            :         ),
    2432                 :            : 
    2433                 :            :         TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
    2434                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2435                 :            :                   (unsigned long) __entry->ino, __entry->found,
    2436                 :            :                   __entry->lblk, __entry->len,
    2437                 :            :                   __entry->found ? __entry->pblk : 0,
    2438                 :            :                   show_extent_status(__entry->found ? __entry->status : 0))
    2439                 :            : );
    2440                 :            : 
    2441   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4__es_shrink_enter,
                   #  # ]
    2442                 :            :         TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
    2443                 :            : 
    2444                 :            :         TP_ARGS(sb, nr_to_scan, cache_cnt),
    2445                 :            : 
    2446                 :            :         TP_STRUCT__entry(
    2447                 :            :                 __field(        dev_t,  dev                     )
    2448                 :            :                 __field(        int,    nr_to_scan              )
    2449                 :            :                 __field(        int,    cache_cnt               )
    2450                 :            :         ),
    2451                 :            : 
    2452                 :            :         TP_fast_assign(
    2453                 :            :                 __entry->dev         = sb->s_dev;
    2454                 :            :                 __entry->nr_to_scan  = nr_to_scan;
    2455                 :            :                 __entry->cache_cnt   = cache_cnt;
    2456                 :            :         ),
    2457                 :            : 
    2458                 :            :         TP_printk("dev %d,%d nr_to_scan %d cache_cnt %d",
    2459                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2460                 :            :                   __entry->nr_to_scan, __entry->cache_cnt)
    2461                 :            : );
    2462                 :            : 
    2463   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__es_shrink_enter, ext4_es_shrink_count,
             #  #  #  # ]
    2464                 :            :         TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
    2465                 :            : 
    2466                 :            :         TP_ARGS(sb, nr_to_scan, cache_cnt)
    2467                 :            : );
    2468                 :            : 
    2469   [ #  #  #  #  :          0 : DEFINE_EVENT(ext4__es_shrink_enter, ext4_es_shrink_scan_enter,
             #  #  #  # ]
    2470                 :            :         TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
    2471                 :            : 
    2472                 :            :         TP_ARGS(sb, nr_to_scan, cache_cnt)
    2473                 :            : );
    2474                 :            : 
    2475   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_es_shrink_scan_exit,
             #  #  #  # ]
    2476                 :            :         TP_PROTO(struct super_block *sb, int nr_shrunk, int cache_cnt),
    2477                 :            : 
    2478                 :            :         TP_ARGS(sb, nr_shrunk, cache_cnt),
    2479                 :            : 
    2480                 :            :         TP_STRUCT__entry(
    2481                 :            :                 __field(        dev_t,  dev                     )
    2482                 :            :                 __field(        int,    nr_shrunk               )
    2483                 :            :                 __field(        int,    cache_cnt               )
    2484                 :            :         ),
    2485                 :            : 
    2486                 :            :         TP_fast_assign(
    2487                 :            :                 __entry->dev         = sb->s_dev;
    2488                 :            :                 __entry->nr_shrunk   = nr_shrunk;
    2489                 :            :                 __entry->cache_cnt   = cache_cnt;
    2490                 :            :         ),
    2491                 :            : 
    2492                 :            :         TP_printk("dev %d,%d nr_shrunk %d cache_cnt %d",
    2493                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2494                 :            :                   __entry->nr_shrunk, __entry->cache_cnt)
    2495                 :            : );
    2496                 :            : 
    2497   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_collapse_range,
             #  #  #  # ]
    2498                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
    2499                 :            : 
    2500                 :            :         TP_ARGS(inode, offset, len),
    2501                 :            : 
    2502                 :            :         TP_STRUCT__entry(
    2503                 :            :                 __field(dev_t,  dev)
    2504                 :            :                 __field(ino_t,  ino)
    2505                 :            :                 __field(loff_t, offset)
    2506                 :            :                 __field(loff_t, len)
    2507                 :            :         ),
    2508                 :            : 
    2509                 :            :         TP_fast_assign(
    2510                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2511                 :            :                 __entry->ino = inode->i_ino;
    2512                 :            :                 __entry->offset      = offset;
    2513                 :            :                 __entry->len = len;
    2514                 :            :         ),
    2515                 :            : 
    2516                 :            :         TP_printk("dev %d,%d ino %lu offset %lld len %lld",
    2517                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2518                 :            :                   (unsigned long) __entry->ino,
    2519                 :            :                   __entry->offset, __entry->len)
    2520                 :            : );
    2521                 :            : 
    2522   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_insert_range,
             #  #  #  # ]
    2523                 :            :         TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
    2524                 :            : 
    2525                 :            :         TP_ARGS(inode, offset, len),
    2526                 :            : 
    2527                 :            :         TP_STRUCT__entry(
    2528                 :            :                 __field(dev_t,  dev)
    2529                 :            :                 __field(ino_t,  ino)
    2530                 :            :                 __field(loff_t, offset)
    2531                 :            :                 __field(loff_t, len)
    2532                 :            :         ),
    2533                 :            : 
    2534                 :            :         TP_fast_assign(
    2535                 :            :                 __entry->dev = inode->i_sb->s_dev;
    2536                 :            :                 __entry->ino = inode->i_ino;
    2537                 :            :                 __entry->offset      = offset;
    2538                 :            :                 __entry->len = len;
    2539                 :            :         ),
    2540                 :            : 
    2541                 :            :         TP_printk("dev %d,%d ino %lu offset %lld len %lld",
    2542                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2543                 :            :                   (unsigned long) __entry->ino,
    2544                 :            :                   __entry->offset, __entry->len)
    2545                 :            : );
    2546                 :            : 
    2547   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_es_shrink,
             #  #  #  # ]
    2548                 :            :         TP_PROTO(struct super_block *sb, int nr_shrunk, u64 scan_time,
    2549                 :            :                  int nr_skipped, int retried),
    2550                 :            : 
    2551                 :            :         TP_ARGS(sb, nr_shrunk, scan_time, nr_skipped, retried),
    2552                 :            : 
    2553                 :            :         TP_STRUCT__entry(
    2554                 :            :                 __field(        dev_t,          dev             )
    2555                 :            :                 __field(        int,            nr_shrunk       )
    2556                 :            :                 __field(        unsigned long long, scan_time   )
    2557                 :            :                 __field(        int,            nr_skipped      )
    2558                 :            :                 __field(        int,            retried         )
    2559                 :            :         ),
    2560                 :            : 
    2561                 :            :         TP_fast_assign(
    2562                 :            :                 __entry->dev         = sb->s_dev;
    2563                 :            :                 __entry->nr_shrunk   = nr_shrunk;
    2564                 :            :                 __entry->scan_time   = div_u64(scan_time, 1000);
    2565                 :            :                 __entry->nr_skipped  = nr_skipped;
    2566                 :            :                 __entry->retried     = retried;
    2567                 :            :         ),
    2568                 :            : 
    2569                 :            :         TP_printk("dev %d,%d nr_shrunk %d, scan_time %llu "
    2570                 :            :                   "nr_skipped %d retried %d",
    2571                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->nr_shrunk,
    2572                 :            :                   __entry->scan_time, __entry->nr_skipped, __entry->retried)
    2573                 :            : );
    2574                 :            : 
    2575   [ -  +  -  -  :      20311 : TRACE_EVENT(ext4_es_insert_delayed_block,
             -  -  -  - ]
    2576                 :            :         TP_PROTO(struct inode *inode, struct extent_status *es,
    2577                 :            :                  bool allocated),
    2578                 :            : 
    2579                 :            :         TP_ARGS(inode, es, allocated),
    2580                 :            : 
    2581                 :            :         TP_STRUCT__entry(
    2582                 :            :                 __field(        dev_t,          dev             )
    2583                 :            :                 __field(        ino_t,          ino             )
    2584                 :            :                 __field(        ext4_lblk_t,    lblk            )
    2585                 :            :                 __field(        ext4_lblk_t,    len             )
    2586                 :            :                 __field(        ext4_fsblk_t,   pblk            )
    2587                 :            :                 __field(        char,           status          )
    2588                 :            :                 __field(        bool,           allocated       )
    2589                 :            :         ),
    2590                 :            : 
    2591                 :            :         TP_fast_assign(
    2592                 :            :                 __entry->dev         = inode->i_sb->s_dev;
    2593                 :            :                 __entry->ino         = inode->i_ino;
    2594                 :            :                 __entry->lblk                = es->es_lblk;
    2595                 :            :                 __entry->len         = es->es_len;
    2596                 :            :                 __entry->pblk                = ext4_es_show_pblock(es);
    2597                 :            :                 __entry->status              = ext4_es_status(es);
    2598                 :            :                 __entry->allocated   = allocated;
    2599                 :            :         ),
    2600                 :            : 
    2601                 :            :         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s "
    2602                 :            :                   "allocated %d",
    2603                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2604                 :            :                   (unsigned long) __entry->ino,
    2605                 :            :                   __entry->lblk, __entry->len,
    2606                 :            :                   __entry->pblk, show_extent_status(__entry->status),
    2607                 :            :                   __entry->allocated)
    2608                 :            : );
    2609                 :            : 
    2610                 :            : /* fsmap traces */
    2611   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4_fsmap_class,
                   #  # ]
    2612                 :            :         TP_PROTO(struct super_block *sb, u32 keydev, u32 agno, u64 bno, u64 len,
    2613                 :            :                  u64 owner),
    2614                 :            :         TP_ARGS(sb, keydev, agno, bno, len, owner),
    2615                 :            :         TP_STRUCT__entry(
    2616                 :            :                 __field(dev_t, dev)
    2617                 :            :                 __field(dev_t, keydev)
    2618                 :            :                 __field(u32, agno)
    2619                 :            :                 __field(u64, bno)
    2620                 :            :                 __field(u64, len)
    2621                 :            :                 __field(u64, owner)
    2622                 :            :         ),
    2623                 :            :         TP_fast_assign(
    2624                 :            :                 __entry->dev = sb->s_bdev->bd_dev;
    2625                 :            :                 __entry->keydev = new_decode_dev(keydev);
    2626                 :            :                 __entry->agno = agno;
    2627                 :            :                 __entry->bno = bno;
    2628                 :            :                 __entry->len = len;
    2629                 :            :                 __entry->owner = owner;
    2630                 :            :         ),
    2631                 :            :         TP_printk("dev %d:%d keydev %d:%d agno %u bno %llu len %llu owner %lld\n",
    2632                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2633                 :            :                   MAJOR(__entry->keydev), MINOR(__entry->keydev),
    2634                 :            :                   __entry->agno,
    2635                 :            :                   __entry->bno,
    2636                 :            :                   __entry->len,
    2637                 :            :                   __entry->owner)
    2638                 :            : )
    2639                 :            : #define DEFINE_FSMAP_EVENT(name) \
    2640                 :            : DEFINE_EVENT(ext4_fsmap_class, name, \
    2641                 :            :         TP_PROTO(struct super_block *sb, u32 keydev, u32 agno, u64 bno, u64 len, \
    2642                 :            :                  u64 owner), \
    2643                 :            :         TP_ARGS(sb, keydev, agno, bno, len, owner))
    2644   [ #  #  #  #  :          0 : DEFINE_FSMAP_EVENT(ext4_fsmap_low_key);
             #  #  #  # ]
    2645   [ #  #  #  #  :          0 : DEFINE_FSMAP_EVENT(ext4_fsmap_high_key);
             #  #  #  # ]
    2646   [ #  #  #  #  :          0 : DEFINE_FSMAP_EVENT(ext4_fsmap_mapping);
             #  #  #  # ]
    2647                 :            : 
    2648   [ #  #  #  #  :          0 : DECLARE_EVENT_CLASS(ext4_getfsmap_class,
                   #  # ]
    2649                 :            :         TP_PROTO(struct super_block *sb, struct ext4_fsmap *fsmap),
    2650                 :            :         TP_ARGS(sb, fsmap),
    2651                 :            :         TP_STRUCT__entry(
    2652                 :            :                 __field(dev_t, dev)
    2653                 :            :                 __field(dev_t, keydev)
    2654                 :            :                 __field(u64, block)
    2655                 :            :                 __field(u64, len)
    2656                 :            :                 __field(u64, owner)
    2657                 :            :                 __field(u64, flags)
    2658                 :            :         ),
    2659                 :            :         TP_fast_assign(
    2660                 :            :                 __entry->dev = sb->s_bdev->bd_dev;
    2661                 :            :                 __entry->keydev = new_decode_dev(fsmap->fmr_device);
    2662                 :            :                 __entry->block = fsmap->fmr_physical;
    2663                 :            :                 __entry->len = fsmap->fmr_length;
    2664                 :            :                 __entry->owner = fsmap->fmr_owner;
    2665                 :            :                 __entry->flags = fsmap->fmr_flags;
    2666                 :            :         ),
    2667                 :            :         TP_printk("dev %d:%d keydev %d:%d block %llu len %llu owner %lld flags 0x%llx\n",
    2668                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2669                 :            :                   MAJOR(__entry->keydev), MINOR(__entry->keydev),
    2670                 :            :                   __entry->block,
    2671                 :            :                   __entry->len,
    2672                 :            :                   __entry->owner,
    2673                 :            :                   __entry->flags)
    2674                 :            : )
    2675                 :            : #define DEFINE_GETFSMAP_EVENT(name) \
    2676                 :            : DEFINE_EVENT(ext4_getfsmap_class, name, \
    2677                 :            :         TP_PROTO(struct super_block *sb, struct ext4_fsmap *fsmap), \
    2678                 :            :         TP_ARGS(sb, fsmap))
    2679   [ #  #  #  #  :          0 : DEFINE_GETFSMAP_EVENT(ext4_getfsmap_low_key);
             #  #  #  # ]
    2680   [ #  #  #  #  :          0 : DEFINE_GETFSMAP_EVENT(ext4_getfsmap_high_key);
             #  #  #  # ]
    2681   [ #  #  #  #  :          0 : DEFINE_GETFSMAP_EVENT(ext4_getfsmap_mapping);
             #  #  #  # ]
    2682                 :            : 
    2683   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_shutdown,
             #  #  #  # ]
    2684                 :            :         TP_PROTO(struct super_block *sb, unsigned long flags),
    2685                 :            : 
    2686                 :            :         TP_ARGS(sb, flags),
    2687                 :            : 
    2688                 :            :         TP_STRUCT__entry(
    2689                 :            :                 __field(        dev_t,  dev                     )
    2690                 :            :                 __field(     unsigned,  flags                   )
    2691                 :            :         ),
    2692                 :            : 
    2693                 :            :         TP_fast_assign(
    2694                 :            :                 __entry->dev = sb->s_dev;
    2695                 :            :                 __entry->flags       = flags;
    2696                 :            :         ),
    2697                 :            : 
    2698                 :            :         TP_printk("dev %d,%d flags %u",
    2699                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2700                 :            :                   __entry->flags)
    2701                 :            : );
    2702                 :            : 
    2703   [ #  #  #  #  :          0 : TRACE_EVENT(ext4_error,
             #  #  #  # ]
    2704                 :            :         TP_PROTO(struct super_block *sb, const char *function,
    2705                 :            :                  unsigned int line),
    2706                 :            : 
    2707                 :            :         TP_ARGS(sb, function, line),
    2708                 :            : 
    2709                 :            :         TP_STRUCT__entry(
    2710                 :            :                 __field(        dev_t,  dev                     )
    2711                 :            :                 __field( const char *,  function                )
    2712                 :            :                 __field(     unsigned,  line                    )
    2713                 :            :         ),
    2714                 :            : 
    2715                 :            :         TP_fast_assign(
    2716                 :            :                 __entry->dev = sb->s_dev;
    2717                 :            :                 __entry->function = function;
    2718                 :            :                 __entry->line        = line;
    2719                 :            :         ),
    2720                 :            : 
    2721                 :            :         TP_printk("dev %d,%d function %s line %u",
    2722                 :            :                   MAJOR(__entry->dev), MINOR(__entry->dev),
    2723                 :            :                   __entry->function, __entry->line)
    2724                 :            : );
    2725                 :            : 
    2726                 :            : #endif /* _TRACE_EXT4_H */
    2727                 :            : 
    2728                 :            : /* This part must be outside protection */
    2729                 :            : #include <trace/define_trace.h>

Generated by: LCOV version 1.14