[lttng-dev] [PATCH lttng-modules] Add new kernel probes instrumentation
Mathieu Desnoyers
mathieu.desnoyers at efficios.com
Mon Dec 10 11:15:54 EST 2012
* Andrew Gabbasov (andrew_gabbasov at mentor.com) wrote:
> Add kernel probes for btrfs, compaction, ext4, printk, random, rcu,
> regmap, rpm, sunrpc, workqueue, writeback.
merged into master branch, thanks!
Mathieu
>
> Signed-off-by: Andrew Gabbasov <andrew_gabbasov at mentor.com>
> ---
> instrumentation/events/lttng-module/btrfs.h | 1005 +++++++++
> instrumentation/events/lttng-module/compaction.h | 74 +
> instrumentation/events/lttng-module/ext4.h | 2398 ++++++++++++++++++++++
> instrumentation/events/lttng-module/printk.h | 64 +
> instrumentation/events/lttng-module/random.h | 134 ++
> instrumentation/events/lttng-module/rcu.h | 721 +++++++
> instrumentation/events/lttng-module/regmap.h | 188 ++
> instrumentation/events/lttng-module/rpm.h | 101 +
> instrumentation/events/lttng-module/sunrpc.h | 177 ++
> instrumentation/events/lttng-module/workqueue.h | 316 +++
> instrumentation/events/lttng-module/writeback.h | 673 ++++++
> instrumentation/events/mainline/btrfs.h | 918 +++++++++
> instrumentation/events/mainline/compaction.h | 74 +
> instrumentation/events/mainline/ext4.h | 2061 +++++++++++++++++++
> instrumentation/events/mainline/printk.h | 41 +
> instrumentation/events/mainline/random.h | 134 ++
> instrumentation/events/mainline/rcu.h | 618 ++++++
> instrumentation/events/mainline/regmap.h | 181 ++
> instrumentation/events/mainline/rpm.h | 100 +
> instrumentation/events/mainline/sunrpc.h | 177 ++
> instrumentation/events/mainline/workqueue.h | 121 ++
> instrumentation/events/mainline/writeback.h | 492 +++++
> probes/Makefile | 73 +
> probes/lttng-probe-btrfs.c | 48 +
> probes/lttng-probe-compaction.c | 43 +
> probes/lttng-probe-ext4.c | 50 +
> probes/lttng-probe-printk.c | 43 +
> probes/lttng-probe-random.c | 43 +
> probes/lttng-probe-rcu.c | 44 +
> probes/lttng-probe-regmap.c | 44 +
> probes/lttng-probe-rpm.c | 44 +
> probes/lttng-probe-sunrpc.c | 43 +
> probes/lttng-probe-workqueue.c | 48 +
> probes/lttng-probe-writeback.c | 69 +
> 34 files changed, 11360 insertions(+)
> create mode 100644 instrumentation/events/lttng-module/btrfs.h
> create mode 100644 instrumentation/events/lttng-module/compaction.h
> create mode 100644 instrumentation/events/lttng-module/ext4.h
> create mode 100644 instrumentation/events/lttng-module/printk.h
> create mode 100644 instrumentation/events/lttng-module/random.h
> create mode 100644 instrumentation/events/lttng-module/rcu.h
> create mode 100644 instrumentation/events/lttng-module/regmap.h
> create mode 100644 instrumentation/events/lttng-module/rpm.h
> create mode 100644 instrumentation/events/lttng-module/sunrpc.h
> create mode 100644 instrumentation/events/lttng-module/workqueue.h
> create mode 100644 instrumentation/events/lttng-module/writeback.h
> create mode 100644 instrumentation/events/mainline/btrfs.h
> create mode 100644 instrumentation/events/mainline/compaction.h
> create mode 100644 instrumentation/events/mainline/ext4.h
> create mode 100644 instrumentation/events/mainline/printk.h
> create mode 100644 instrumentation/events/mainline/random.h
> create mode 100644 instrumentation/events/mainline/rcu.h
> create mode 100644 instrumentation/events/mainline/regmap.h
> create mode 100644 instrumentation/events/mainline/rpm.h
> create mode 100644 instrumentation/events/mainline/sunrpc.h
> create mode 100644 instrumentation/events/mainline/workqueue.h
> create mode 100644 instrumentation/events/mainline/writeback.h
> create mode 100644 probes/lttng-probe-btrfs.c
> create mode 100644 probes/lttng-probe-compaction.c
> create mode 100644 probes/lttng-probe-ext4.c
> create mode 100644 probes/lttng-probe-printk.c
> create mode 100644 probes/lttng-probe-random.c
> create mode 100644 probes/lttng-probe-rcu.c
> create mode 100644 probes/lttng-probe-regmap.c
> create mode 100644 probes/lttng-probe-rpm.c
> create mode 100644 probes/lttng-probe-sunrpc.c
> create mode 100644 probes/lttng-probe-workqueue.c
> create mode 100644 probes/lttng-probe-writeback.c
>
> diff --git a/instrumentation/events/lttng-module/btrfs.h b/instrumentation/events/lttng-module/btrfs.h
> new file mode 100644
> index 0000000..b0ff3c6
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/btrfs.h
> @@ -0,0 +1,1005 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM btrfs
> +
> +#if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_BTRFS_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +#include <trace/events/gfpflags.h>
> +#include <linux/version.h>
> +
> +#ifndef _TRACE_BTRFS_DEF_
> +#define _TRACE_BTRFS_DEF_
> +struct btrfs_root;
> +struct btrfs_fs_info;
> +struct btrfs_inode;
> +struct extent_map;
> +struct btrfs_ordered_extent;
> +struct btrfs_delayed_ref_node;
> +struct btrfs_delayed_tree_ref;
> +struct btrfs_delayed_data_ref;
> +struct btrfs_delayed_ref_head;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +struct btrfs_block_group_cache;
> +struct btrfs_free_cluster;
> +#endif
> +struct map_lookup;
> +struct extent_buffer;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> +struct extent_state;
> +#endif
> +#endif
> +
> +#define show_ref_type(type) \
> + __print_symbolic(type, \
> + { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
> + { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
> + { BTRFS_EXTENT_REF_V0_KEY, "EXTENT_REF_V0" }, \
> + { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
> + { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
> +#define __show_root_type(obj) \
> + __print_symbolic_u64(obj, \
> + { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
> + { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
> + { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
> + { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
> + { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
> + { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
> + { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
> + { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
> + { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
> + { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
> +#else
> +#define __show_root_type(obj) \
> + __print_symbolic(obj, \
> + { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
> + { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
> + { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
> + { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
> + { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
> + { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
> + { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
> + { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
> + { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
> + { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
> +#endif
> +
> +#define show_root_type(obj) \
> + obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
> + (obj <= BTRFS_CSUM_TREE_OBJECTID )) ? __show_root_type(obj) : "-"
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +
> +#define BTRFS_GROUP_FLAGS \
> + { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
> + { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
> + { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
> + { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
> + { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
> + { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
> + { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}
> +
> +#define BTRFS_UUID_SIZE 16
> +
> +#endif
> +
> +TRACE_EVENT(btrfs_transaction_commit,
> +
> + TP_PROTO(struct btrfs_root *root),
> +
> + TP_ARGS(root),
> +
> + TP_STRUCT__entry(
> + __field( u64, generation )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(generation, root->fs_info->generation)
> + tp_assign(root_objectid, root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), gen = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->generation)
> +)
> +
> +DECLARE_EVENT_CLASS(btrfs__inode,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( blkcnt_t, blocks )
> + __field( u64, disk_i_size )
> + __field( u64, generation )
> + __field( u64, last_trans )
> + __field( u64, logged_trans )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(ino, inode->i_ino)
> + tp_assign(blocks, inode->i_blocks)
> + tp_assign(disk_i_size, BTRFS_I(inode)->disk_i_size)
> + tp_assign(generation, BTRFS_I(inode)->generation)
> + tp_assign(last_trans, BTRFS_I(inode)->last_trans)
> + tp_assign(logged_trans, BTRFS_I(inode)->logged_trans)
> + tp_assign(root_objectid,
> + BTRFS_I(inode)->root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
> + "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->generation,
> + (unsigned long)__entry->ino,
> + (unsigned long long)__entry->blocks,
> + (unsigned long long)__entry->disk_i_size,
> + (unsigned long long)__entry->last_trans,
> + (unsigned long long)__entry->logged_trans)
> +)
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +)
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +)
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
> +#define __show_map_type(type) \
> + __print_symbolic_u64(type, \
> + { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
> + { EXTENT_MAP_HOLE, "HOLE" }, \
> + { EXTENT_MAP_INLINE, "INLINE" }, \
> + { EXTENT_MAP_DELALLOC, "DELALLOC" })
> +#else
> +#define __show_map_type(type) \
> + __print_symbolic(type, \
> + { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
> + { EXTENT_MAP_HOLE, "HOLE" }, \
> + { EXTENT_MAP_INLINE, "INLINE" }, \
> + { EXTENT_MAP_DELALLOC, "DELALLOC" })
> +#endif
> +
> +#define show_map_type(type) \
> + type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
> +
> +#define show_map_flags(flag) \
> + __print_flags(flag, "|", \
> + { EXTENT_FLAG_PINNED, "PINNED" }, \
> + { EXTENT_FLAG_COMPRESSED, "COMPRESSED" }, \
> + { EXTENT_FLAG_VACANCY, "VACANCY" }, \
> + { EXTENT_FLAG_PREALLOC, "PREALLOC" })
> +
> +TRACE_EVENT(btrfs_get_extent,
> +
> + TP_PROTO(struct btrfs_root *root, struct extent_map *map),
> +
> + TP_ARGS(root, map),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, start )
> + __field( u64, len )
> + __field( u64, orig_start )
> + __field( u64, block_start )
> + __field( u64, block_len )
> + __field( unsigned long, flags )
> + __field( int, refs )
> + __field( unsigned int, compress_type )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(root_objectid, root->root_key.objectid)
> + tp_assign(start, map->start)
> + tp_assign(len, map->len)
> + tp_assign(orig_start, map->orig_start)
> + tp_assign(block_start, map->block_start)
> + tp_assign(block_len, map->block_len)
> + tp_assign(flags, map->flags)
> + tp_assign(refs, atomic_read(&map->refs))
> + tp_assign(compress_type, map->compress_type)
> + ),
> +
> + TP_printk("root = %llu(%s), start = %llu, len = %llu, "
> + "orig_start = %llu, block_start = %llu(%s), "
> + "block_len = %llu, flags = %s, refs = %u, "
> + "compress_type = %u",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len,
> + (unsigned long long)__entry->orig_start,
> + show_map_type(__entry->block_start),
> + (unsigned long long)__entry->block_len,
> + show_map_flags(__entry->flags),
> + __entry->refs, __entry->compress_type)
> +)
> +
> +#define show_ordered_flags(flags) \
> + __print_symbolic(flags, \
> + { BTRFS_ORDERED_IO_DONE, "IO_DONE" }, \
> + { BTRFS_ORDERED_COMPLETE, "COMPLETE" }, \
> + { BTRFS_ORDERED_NOCOW, "NOCOW" }, \
> + { BTRFS_ORDERED_COMPRESSED, "COMPRESSED" }, \
> + { BTRFS_ORDERED_PREALLOC, "PREALLOC" }, \
> + { BTRFS_ORDERED_DIRECT, "DIRECT" })
> +
> +DECLARE_EVENT_CLASS(btrfs__ordered_extent,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( u64, file_offset )
> + __field( u64, start )
> + __field( u64, len )
> + __field( u64, disk_len )
> + __field( u64, bytes_left )
> + __field( unsigned long, flags )
> + __field( int, compress_type )
> + __field( int, refs )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(ino, inode->i_ino)
> + tp_assign(file_offset, ordered->file_offset)
> + tp_assign(start, ordered->start)
> + tp_assign(len, ordered->len)
> + tp_assign(disk_len, ordered->disk_len)
> + tp_assign(bytes_left, ordered->bytes_left)
> + tp_assign(flags, ordered->flags)
> + tp_assign(compress_type, ordered->compress_type)
> + tp_assign(refs, atomic_read(&ordered->refs))
> + tp_assign(root_objectid,
> + BTRFS_I(inode)->root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %llu, file_offset = %llu, "
> + "start = %llu, len = %llu, disk_len = %llu, "
> + "bytes_left = %llu, flags = %s, compress_type = %d, "
> + "refs = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->ino,
> + (unsigned long long)__entry->file_offset,
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len,
> + (unsigned long long)__entry->disk_len,
> + (unsigned long long)__entry->bytes_left,
> + show_ordered_flags(__entry->flags),
> + __entry->compress_type, __entry->refs)
> +)
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +)
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +)
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +)
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +)
> +
> +DECLARE_EVENT_CLASS(btrfs__writepage,
> +
> + TP_PROTO(struct page *page, struct inode *inode,
> + struct writeback_control *wbc),
> +
> + TP_ARGS(page, inode, wbc),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( long, nr_to_write )
> + __field( long, pages_skipped )
> + __field( loff_t, range_start )
> + __field( loff_t, range_end )
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + __field( char, nonblocking )
> +#endif
> + __field( char, for_kupdate )
> + __field( char, for_reclaim )
> + __field( char, range_cyclic )
> + __field( pgoff_t, writeback_index )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(ino, inode->i_ino)
> + tp_assign(index, page->index)
> + tp_assign(nr_to_write, wbc->nr_to_write)
> + tp_assign(pages_skipped, wbc->pages_skipped)
> + tp_assign(range_start, wbc->range_start)
> + tp_assign(range_end, wbc->range_end)
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + tp_assign(nonblocking, wbc->nonblocking)
> +#endif
> + tp_assign(for_kupdate, wbc->for_kupdate)
> + tp_assign(for_reclaim, wbc->for_reclaim)
> + tp_assign(range_cyclic, wbc->range_cyclic)
> + tp_assign(writeback_index, inode->i_mapping->writeback_index)
> + tp_assign(root_objectid,
> + BTRFS_I(inode)->root->root_key.objectid)
> + ),
> +
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
> + "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
> + "range_end = %llu, nonblocking = %d, for_kupdate = %d, "
> + "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, __entry->index,
> + __entry->nr_to_write, __entry->pages_skipped,
> + __entry->range_start, __entry->range_end,
> + __entry->nonblocking, __entry->for_kupdate,
> + __entry->for_reclaim, __entry->range_cyclic,
> + (unsigned long)__entry->writeback_index)
> +#else
> + TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
> + "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
> + "range_end = %llu, for_kupdate = %d, "
> + "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, __entry->index,
> + __entry->nr_to_write, __entry->pages_skipped,
> + __entry->range_start, __entry->range_end,
> + __entry->for_kupdate,
> + __entry->for_reclaim, __entry->range_cyclic,
> + (unsigned long)__entry->writeback_index)
> +#endif
> +)
> +
> +DEFINE_EVENT(btrfs__writepage, __extent_writepage,
> +
> + TP_PROTO(struct page *page, struct inode *inode,
> + struct writeback_control *wbc),
> +
> + TP_ARGS(page, inode, wbc)
> +)
> +
> +TRACE_EVENT(btrfs_writepage_end_io_hook,
> +
> + TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
> +
> + TP_ARGS(page, start, end, uptodate),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( u64, start )
> + __field( u64, end )
> + __field( int, uptodate )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(ino, page->mapping->host->i_ino)
> + tp_assign(index, page->index)
> + tp_assign(start, start)
> + tp_assign(end, end)
> + tp_assign(uptodate, uptodate)
> + tp_assign(root_objectid,
> + BTRFS_I(page->mapping->host)->root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
> + "end = %llu, uptodate = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, (unsigned long)__entry->index,
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->end, __entry->uptodate)
> +)
> +
> +TRACE_EVENT(btrfs_sync_file,
> +
> + TP_PROTO(struct file *file, int datasync),
> +
> + TP_ARGS(file, datasync),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( int, datasync )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(ino, file->f_path.dentry->d_inode->i_ino)
> + tp_assign(parent, file->f_path.dentry->d_parent->d_inode->i_ino)
> + tp_assign(datasync, datasync)
> + tp_assign(root_objectid,
> + BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, (unsigned long)__entry->parent,
> + __entry->datasync)
> +)
> +
> +TRACE_EVENT(btrfs_sync_fs,
> +
> + TP_PROTO(int wait),
> +
> + TP_ARGS(wait),
> +
> + TP_STRUCT__entry(
> + __field( int, wait )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(wait, wait)
> + ),
> +
> + TP_printk("wait = %d", __entry->wait)
> +)
> +
> +#define show_ref_action(action) \
> + __print_symbolic(action, \
> + { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
> + { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
> + { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
> + { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
> +
> +
> +TRACE_EVENT(btrfs_delayed_tree_ref,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_tree_ref *full_ref,
> + int action),
> +
> + TP_ARGS(ref, full_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( u64, parent )
> + __field( u64, ref_root )
> + __field( int, level )
> + __field( int, type )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + __field( u64, seq )
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bytenr, ref->bytenr)
> + tp_assign(num_bytes, ref->num_bytes)
> + tp_assign(action, action)
> + tp_assign(parent, full_ref->parent)
> + tp_assign(ref_root, full_ref->root)
> + tp_assign(level, full_ref->level)
> + tp_assign(type, ref->type)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + tp_assign(seq, ref->seq)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
> + "type = %s, seq = %llu",
> +#else
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
> + "type = %s",
> +#endif
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + show_root_type(__entry->parent),
> + show_root_type(__entry->ref_root),
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + __entry->level, show_ref_type(__entry->type),
> + (unsigned long long)__entry->seq)
> +#else
> + __entry->level, show_ref_type(__entry->type))
> +#endif
> +)
> +
> +TRACE_EVENT(btrfs_delayed_data_ref,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_data_ref *full_ref,
> + int action),
> +
> + TP_ARGS(ref, full_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( u64, parent )
> + __field( u64, ref_root )
> + __field( u64, owner )
> + __field( u64, offset )
> + __field( int, type )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + __field( u64, seq )
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bytenr, ref->bytenr)
> + tp_assign(num_bytes, ref->num_bytes)
> + tp_assign(action, action)
> + tp_assign(parent, full_ref->parent)
> + tp_assign(ref_root, full_ref->root)
> + tp_assign(owner, full_ref->objectid)
> + tp_assign(offset, full_ref->offset)
> + tp_assign(type, ref->type)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + tp_assign(seq, ref->seq)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
> + "offset = %llu, type = %s, seq = %llu",
> +#else
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
> + "offset = %llu, type = %s",
> +#endif
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + show_root_type(__entry->parent),
> + show_root_type(__entry->ref_root),
> + (unsigned long long)__entry->owner,
> + (unsigned long long)__entry->offset,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + show_ref_type(__entry->type),
> + (unsigned long long)__entry->seq)
> +#else
> + show_ref_type(__entry->type))
> +#endif
> +)
> +
> +TRACE_EVENT(btrfs_delayed_ref_head,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_ref_head *head_ref,
> + int action),
> +
> + TP_ARGS(ref, head_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( int, is_data )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bytenr, ref->bytenr)
> + tp_assign(num_bytes, ref->num_bytes)
> + tp_assign(action, action)
> + tp_assign(is_data, head_ref->is_data)
> + ),
> +
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + __entry->is_data)
> +)
> +
> +#define show_chunk_type(type) \
> + __print_flags(type, "|", \
> + { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
> + { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
> + { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
> + { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
> + { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
> + { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
> + { BTRFS_BLOCK_GROUP_RAID10, "RAID10"})
> +
> +DECLARE_EVENT_CLASS(btrfs__chunk,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size),
> +
> + TP_STRUCT__entry(
> + __field( int, num_stripes )
> + __field( u64, type )
> + __field( int, sub_stripes )
> + __field( u64, offset )
> + __field( u64, size )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(num_stripes, map->num_stripes)
> + tp_assign(type, map->type)
> + tp_assign(sub_stripes, map->sub_stripes)
> + tp_assign(offset, offset)
> + tp_assign(size, size)
> + tp_assign(root_objectid, root->root_key.objectid)
> + ),
> +
> + TP_printk("root = %llu(%s), offset = %llu, size = %llu, "
> + "num_stripes = %d, sub_stripes = %d, type = %s",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->offset,
> + (unsigned long long)__entry->size,
> + __entry->num_stripes, __entry->sub_stripes,
> + show_chunk_type(__entry->type))
> +)
> +
> +DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size)
> +)
> +
> +DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size)
> +)
> +
> +TRACE_EVENT(btrfs_cow_block,
> +
> + TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
> + struct extent_buffer *cow),
> +
> + TP_ARGS(root, buf, cow),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, buf_start )
> + __field( int, refs )
> + __field( u64, cow_start )
> + __field( int, buf_level )
> + __field( int, cow_level )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(root_objectid, root->root_key.objectid)
> + tp_assign(buf_start, buf->start)
> + tp_assign(refs, atomic_read(&buf->refs))
> + tp_assign(cow_start, cow->start)
> + tp_assign(buf_level, btrfs_header_level(buf))
> + tp_assign(cow_level, btrfs_header_level(cow))
> + ),
> +
> + TP_printk("root = %llu(%s), refs = %d, orig_buf = %llu "
> + "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
> + show_root_type(__entry->root_objectid),
> + __entry->refs,
> + (unsigned long long)__entry->buf_start,
> + __entry->buf_level,
> + (unsigned long long)__entry->cow_start,
> + __entry->cow_level)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +TRACE_EVENT(btrfs_space_reservation,
> +
> + TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
> + u64 bytes, int reserve),
> +
> + TP_ARGS(fs_info, type, val, bytes, reserve),
> +
> + TP_STRUCT__entry(
> + __array( u8, fsid, BTRFS_UUID_SIZE )
> + __string( type, type )
> + __field( u64, val )
> + __field( u64, bytes )
> + __field( int, reserve )
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(fsid, fs_info->fsid, BTRFS_UUID_SIZE)
> + tp_strcpy(type, type)
> + tp_assign(val, val)
> + tp_assign(bytes, bytes)
> + tp_assign(reserve, reserve)
> + ),
> +
> + TP_printk("%pU: %s: %Lu %s %Lu", __entry->fsid, __get_str(type),
> + __entry->val, __entry->reserve ? "reserve" : "release",
> + __entry->bytes)
> +)
> +#endif
> +
> +DECLARE_EVENT_CLASS(btrfs__reserved_extent,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, start )
> + __field( u64, len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(root_objectid, root->root_key.objectid)
> + tp_assign(start, start)
> + tp_assign(len, len)
> + ),
> +
> + TP_printk("root = %llu(%s), start = %llu, len = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len)
> +)
> +
> +DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len)
> +)
> +
> +DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +TRACE_EVENT(find_free_extent,
> +
> + TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
> + u64 data),
> +
> + TP_ARGS(root, num_bytes, empty_size, data),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, num_bytes )
> + __field( u64, empty_size )
> + __field( u64, data )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(root_objectid, root->root_key.objectid)
> + tp_assign(num_bytes, num_bytes)
> + tp_assign(empty_size, empty_size)
> + tp_assign(data, data)
> + ),
> +
> + TP_printk("root = %Lu(%s), len = %Lu, empty_size = %Lu, "
> + "flags = %Lu(%s)", show_root_type(__entry->root_objectid),
> + __entry->num_bytes, __entry->empty_size, __entry->data,
> + __print_flags((unsigned long)__entry->data, "|",
> + BTRFS_GROUP_FLAGS))
> +)
> +
> +DECLARE_EVENT_CLASS(btrfs__reserve_extent,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(root_objectid, root->root_key.objectid)
> + tp_assign(bg_objectid, block_group->key.objectid)
> + tp_assign(flags, block_group->flags)
> + tp_assign(start, start)
> + tp_assign(len, len)
> + ),
> +
> + TP_printk("root = %Lu(%s), block_group = %Lu, flags = %Lu(%s), "
> + "start = %Lu, len = %Lu",
> + show_root_type(__entry->root_objectid), __entry->bg_objectid,
> + __entry->flags, __print_flags((unsigned long)__entry->flags,
> + "|", BTRFS_GROUP_FLAGS),
> + __entry->start, __entry->len)
> +)
> +
> +DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len)
> +)
> +
> +DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len)
> +)
> +
> +TRACE_EVENT(btrfs_find_cluster,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
> + u64 bytes, u64 empty_size, u64 min_bytes),
> +
> + TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, bytes )
> + __field( u64, empty_size )
> + __field( u64, min_bytes )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bg_objectid, block_group->key.objectid)
> + tp_assign(flags, block_group->flags)
> + tp_assign(start, start)
> + tp_assign(bytes, bytes)
> + tp_assign(empty_size, empty_size)
> + tp_assign(min_bytes, min_bytes)
> + ),
> +
> + TP_printk("block_group = %Lu, flags = %Lu(%s), start = %Lu, len = %Lu,"
> + " empty_size = %Lu, min_bytes = %Lu", __entry->bg_objectid,
> + __entry->flags,
> + __print_flags((unsigned long)__entry->flags, "|",
> + BTRFS_GROUP_FLAGS), __entry->start,
> + __entry->bytes, __entry->empty_size, __entry->min_bytes)
> +)
> +
> +TRACE_EVENT(btrfs_failed_cluster_setup,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group),
> +
> + TP_ARGS(block_group),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bg_objectid, block_group->key.objectid)
> + ),
> +
> + TP_printk("block_group = %Lu", __entry->bg_objectid)
> +)
> +
> +TRACE_EVENT(btrfs_setup_cluster,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group,
> + struct btrfs_free_cluster *cluster, u64 size, int bitmap),
> +
> + TP_ARGS(block_group, cluster, size, bitmap),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, max_size )
> + __field( u64, size )
> + __field( int, bitmap )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(bg_objectid, block_group->key.objectid)
> + tp_assign(flags, block_group->flags)
> + tp_assign(start, cluster->window_start)
> + tp_assign(max_size, cluster->max_size)
> + tp_assign(size, size)
> + tp_assign(bitmap, bitmap)
> + ),
> +
> + TP_printk("block_group = %Lu, flags = %Lu(%s), window_start = %Lu, "
> + "size = %Lu, max_size = %Lu, bitmap = %d",
> + __entry->bg_objectid,
> + __entry->flags,
> + __print_flags((unsigned long)__entry->flags, "|",
> + BTRFS_GROUP_FLAGS), __entry->start,
> + __entry->size, __entry->max_size, __entry->bitmap)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> +TRACE_EVENT(alloc_extent_state,
> +
> + TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
> +
> + TP_ARGS(state, mask, IP),
> +
> + TP_STRUCT__entry(
> + __field(struct extent_state *, state)
> + __field(gfp_t, mask)
> + __field(unsigned long, ip)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(state, state)
> + tp_assign(mask, mask)
> + tp_assign(ip, IP)
> + ),
> +
> + TP_printk("state=%p; mask = %s; caller = %pF", __entry->state,
> + show_gfp_flags(__entry->mask), (void *)__entry->ip)
> +)
> +
> +TRACE_EVENT(free_extent_state,
> +
> + TP_PROTO(struct extent_state *state, unsigned long IP),
> +
> + TP_ARGS(state, IP),
> +
> + TP_STRUCT__entry(
> + __field(struct extent_state *, state)
> + __field(unsigned long, ip)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(state, state)
> + tp_assign(ip, IP)
> + ),
> +
> + TP_printk(" state=%p; caller = %pF", __entry->state,
> + (void *)__entry->ip)
> +)
> +#endif
> +
> +#endif /* _TRACE_BTRFS_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/compaction.h b/instrumentation/events/lttng-module/compaction.h
> new file mode 100644
> index 0000000..1b237fa
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/compaction.h
> @@ -0,0 +1,74 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM compaction
> +
> +#if !defined(_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_COMPACTION_H
> +
> +#include <linux/types.h>
> +#include <linux/tracepoint.h>
> +#include <trace/events/gfpflags.h>
> +
> +DECLARE_EVENT_CLASS(mm_compaction_isolate_template,
> +
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_scanned)
> + __field(unsigned long, nr_taken)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(nr_scanned, nr_scanned)
> + tp_assign(nr_taken, nr_taken)
> + ),
> +
> + TP_printk("nr_scanned=%lu nr_taken=%lu",
> + __entry->nr_scanned,
> + __entry->nr_taken)
> +)
> +
> +DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_migratepages,
> +
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken)
> +)
> +
> +DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_freepages,
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken)
> +)
> +
> +TRACE_EVENT(mm_compaction_migratepages,
> +
> + TP_PROTO(unsigned long nr_migrated,
> + unsigned long nr_failed),
> +
> + TP_ARGS(nr_migrated, nr_failed),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_migrated)
> + __field(unsigned long, nr_failed)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(nr_migrated, nr_migrated)
> + tp_assign(nr_failed, nr_failed)
> + ),
> +
> + TP_printk("nr_migrated=%lu nr_failed=%lu",
> + __entry->nr_migrated,
> + __entry->nr_failed)
> +)
> +
> +
> +#endif /* _TRACE_COMPACTION_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/ext4.h b/instrumentation/events/lttng-module/ext4.h
> new file mode 100644
> index 0000000..661a5a9
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/ext4.h
> @@ -0,0 +1,2398 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM ext4
> +
> +#if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_EXT4_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +#include <linux/version.h>
> +
> +#ifndef _TRACE_EXT4_DEF_
> +#define _TRACE_EXT4_DEF_
> +struct ext4_allocation_context;
> +struct ext4_allocation_request;
> +struct ext4_prealloc_space;
> +struct ext4_inode_info;
> +struct mpage_da_data;
> +struct ext4_map_blocks;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> +struct ext4_extent;
> +#endif
> +#endif
> +
> +#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> +#define TP_MODE_T __u16
> +#else
> +#define TP_MODE_T umode_t
> +#endif
> +
> +TRACE_EVENT(ext4_free_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( uid_t, uid )
> + __field( gid_t, gid )
> + __field( __u64, blocks )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
> + tp_assign(uid, i_uid_read(inode))
> + tp_assign(gid, i_gid_read(inode))
> +#else
> + tp_assign(uid, inode->i_uid)
> + tp_assign(gid, inode->i_gid)
> +#endif
> + tp_assign(blocks, inode->i_blocks)
> + tp_assign(mode, inode->i_mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->mode,
> + __entry->uid, __entry->gid, __entry->blocks)
> +)
> +
> +TRACE_EVENT(ext4_request_inode,
> + TP_PROTO(struct inode *dir, int mode),
> +
> + TP_ARGS(dir, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, dir )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, dir->i_sb->s_dev)
> + tp_assign(dir, dir->i_ino)
> + tp_assign(mode, mode)
> + ),
> +
> + TP_printk("dev %d,%d dir %lu mode 0%o",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->dir, __entry->mode)
> +)
> +
> +TRACE_EVENT(ext4_allocate_inode,
> + TP_PROTO(struct inode *inode, struct inode *dir, int mode),
> +
> + TP_ARGS(inode, dir, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, dir )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(dir, dir->i_ino)
> + tp_assign(mode, mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->dir, __entry->mode)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> +TRACE_EVENT(ext4_evict_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, nlink )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(nlink, inode->i_nlink)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu nlink %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->nlink)
> +)
> +
> +TRACE_EVENT(ext4_drop_inode,
> + TP_PROTO(struct inode *inode, int drop),
> +
> + TP_ARGS(inode, drop),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, drop )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(drop, drop)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu drop %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->drop)
> +)
> +
> +TRACE_EVENT(ext4_mark_inode_dirty,
> + TP_PROTO(struct inode *inode, unsigned long IP),
> +
> + TP_ARGS(inode, IP),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field(unsigned long, ip )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(ip, IP)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu caller %pF",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, (void *)__entry->ip)
> +)
> +
> +TRACE_EVENT(ext4_begin_ordered_truncate,
> + TP_PROTO(struct inode *inode, loff_t new_size),
> +
> + TP_ARGS(inode, new_size),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, new_size )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(new_size, new_size)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu new_size %lld",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->new_size)
> +)
> +#endif
> +
> +DECLARE_EVENT_CLASS(ext4__write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, len )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, pos)
> + tp_assign(len, len)
> + tp_assign(flags, flags)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %u flags %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->flags)
> +)
> +
> +DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags)
> +)
> +
> +DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__write_end,
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, len )
> + __field( unsigned int, copied )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, pos)
> + tp_assign(len, len)
> + tp_assign(copied, copied)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->copied)
> +)
> +
> +DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +)
> +
> +DEFINE_EVENT(ext4__write_end, ext4_writeback_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +)
> +
> +DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +)
> +
> +DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +)
> +
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0))
> +TRACE_EVENT(ext4_writepage,
> + TP_PROTO(struct inode *inode, struct page *page),
> +
> + TP_ARGS(inode, page),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(index, page->index)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu page_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->index)
> +)
> +#endif
> +
> +TRACE_EVENT(ext4_da_writepages,
> + TP_PROTO(struct inode *inode, struct writeback_control *wbc),
> +
> + TP_ARGS(inode, wbc),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( long, nr_to_write )
> + __field( long, pages_skipped )
> + __field( loff_t, range_start )
> + __field( loff_t, range_end )
> + __field( pgoff_t, writeback_index )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + __field( int, sync_mode )
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
> + __field( char, nonblocking )
> +#endif
> + __field( char, for_kupdate )
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
> + __field( char, for_reclaim )
> +#endif
> + __field( char, range_cyclic )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(nr_to_write, wbc->nr_to_write)
> + tp_assign(pages_skipped, wbc->pages_skipped)
> + tp_assign(range_start, wbc->range_start)
> + tp_assign(range_end, wbc->range_end)
> + tp_assign(writeback_index, inode->i_mapping->writeback_index)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + tp_assign(sync_mode, wbc->sync_mode)
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
> + tp_assign(nonblocking, wbc->nonblocking)
> +#endif
> + tp_assign(for_kupdate, wbc->for_kupdate)
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
> + tp_assign(for_reclaim, wbc->for_reclaim)
> +#endif
> + tp_assign(range_cyclic, wbc->range_cyclic)
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
> + "range_start %lld range_end %lld sync_mode %d "
> + "for_kupdate %d range_cyclic %d writeback_index %lu",
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
> + "range_start %llu range_end %llu "
> + "for_kupdate %d for_reclaim %d "
> + "range_cyclic %d writeback_index %lu",
> +#else
> + TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
> + "range_start %llu range_end %llu "
> + "nonblocking %d for_kupdate %d for_reclaim %d "
> + "range_cyclic %d writeback_index %lu",
> +#endif
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->nr_to_write,
> + __entry->pages_skipped, __entry->range_start,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + __entry->range_end, __entry->sync_mode,
> + __entry->for_kupdate, __entry->range_cyclic,
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + __entry->range_end,
> + __entry->for_kupdate, __entry->for_reclaim,
> + __entry->range_cyclic,
> +#else
> + __entry->range_end, __entry->nonblocking,
> + __entry->for_kupdate, __entry->for_reclaim,
> + __entry->range_cyclic,
> +#endif
> + (unsigned long) __entry->writeback_index)
> +)
> +
> +TRACE_EVENT(ext4_da_write_pages,
> + TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
> +
> + TP_ARGS(inode, mpd),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, b_blocknr )
> + __field( __u32, b_size )
> + __field( __u32, b_state )
> + __field( unsigned long, first_page )
> + __field( int, io_done )
> + __field( int, pages_written )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + __field( int, sync_mode )
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(b_blocknr, mpd->b_blocknr)
> + tp_assign(b_size, mpd->b_size)
> + tp_assign(b_state, mpd->b_state)
> + tp_assign(first_page, mpd->first_page)
> + tp_assign(io_done, mpd->io_done)
> + tp_assign(pages_written, mpd->pages_written)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + tp_assign(sync_mode, mpd->wbc->sync_mode)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
> + "first_page %lu io_done %d pages_written %d sync_mode %d",
> +#else
> + TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
> + "first_page %lu io_done %d pages_written %d",
> +#endif
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->b_blocknr, __entry->b_size,
> + __entry->b_state, __entry->first_page,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + __entry->io_done, __entry->pages_written,
> + __entry->sync_mode
> +#else
> + __entry->io_done, __entry->pages_written
> +#endif
> + )
> +)
> +
> +TRACE_EVENT(ext4_da_writepages_result,
> + TP_PROTO(struct inode *inode, struct writeback_control *wbc,
> + int ret, int pages_written),
> +
> + TP_ARGS(inode, wbc, ret, pages_written),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + __field( int, pages_written )
> + __field( long, pages_skipped )
> + __field( pgoff_t, writeback_index )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + __field( int, sync_mode )
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33))
> + __field( char, encountered_congestion )
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + __field( char, more_io )
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
> + __field( char, no_nrwrite_index_update )
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(ret, ret)
> + tp_assign(pages_written, pages_written)
> + tp_assign(pages_skipped, wbc->pages_skipped)
> + tp_assign(writeback_index, inode->i_mapping->writeback_index)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + tp_assign(sync_mode, wbc->sync_mode)
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33))
> + tp_assign(encountered_congestion, wbc->encountered_congestion)
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + tp_assign(more_io, wbc->more_io)
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
> + tp_assign(no_nrwrite_index_update, wbc->no_nrwrite_index_update)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + "sync_mode %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->sync_mode,
> + (unsigned long) __entry->writeback_index)
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + " more_io %d sync_mode %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->more_io, __entry->sync_mode,
> + (unsigned long) __entry->writeback_index)
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + " more_io %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->more_io,
> + (unsigned long) __entry->writeback_index)
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + " more_io %d no_nrwrite_index_update %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->more_io, __entry->no_nrwrite_index_update,
> + (unsigned long) __entry->writeback_index)
> +#else
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + " congestion %d"
> + " more_io %d no_nrwrite_index_update %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->encountered_congestion,
> + __entry->more_io, __entry->no_nrwrite_index_update,
> + (unsigned long) __entry->writeback_index)
> +#endif
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> +DECLARE_EVENT_CLASS(ext4__page_op,
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, page->mapping->host->i_sb->s_dev)
> + tp_assign(ino, page->mapping->host->i_ino)
> + tp_assign(index, page->index)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu page_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->index)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
> +DEFINE_EVENT(ext4__page_op, ext4_writepage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +)
> +#endif
> +
> +DEFINE_EVENT(ext4__page_op, ext4_readpage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +)
> +
> +DEFINE_EVENT(ext4__page_op, ext4_releasepage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +)
> +
> +TRACE_EVENT(ext4_invalidatepage,
> + TP_PROTO(struct page *page, unsigned long offset),
> +
> + TP_ARGS(page, offset),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( unsigned long, offset )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, page->mapping->host->i_sb->s_dev)
> + tp_assign(ino, page->mapping->host->i_ino)
> + tp_assign(index, page->index)
> + tp_assign(offset, offset)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->index, __entry->offset)
> +)
> +#endif
> +
> +TRACE_EVENT(ext4_discard_blocks,
> + TP_PROTO(struct super_block *sb, unsigned long long blk,
> + unsigned long long count),
> +
> + TP_ARGS(sb, blk, count),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( __u64, blk )
> + __field( __u64, count )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(blk, blk)
> + tp_assign(count, count)
> + ),
> +
> + TP_printk("dev %d,%d blk %llu count %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->blk, __entry->count)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__mb_new_pa,
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, pa_pstart )
> + __field( __u64, pa_lstart )
> + __field( __u32, pa_len )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, ac->ac_sb->s_dev)
> + tp_assign(ino, ac->ac_inode->i_ino)
> + tp_assign(pa_pstart, pa->pa_pstart)
> + tp_assign(pa_lstart, pa->pa_lstart)
> + tp_assign(pa_len, pa->pa_len)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
> +)
> +
> +DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
> +
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa)
> +)
> +
> +DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
> +
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa)
> +)
> +
> +TRACE_EVENT(ext4_mb_release_inode_pa,
> + TP_PROTO(
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0))
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + struct super_block *sb,
> + struct inode *inode,
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> + struct super_block *sb,
> + struct ext4_allocation_context *ac,
> +#else
> + struct ext4_allocation_context *ac,
> +#endif
> +#endif
> + struct ext4_prealloc_space *pa,
> + unsigned long long block, unsigned int count),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
> + TP_ARGS(pa, block, count),
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_ARGS(sb, inode, pa, block, count),
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> + TP_ARGS(sb, ac, pa, block, count),
> +#else
> + TP_ARGS(ac, pa, block, count),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( __u32, count )
> +
> + ),
> +
> + TP_fast_assign(
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
> + tp_assign(dev, pa->pa_inode->i_sb->s_dev)
> + tp_assign(ino, pa->pa_inode->i_ino)
> +#else
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> + tp_assign(dev, sb->s_dev)
> +#else
> + tp_assign(dev, ac->ac_sb->s_dev)
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + tp_assign(ino, inode->i_ino)
> +#else
> + tp_assign(ino, (ac && ac->ac_inode) ? ac->ac_inode->i_ino : 0)
> +#endif
> +#endif
> + tp_assign(block, block)
> + tp_assign(count, count)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu block %llu count %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->block, __entry->count)
> +)
> +
> +TRACE_EVENT(ext4_mb_release_group_pa,
> +
> +#if (LTTNG_KERNEL_RANGE(3,0,0, 3,3,0))
> + TP_PROTO(struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(pa),
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(sb, pa),
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> + TP_PROTO(struct super_block *sb,
> + struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(sb, ac, pa),
> +#else
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
> + __field( ino_t, ino )
> +#endif
> + __field( __u64, pa_pstart )
> + __field( __u32, pa_len )
> +
> + ),
> +
> + TP_fast_assign(
> +#if (LTTNG_KERNEL_RANGE(3,0,0, 3,3,0))
> + tp_assign(dev, pa->pa_inode->i_sb->s_dev)
> +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> + tp_assign(dev, sb->s_dev)
> +#else
> + tp_assign(dev, ac->ac_sb->s_dev)
> +#endif
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
> + tp_assign(ino, (ac && ac->ac_inode) ? ac->ac_inode->i_ino : 0)
> +#endif
> + tp_assign(pa_pstart, pa->pa_pstart)
> + tp_assign(pa_len, pa->pa_len)
> + ),
> +
> + TP_printk("dev %d,%d pstart %llu len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->pa_pstart, __entry->pa_len)
> +)
> +
> +TRACE_EVENT(ext4_discard_preallocations,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino)
> +)
> +
> +TRACE_EVENT(ext4_mb_discard_preallocations,
> + TP_PROTO(struct super_block *sb, int needed),
> +
> + TP_ARGS(sb, needed),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( int, needed )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(needed, needed)
> + ),
> +
> + TP_printk("dev %d,%d needed %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->needed)
> +)
> +
> +TRACE_EVENT(ext4_request_blocks,
> + TP_PROTO(struct ext4_allocation_request *ar),
> +
> + TP_ARGS(ar),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( unsigned int, len )
> + __field( __u32, logical )
> + __field( __u32, lleft )
> + __field( __u32, lright )
> + __field( __u64, goal )
> + __field( __u64, pleft )
> + __field( __u64, pright )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, ar->inode->i_sb->s_dev)
> + tp_assign(ino, ar->inode->i_ino)
> + tp_assign(len, ar->len)
> + tp_assign(logical, ar->logical)
> + tp_assign(goal, ar->goal)
> + tp_assign(lleft, ar->lleft)
> + tp_assign(lright, ar->lright)
> + tp_assign(pleft, ar->pleft)
> + tp_assign(pright, ar->pright)
> + tp_assign(flags, ar->flags)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu flags %u len %u lblk %u goal %llu "
> + "lleft %u lright %u pleft %llu pright %llu ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->flags,
> + __entry->len, __entry->logical, __entry->goal,
> + __entry->lleft, __entry->lright, __entry->pleft,
> + __entry->pright)
> +)
> +
> +TRACE_EVENT(ext4_allocate_blocks,
> + TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
> +
> + TP_ARGS(ar, block),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( unsigned int, len )
> + __field( __u32, logical )
> + __field( __u32, lleft )
> + __field( __u32, lright )
> + __field( __u64, goal )
> + __field( __u64, pleft )
> + __field( __u64, pright )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, ar->inode->i_sb->s_dev)
> + tp_assign(ino, ar->inode->i_ino)
> + tp_assign(block, block)
> + tp_assign(len, ar->len)
> + tp_assign(logical, ar->logical)
> + tp_assign(goal, ar->goal)
> + tp_assign(lleft, ar->lleft)
> + tp_assign(lright, ar->lright)
> + tp_assign(pleft, ar->pleft)
> + tp_assign(pright, ar->pright)
> + tp_assign(flags, ar->flags)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %u "
> + "goal %llu lleft %u lright %u pleft %llu pright %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->flags,
> + __entry->len, __entry->block, __entry->logical,
> + __entry->goal, __entry->lleft, __entry->lright,
> + __entry->pleft, __entry->pright)
> +)
> +
> +TRACE_EVENT(ext4_free_blocks,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
> + int flags),
> +
> + TP_ARGS(inode, block, count, flags),
> +#else
> + TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
> + int metadata),
> +
> + TP_ARGS(inode, block, count, metadata),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( unsigned long, count )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + __field( int, flags )
> + __field( TP_MODE_T, mode )
> +#else
> + __field( int, metadata )
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(block, block)
> + tp_assign(count, count)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + tp_assign(flags, flags)
> + tp_assign(mode, inode->i_mode)
> +#else
> + tp_assign(metadata, metadata)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
> +#else
> + TP_printk("dev %d,%d ino %lu block %llu count %lu metadata %d",
> +#endif
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> + __entry->mode, __entry->block, __entry->count,
> + __entry->flags)
> +#else
> + __entry->block, __entry->count, __entry->metadata)
> +#endif
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> +TRACE_EVENT(ext4_sync_file_enter,
> +#else
> +TRACE_EVENT(ext4_sync_file,
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
> + TP_PROTO(struct file *file, int datasync),
> +
> + TP_ARGS(file, datasync),
> +#else
> + TP_PROTO(struct file *file, struct dentry *dentry, int datasync),
> +
> + TP_ARGS(file, dentry, datasync),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( int, datasync )
> + ),
> +
> + TP_fast_assign(
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
> + tp_assign(dev, file->f_path.dentry->d_inode->i_sb->s_dev)
> + tp_assign(ino, file->f_path.dentry->d_inode->i_ino)
> + tp_assign(datasync, datasync)
> + tp_assign(parent, file->f_path.dentry->d_parent->d_inode->i_ino)
> +#else
> + tp_assign(dev, dentry->d_inode->i_sb->s_dev)
> + tp_assign(ino, dentry->d_inode->i_ino)
> + tp_assign(datasync, datasync)
> + tp_assign(parent, dentry->d_parent->d_inode->i_ino)
> +#endif
> + ),
> +
> + TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->parent, __entry->datasync)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> +TRACE_EVENT(ext4_sync_file_exit,
> + TP_PROTO(struct inode *inode, int ret),
> +
> + TP_ARGS(inode, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->ret)
> +)
> +#endif
> +
> +TRACE_EVENT(ext4_sync_fs,
> + TP_PROTO(struct super_block *sb, int wait),
> +
> + TP_ARGS(sb, wait),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( int, wait )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(wait, wait)
> + ),
> +
> + TP_printk("dev %d,%d wait %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->wait)
> +)
> +
> +TRACE_EVENT(ext4_alloc_da_blocks,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( unsigned int, data_blocks )
> + __field( unsigned int, meta_blocks )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(data_blocks, EXT4_I(inode)->i_reserved_data_blocks)
> + tp_assign(meta_blocks, EXT4_I(inode)->i_reserved_meta_blocks)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->data_blocks, __entry->meta_blocks)
> +)
> +
> +TRACE_EVENT(ext4_mballoc_alloc,
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u32, orig_logical )
> + __field( int, orig_start )
> + __field( __u32, orig_group )
> + __field( int, orig_len )
> + __field( __u32, goal_logical )
> + __field( int, goal_start )
> + __field( __u32, goal_group )
> + __field( int, goal_len )
> + __field( __u32, result_logical )
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + __field( __u16, found )
> + __field( __u16, groups )
> + __field( __u16, buddy )
> + __field( __u16, flags )
> + __field( __u16, tail )
> + __field( __u8, cr )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, ac->ac_inode->i_sb->s_dev)
> + tp_assign(ino, ac->ac_inode->i_ino)
> + tp_assign(orig_logical, ac->ac_o_ex.fe_logical)
> + tp_assign(orig_start, ac->ac_o_ex.fe_start)
> + tp_assign(orig_group, ac->ac_o_ex.fe_group)
> + tp_assign(orig_len, ac->ac_o_ex.fe_len)
> + tp_assign(goal_logical, ac->ac_g_ex.fe_logical)
> + tp_assign(goal_start, ac->ac_g_ex.fe_start)
> + tp_assign(goal_group, ac->ac_g_ex.fe_group)
> + tp_assign(goal_len, ac->ac_g_ex.fe_len)
> + tp_assign(result_logical, ac->ac_f_ex.fe_logical)
> + tp_assign(result_start, ac->ac_f_ex.fe_start)
> + tp_assign(result_group, ac->ac_f_ex.fe_group)
> + tp_assign(result_len, ac->ac_f_ex.fe_len)
> + tp_assign(found, ac->ac_found)
> + tp_assign(flags, ac->ac_flags)
> + tp_assign(groups, ac->ac_groups_scanned)
> + tp_assign(buddy, ac->ac_buddy)
> + tp_assign(tail, ac->ac_tail)
> + tp_assign(cr, ac->ac_criteria)
> + ),
> +
> + TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
> + "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
> + "tail %u broken %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->orig_group, __entry->orig_start,
> + __entry->orig_len, __entry->orig_logical,
> + __entry->goal_group, __entry->goal_start,
> + __entry->goal_len, __entry->goal_logical,
> + __entry->result_group, __entry->result_start,
> + __entry->result_len, __entry->result_logical,
> + __entry->found, __entry->groups, __entry->cr,
> + __entry->flags, __entry->tail,
> + __entry->buddy ? 1 << __entry->buddy : 0)
> +)
> +
> +TRACE_EVENT(ext4_mballoc_prealloc,
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u32, orig_logical )
> + __field( int, orig_start )
> + __field( __u32, orig_group )
> + __field( int, orig_len )
> + __field( __u32, result_logical )
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, ac->ac_inode->i_sb->s_dev)
> + tp_assign(ino, ac->ac_inode->i_ino)
> + tp_assign(orig_logical, ac->ac_o_ex.fe_logical)
> + tp_assign(orig_start, ac->ac_o_ex.fe_start)
> + tp_assign(orig_group, ac->ac_o_ex.fe_group)
> + tp_assign(orig_len, ac->ac_o_ex.fe_len)
> + tp_assign(result_logical, ac->ac_b_ex.fe_logical)
> + tp_assign(result_start, ac->ac_b_ex.fe_start)
> + tp_assign(result_group, ac->ac_b_ex.fe_group)
> + tp_assign(result_len, ac->ac_b_ex.fe_len)
> + ),
> +
> + TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->orig_group, __entry->orig_start,
> + __entry->orig_len, __entry->orig_logical,
> + __entry->result_group, __entry->result_start,
> + __entry->result_len, __entry->result_logical)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__mballoc,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len),
> +#else
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
> + __field( __u32, result_logical )
> +#endif
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + ),
> +
> + TP_fast_assign(
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + tp_assign(dev, sb->s_dev)
> + tp_assign(ino, inode ? inode->i_ino : 0)
> + tp_assign(result_start, start)
> + tp_assign(result_group, group)
> + tp_assign(result_len, len)
> +#else
> + tp_assign(dev, ac->ac_sb->s_dev)
> + tp_assign(ino, ac->ac_inode ? ac->ac_inode->i_ino : 0)
> + tp_assign(result_logical, ac->ac_b_ex.fe_logical)
> + tp_assign(result_start, ac->ac_b_ex.fe_start)
> + tp_assign(result_group, ac->ac_b_ex.fe_group)
> + tp_assign(result_len, ac->ac_b_ex.fe_len)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
> +#else
> + TP_printk("dev %d,%d inode %lu extent %u/%d/%u@%u ",
> +#endif
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->result_group, __entry->result_start,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + __entry->result_len
> +#else
> + __entry->result_len, __entry->result_logical
> +#endif
> + )
> +)
> +
> +DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len)
> +#else
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac)
> +#endif
> +)
> +
> +DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len)
> +#else
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac)
> +#endif
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
> +TRACE_EVENT(ext4_forget,
> + TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
> +
> + TP_ARGS(inode, is_metadata, block),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( int, is_metadata )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(block, block)
> + tp_assign(is_metadata, is_metadata)
> + tp_assign(mode, inode->i_mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->is_metadata, __entry->block)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
> +TRACE_EVENT(ext4_da_update_reserve_space,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
> +
> + TP_ARGS(inode, used_blocks, quota_claim),
> +#else
> + TP_PROTO(struct inode *inode, int used_blocks),
> +
> + TP_ARGS(inode, used_blocks),
> +#endif
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, used_blocks )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( int, allocated_meta_blocks )
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + __field( int, quota_claim )
> +#endif
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(i_blocks, inode->i_blocks)
> + tp_assign(used_blocks, used_blocks)
> + tp_assign(reserved_data_blocks,
> + EXT4_I(inode)->i_reserved_data_blocks)
> + tp_assign(reserved_meta_blocks,
> + EXT4_I(inode)->i_reserved_meta_blocks)
> + tp_assign(allocated_meta_blocks,
> + EXT4_I(inode)->i_allocated_meta_blocks)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + tp_assign(quota_claim, quota_claim)
> +#endif
> + tp_assign(mode, inode->i_mode)
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d "
> + "allocated_meta_blocks %d quota_claim %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->used_blocks, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
> + __entry->quota_claim)
> +#else
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d "
> + "allocated_meta_blocks %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->used_blocks, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
> +#endif
> +)
> +
> +TRACE_EVENT(ext4_da_reserve_space,
> + TP_PROTO(struct inode *inode, int md_needed),
> +
> + TP_ARGS(inode, md_needed),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, md_needed )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(i_blocks, inode->i_blocks)
> + tp_assign(md_needed, md_needed)
> + tp_assign(reserved_data_blocks,
> + EXT4_I(inode)->i_reserved_data_blocks)
> + tp_assign(reserved_meta_blocks,
> + EXT4_I(inode)->i_reserved_meta_blocks)
> + tp_assign(mode, inode->i_mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->md_needed, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks)
> +)
> +
> +TRACE_EVENT(ext4_da_release_space,
> + TP_PROTO(struct inode *inode, int freed_blocks),
> +
> + TP_ARGS(inode, freed_blocks),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, freed_blocks )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( int, allocated_meta_blocks )
> + __field( TP_MODE_T, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(i_blocks, inode->i_blocks)
> + tp_assign(freed_blocks, freed_blocks)
> + tp_assign(reserved_data_blocks,
> + EXT4_I(inode)->i_reserved_data_blocks)
> + tp_assign(reserved_meta_blocks,
> + EXT4_I(inode)->i_reserved_meta_blocks)
> + tp_assign(allocated_meta_blocks,
> + EXT4_I(inode)->i_allocated_meta_blocks)
> + tp_assign(mode, inode->i_mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d "
> + "allocated_meta_blocks %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->freed_blocks, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
> +DECLARE_EVENT_CLASS(ext4__bitmap_load,
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( __u32, group )
> +
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(group, group)
> + ),
> +
> + TP_printk("dev %d,%d group %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->group)
> +)
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +)
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
> +DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +)
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +)
> +
> +TRACE_EVENT(ext4_direct_IO_enter,
> + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
> +
> + TP_ARGS(inode, offset, len, rw),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned long, len )
> + __field( int, rw )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, offset)
> + tp_assign(len, len)
> + tp_assign(rw, rw)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->rw)
> +)
> +
> +TRACE_EVENT(ext4_direct_IO_exit,
> + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
> + int rw, int ret),
> +
> + TP_ARGS(inode, offset, len, rw, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned long, len )
> + __field( int, rw )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, offset)
> + tp_assign(len, len)
> + tp_assign(rw, rw)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len,
> + __entry->rw, __entry->ret)
> +)
> +
> +TRACE_EVENT(ext4_fallocate_enter,
> + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
> +
> + TP_ARGS(inode, offset, len, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( loff_t, len )
> + __field( int, mode )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, offset)
> + tp_assign(len, len)
> + tp_assign(mode, mode)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lld mode %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->pos,
> + __entry->len, __entry->mode)
> +)
> +
> +TRACE_EVENT(ext4_fallocate_exit,
> + TP_PROTO(struct inode *inode, loff_t offset,
> + unsigned int max_blocks, int ret),
> +
> + TP_ARGS(inode, offset, max_blocks, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, blocks )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pos, offset)
> + tp_assign(blocks, max_blocks)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->blocks,
> + __entry->ret)
> +)
> +
> +TRACE_EVENT(ext4_unlink_enter,
> + TP_PROTO(struct inode *parent, struct dentry *dentry),
> +
> + TP_ARGS(parent, dentry),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( loff_t, size )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, dentry->d_inode->i_sb->s_dev)
> + tp_assign(ino, dentry->d_inode->i_ino)
> + tp_assign(parent, parent->i_ino)
> + tp_assign(size, dentry->d_inode->i_size)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu size %lld parent %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->size,
> + (unsigned long) __entry->parent)
> +)
> +
> +TRACE_EVENT(ext4_unlink_exit,
> + TP_PROTO(struct dentry *dentry, int ret),
> +
> + TP_ARGS(dentry, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, dentry->d_inode->i_sb->s_dev)
> + tp_assign(ino, dentry->d_inode->i_ino)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->ret)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__truncate,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, blocks )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(blocks, inode->i_blocks)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu blocks %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->blocks)
> +)
> +
> +DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +)
> +
> +DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> +/* 'ux' is the uninitialized extent. */
> +TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + struct ext4_extent *ux),
> +
> + TP_ARGS(inode, map, ux),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, m_lblk )
> + __field( unsigned, m_len )
> + __field( ext4_lblk_t, u_lblk )
> + __field( unsigned, u_len )
> + __field( ext4_fsblk_t, u_pblk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(m_lblk, map->m_lblk)
> + tp_assign(m_len, map->m_len)
> + tp_assign(u_lblk, le32_to_cpu(ux->ee_block))
> + tp_assign(u_len, ext4_ext_get_actual_len(ux))
> + tp_assign(u_pblk, ext4_ext_pblock(ux))
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
> + "u_pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->m_lblk, __entry->m_len,
> + __entry->u_lblk, __entry->u_len, __entry->u_pblk)
> +)
> +
> +/*
> + * 'ux' is the uninitialized extent.
> + * 'ix' is the initialized extent to which blocks are transferred.
> + */
> +TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + struct ext4_extent *ux, struct ext4_extent *ix),
> +
> + TP_ARGS(inode, map, ux, ix),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, m_lblk )
> + __field( unsigned, m_len )
> + __field( ext4_lblk_t, u_lblk )
> + __field( unsigned, u_len )
> + __field( ext4_fsblk_t, u_pblk )
> + __field( ext4_lblk_t, i_lblk )
> + __field( unsigned, i_len )
> + __field( ext4_fsblk_t, i_pblk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(m_lblk, map->m_lblk)
> + tp_assign(m_len, map->m_len)
> + tp_assign(u_lblk, le32_to_cpu(ux->ee_block))
> + tp_assign(u_len, ext4_ext_get_actual_len(ux))
> + tp_assign(u_pblk, ext4_ext_pblock(ux))
> + tp_assign(i_lblk, le32_to_cpu(ix->ee_block))
> + tp_assign(i_len, ext4_ext_get_actual_len(ix))
> + tp_assign(i_pblk, ext4_ext_pblock(ix))
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
> + "u_lblk %u u_len %u u_pblk %llu "
> + "i_lblk %u i_len %u i_pblk %llu ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->m_lblk, __entry->m_len,
> + __entry->u_lblk, __entry->u_len, __entry->u_pblk,
> + __entry->i_lblk, __entry->i_len, __entry->i_pblk)
> +)
> +#endif
> +
> +DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned int len, unsigned int flags),
> +
> + TP_ARGS(inode, lblk, len, flags),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(lblk, lblk)
> + tp_assign(len, len)
> + tp_assign(flags, flags)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->len, __entry->flags)
> +)
> +
> +DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned len, unsigned flags),
> +
> + TP_ARGS(inode, lblk, len, flags)
> +)
> +
> +DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned len, unsigned flags),
> +
> + TP_ARGS(inode, lblk, len, flags)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned int len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pblk, pblk)
> + tp_assign(lblk, lblk)
> + tp_assign(len, len)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->pblk,
> + __entry->len, __entry->ret)
> +)
> +
> +DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret)
> +)
> +
> +DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret)
> +)
> +
> +TRACE_EVENT(ext4_ext_load_extent,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
> +
> + TP_ARGS(inode, lblk, pblk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pblk, pblk)
> + tp_assign(lblk, lblk)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->pblk)
> +)
> +
> +TRACE_EVENT(ext4_load_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + ),
> +
> + TP_printk("dev %d,%d ino %ld",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> +TRACE_EVENT(ext4_journal_start,
> + TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
> +
> + TP_ARGS(sb, nblocks, IP),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field(unsigned long, ip )
> + __field( int, nblocks )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(ip, IP)
> + tp_assign(nblocks, nblocks)
> + ),
> +
> + TP_printk("dev %d,%d nblocks %d caller %pF",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->nblocks, (void *)__entry->ip)
> +)
> +
> +DECLARE_EVENT_CLASS(ext4__trim,
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len),
> +
> + TP_STRUCT__entry(
> + __field( int, dev_major )
> + __field( int, dev_minor )
> + __field( __u32, group )
> + __field( int, start )
> + __field( int, len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev_major, MAJOR(sb->s_dev))
> + tp_assign(dev_minor, MINOR(sb->s_dev))
> + tp_assign(group, group)
> + tp_assign(start, start)
> + tp_assign(len, len)
> + ),
> +
> + TP_printk("dev %d,%d group %u, start %d, len %d",
> + __entry->dev_major, __entry->dev_minor,
> + __entry->group, __entry->start, __entry->len)
> +)
> +
> +DEFINE_EVENT(ext4__trim, ext4_trim_extent,
> +
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len)
> +)
> +
> +DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
> +
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> +TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + unsigned int allocated, ext4_fsblk_t newblock),
> +
> + TP_ARGS(inode, map, allocated, newblock),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, flags )
> + __field( ext4_lblk_t, lblk )
> + __field( ext4_fsblk_t, pblk )
> + __field( unsigned int, len )
> + __field( unsigned int, allocated )
> + __field( ext4_fsblk_t, newblk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(flags, map->m_flags)
> + tp_assign(lblk, map->m_lblk)
> + tp_assign(pblk, map->m_pblk)
> + tp_assign(len, map->m_len)
> + tp_assign(allocated, allocated)
> + tp_assign(newblk, newblock)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %d"
> + "allocated %d newblock %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
> + __entry->len, __entry->flags,
> + (unsigned int) __entry->allocated,
> + (unsigned long long) __entry->newblk)
> +)
> +
> +TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
> + TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
> +
> + TP_ARGS(sb, map, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( unsigned int, flags )
> + __field( ext4_lblk_t, lblk )
> + __field( ext4_fsblk_t, pblk )
> + __field( unsigned int, len )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, sb->s_dev)
> + tp_assign(flags, map->m_flags)
> + tp_assign(lblk, map->m_lblk)
> + tp_assign(pblk, map->m_pblk)
> + tp_assign(len, map->m_len)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->lblk, (unsigned long long) __entry->pblk,
> + __entry->len, __entry->flags, __entry->ret)
> +)
> +
> +TRACE_EVENT(ext4_ext_put_in_cache,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
> + ext4_fsblk_t start),
> +
> + TP_ARGS(inode, lblk, len, start),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( ext4_fsblk_t, start )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(lblk, lblk)
> + tp_assign(len, len)
> + tp_assign(start, start)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->len,
> + (unsigned long long) __entry->start)
> +)
> +
> +TRACE_EVENT(ext4_ext_in_cache,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
> +
> + TP_ARGS(inode, lblk, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(lblk, lblk)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->ret)
> +
> +)
> +
> +TRACE_EVENT(ext4_find_delalloc_range,
> + TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
> + int reverse, int found, ext4_lblk_t found_blk),
> +
> + TP_ARGS(inode, from, to, reverse, found, found_blk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, from )
> + __field( ext4_lblk_t, to )
> + __field( int, reverse )
> + __field( int, found )
> + __field( ext4_lblk_t, found_blk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(from, from)
> + tp_assign(to, to)
> + tp_assign(reverse, reverse)
> + tp_assign(found, found)
> + tp_assign(found_blk, found_blk)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
> + "(blk = %u)",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->from, (unsigned) __entry->to,
> + __entry->reverse, __entry->found,
> + (unsigned) __entry->found_blk)
> +)
> +
> +TRACE_EVENT(ext4_get_reserved_cluster_alloc,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
> +
> + TP_ARGS(inode, lblk, len),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(lblk, lblk)
> + tp_assign(len, len)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->len)
> +)
> +
> +TRACE_EVENT(ext4_ext_show_extent,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
> + unsigned short len),
> +
> + TP_ARGS(inode, lblk, pblk, len),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned short, len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pblk, pblk)
> + tp_assign(lblk, lblk)
> + tp_assign(len, len)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + (unsigned long long) __entry->pblk,
> + (unsigned short) __entry->len)
> +)
> +
> +TRACE_EVENT(ext4_remove_blocks,
> + TP_PROTO(struct inode *inode, struct ext4_extent *ex,
> + ext4_lblk_t from, ext4_fsblk_t to,
> + ext4_fsblk_t partial_cluster),
> +
> + TP_ARGS(inode, ex, from, to, partial_cluster),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, from )
> + __field( ext4_lblk_t, to )
> + __field( ext4_fsblk_t, partial )
> + __field( ext4_fsblk_t, ee_pblk )
> + __field( ext4_lblk_t, ee_lblk )
> + __field( unsigned short, ee_len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(from, from)
> + tp_assign(to, to)
> + tp_assign(partial, partial_cluster)
> + tp_assign(ee_pblk, ext4_ext_pblock(ex))
> + tp_assign(ee_lblk, cpu_to_le32(ex->ee_block))
> + tp_assign(ee_len, ext4_ext_get_actual_len(ex))
> + ),
> +
> + TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
> + "from %u to %u partial_cluster %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->ee_lblk,
> + (unsigned long long) __entry->ee_pblk,
> + (unsigned short) __entry->ee_len,
> + (unsigned) __entry->from,
> + (unsigned) __entry->to,
> + (unsigned) __entry->partial)
> +)
> +
> +TRACE_EVENT(ext4_ext_rm_leaf,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start,
> + struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
> +
> + TP_ARGS(inode, start, ex, partial_cluster),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, partial )
> + __field( ext4_lblk_t, start )
> + __field( ext4_lblk_t, ee_lblk )
> + __field( ext4_fsblk_t, ee_pblk )
> + __field( short, ee_len )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(partial, partial_cluster)
> + tp_assign(start, start)
> + tp_assign(ee_lblk, le32_to_cpu(ex->ee_block))
> + tp_assign(ee_pblk, ext4_ext_pblock(ex))
> + tp_assign(ee_len, ext4_ext_get_actual_len(ex))
> + ),
> +
> + TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
> + "partial_cluster %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + (unsigned) __entry->ee_lblk,
> + (unsigned long long) __entry->ee_pblk,
> + (unsigned short) __entry->ee_len,
> + (unsigned) __entry->partial)
> +)
> +
> +TRACE_EVENT(ext4_ext_rm_idx,
> + TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
> +
> + TP_ARGS(inode, pblk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(pblk, pblk)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu index_pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long long) __entry->pblk)
> +)
> +
> +TRACE_EVENT(ext4_ext_remove_space,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
> +
> + TP_ARGS(inode, start, depth),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, start )
> + __field( int, depth )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(start, start)
> + tp_assign(depth, depth)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu since %u depth %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + __entry->depth)
> +)
> +
> +TRACE_EVENT(ext4_ext_remove_space_done,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
> + ext4_lblk_t partial, unsigned short eh_entries),
> +
> + TP_ARGS(inode, start, depth, partial, eh_entries),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, start )
> + __field( int, depth )
> + __field( ext4_lblk_t, partial )
> + __field( unsigned short, eh_entries )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(dev, inode->i_sb->s_dev)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(start, start)
> + tp_assign(depth, depth)
> + tp_assign(partial, partial)
> + tp_assign(eh_entries, eh_entries)
> + ),
> +
> + TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
> + "remaining_entries %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + __entry->depth,
> + (unsigned) __entry->partial,
> + (unsigned short) __entry->eh_entries)
> +)
> +#endif
> +
> +#endif /* _TRACE_EXT4_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/printk.h b/instrumentation/events/lttng-module/printk.h
> new file mode 100644
> index 0000000..4c744f9
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/printk.h
> @@ -0,0 +1,64 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM printk
> +
> +#if !defined(_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_PRINTK_H
> +
> +#include <linux/tracepoint.h>
> +#include <linux/version.h>
> +
> +#define MSG_TRACE_MAX_LEN 2048
> +
> +TRACE_EVENT_CONDITION(console,
> + TP_PROTO(const char *log_buf, unsigned start, unsigned end,
> + unsigned log_buf_len),
> +
> + TP_ARGS(log_buf, start, end, log_buf_len),
> +
> + TP_CONDITION(start != end),
> +
> + TP_STRUCT__entry(
> + __dynamic_array_text(char, msg,
> + min_t(unsigned, end - start, MSG_TRACE_MAX_LEN) + 1)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy_dyn(msg,
> + ({
> + char lmsg[MSG_TRACE_MAX_LEN + 1];
> +
> + if ((end - start) > MSG_TRACE_MAX_LEN)
> + start = end - MSG_TRACE_MAX_LEN;
> +
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
> + if ((start & (log_buf_len - 1)) >
> + (end & (log_buf_len - 1))) {
> + memcpy(lmsg,
> + log_buf +
> + (start & (log_buf_len - 1)),
> + log_buf_len -
> + (start & (log_buf_len - 1)));
> + memcpy(lmsg + log_buf_len -
> + (start & (log_buf_len - 1)),
> + log_buf,
> + end & (log_buf_len - 1));
> + } else
> + memcpy(lmsg,
> + log_buf +
> + (start & (log_buf_len - 1)),
> + end - start);
> +#else
> + memcpy(lmsg, log_buf + start, end - start);
> +#endif
> + lmsg[end - start] = 0;
> + lmsg;
> + })
> + )
> + ),
> +
> + TP_printk("%s", __get_str(msg))
> +)
> +#endif /* _TRACE_PRINTK_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/random.h b/instrumentation/events/lttng-module/random.h
> new file mode 100644
> index 0000000..6ecdd90
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/random.h
> @@ -0,0 +1,134 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM random
> +
> +#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RANDOM_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +
> +DECLARE_EVENT_CLASS(random__mix_pool_bytes,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP),
> +
> + TP_STRUCT__entry(
> + __string( pool_name, pool_name )
> + __field( int, bytes )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(pool_name, pool_name)
> + tp_assign(bytes, bytes)
> + tp_assign(IP, IP)
> + ),
> +
> + TP_printk("%s pool: bytes %d caller %pF",
> + __get_str(pool_name), __entry->bytes, (void *)__entry->IP)
> +)
> +
> +DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP)
> +)
> +
> +DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP)
> +)
> +
> +TRACE_EVENT(credit_entropy_bits,
> + TP_PROTO(const char *pool_name, int bits, int entropy_count,
> + int entropy_total, unsigned long IP),
> +
> + TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP),
> +
> + TP_STRUCT__entry(
> + __string( pool_name, pool_name )
> + __field( int, bits )
> + __field( int, entropy_count )
> + __field( int, entropy_total )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(pool_name, pool_name)
> + tp_assign(bits, bits)
> + tp_assign(entropy_count, entropy_count)
> + tp_assign(entropy_total, entropy_total)
> + tp_assign(IP, IP)
> + ),
> +
> + TP_printk("%s pool: bits %d entropy_count %d entropy_total %d "
> + "caller %pF", __get_str(pool_name), __entry->bits,
> + __entry->entropy_count, __entry->entropy_total,
> + (void *)__entry->IP)
> +)
> +
> +TRACE_EVENT(get_random_bytes,
> + TP_PROTO(int nbytes, unsigned long IP),
> +
> + TP_ARGS(nbytes, IP),
> +
> + TP_STRUCT__entry(
> + __field( int, nbytes )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(nbytes, nbytes)
> + tp_assign(IP, IP)
> + ),
> +
> + TP_printk("nbytes %d caller %pF", __entry->nbytes, (void *)__entry->IP)
> +)
> +
> +DECLARE_EVENT_CLASS(random__extract_entropy,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP),
> +
> + TP_STRUCT__entry(
> + __string( pool_name, pool_name )
> + __field( int, nbytes )
> + __field( int, entropy_count )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(pool_name, pool_name)
> + tp_assign(nbytes, nbytes)
> + tp_assign(entropy_count, entropy_count)
> + tp_assign(IP, IP)
> + ),
> +
> + TP_printk("%s pool: nbytes %d entropy_count %d caller %pF",
> + __get_str(pool_name), __entry->nbytes, __entry->entropy_count,
> + (void *)__entry->IP)
> +)
> +
> +
> +DEFINE_EVENT(random__extract_entropy, extract_entropy,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP)
> +)
> +
> +DEFINE_EVENT(random__extract_entropy, extract_entropy_user,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP)
> +)
> +
> +
> +
> +#endif /* _TRACE_RANDOM_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/rcu.h b/instrumentation/events/lttng-module/rcu.h
> new file mode 100644
> index 0000000..56434aa
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/rcu.h
> @@ -0,0 +1,721 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM rcu
> +
> +#if !defined(_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RCU_H
> +
> +#include <linux/tracepoint.h>
> +#include <linux/version.h>
> +
> +/*
> + * Tracepoint for start/end markers used for utilization calculations.
> + * By convention, the string is of the following forms:
> + *
> + * "Start <activity>" -- Mark the start of the specified activity,
> + * such as "context switch". Nesting is permitted.
> + * "End <activity>" -- Mark the end of the specified activity.
> + *
> + * An "@" character within "<activity>" is a comment character: Data
> + * reduction scripts will ignore the "@" and the remainder of the line.
> + */
> +TRACE_EVENT(rcu_utilization,
> +
> + TP_PROTO(char *s),
> +
> + TP_ARGS(s),
> +
> + TP_STRUCT__entry(
> + __string(s, s)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(s, s)
> + ),
> +
> + TP_printk("%s", __get_str(s))
> +)
> +
> +#ifdef CONFIG_RCU_TRACE
> +
> +#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
> +
> +/*
> + * Tracepoint for grace-period events: starting and ending a grace
> + * period ("start" and "end", respectively), a CPU noting the start
> + * of a new grace period or the end of an old grace period ("cpustart"
> + * and "cpuend", respectively), a CPU passing through a quiescent
> + * state ("cpuqs"), a CPU coming online or going offline ("cpuonl"
> + * and "cpuofl", respectively), and a CPU being kicked for being too
> + * long in dyntick-idle mode ("kick").
> + */
> +TRACE_EVENT(rcu_grace_period,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, char *gpevent),
> +
> + TP_ARGS(rcuname, gpnum, gpevent),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __string(gpevent, gpevent)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_strcpy(gpevent, gpevent)
> + ),
> +
> + TP_printk("%s %lu %s",
> + __get_str(rcuname), __entry->gpnum, __get_str(gpevent))
> +)
> +
> +/*
> + * Tracepoint for grace-period-initialization events. These are
> + * distinguished by the type of RCU, the new grace-period number, the
> + * rcu_node structure level, the starting and ending CPU covered by the
> + * rcu_node structure, and the mask of CPUs that will be waited for.
> + * All but the type of RCU are extracted from the rcu_node structure.
> + */
> +TRACE_EVENT(rcu_grace_period_init,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, u8 level,
> + int grplo, int grphi, unsigned long qsmask),
> +
> + TP_ARGS(rcuname, gpnum, level, grplo, grphi, qsmask),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __field(u8, level)
> + __field(int, grplo)
> + __field(int, grphi)
> + __field(unsigned long, qsmask)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_assign(level, level)
> + tp_assign(grplo, grplo)
> + tp_assign(grphi, grphi)
> + tp_assign(qsmask, qsmask)
> + ),
> +
> + TP_printk("%s %lu %u %d %d %lx",
> + __get_str(rcuname), __entry->gpnum, __entry->level,
> + __entry->grplo, __entry->grphi, __entry->qsmask)
> +)
> +
> +/*
> + * Tracepoint for tasks blocking within preemptible-RCU read-side
> + * critical sections. Track the type of RCU (which one day might
> + * include SRCU), the grace-period number that the task is blocking
> + * (the current or the next), and the task's PID.
> + */
> +TRACE_EVENT(rcu_preempt_task,
> +
> + TP_PROTO(char *rcuname, int pid, unsigned long gpnum),
> +
> + TP_ARGS(rcuname, pid, gpnum),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, pid)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_assign(pid, pid)
> + ),
> +
> + TP_printk("%s %lu %d",
> + __get_str(rcuname), __entry->gpnum, __entry->pid)
> +)
> +
> +/*
> + * Tracepoint for tasks that blocked within a given preemptible-RCU
> + * read-side critical section exiting that critical section. Track the
> + * type of RCU (which one day might include SRCU) and the task's PID.
> + */
> +TRACE_EVENT(rcu_unlock_preempted_task,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, int pid),
> +
> + TP_ARGS(rcuname, gpnum, pid),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, pid)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_assign(pid, pid)
> + ),
> +
> + TP_printk("%s %lu %d", __get_str(rcuname), __entry->gpnum, __entry->pid)
> +)
> +
> +/*
> + * Tracepoint for quiescent-state-reporting events. These are
> + * distinguished by the type of RCU, the grace-period number, the
> + * mask of quiescent lower-level entities, the rcu_node structure level,
> + * the starting and ending CPU covered by the rcu_node structure, and
> + * whether there are any blocked tasks blocking the current grace period.
> + * All but the type of RCU are extracted from the rcu_node structure.
> + */
> +TRACE_EVENT(rcu_quiescent_state_report,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum,
> + unsigned long mask, unsigned long qsmask,
> + u8 level, int grplo, int grphi, int gp_tasks),
> +
> + TP_ARGS(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __field(unsigned long, mask)
> + __field(unsigned long, qsmask)
> + __field(u8, level)
> + __field(int, grplo)
> + __field(int, grphi)
> + __field(u8, gp_tasks)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_assign(mask, mask)
> + tp_assign(qsmask, qsmask)
> + tp_assign(level, level)
> + tp_assign(grplo, grplo)
> + tp_assign(grphi, grphi)
> + tp_assign(gp_tasks, gp_tasks)
> + ),
> +
> + TP_printk("%s %lu %lx>%lx %u %d %d %u",
> + __get_str(rcuname), __entry->gpnum,
> + __entry->mask, __entry->qsmask, __entry->level,
> + __entry->grplo, __entry->grphi, __entry->gp_tasks)
> +)
> +
> +/*
> + * Tracepoint for quiescent states detected by force_quiescent_state().
> + * These trace events include the type of RCU, the grace-period number
> + * that was blocked by the CPU, the CPU itself, and the type of quiescent
> + * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline,
> + * or "kick" when kicking a CPU that has been in dyntick-idle mode for
> + * too long.
> + */
> +TRACE_EVENT(rcu_fqs,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, int cpu, char *qsevent),
> +
> + TP_ARGS(rcuname, gpnum, cpu, qsevent),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, cpu)
> + __string(qsevent, qsevent)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(gpnum, gpnum)
> + tp_assign(cpu, cpu)
> + tp_strcpy(qsevent, qsevent)
> + ),
> +
> + TP_printk("%s %lu %d %s",
> + __get_str(rcuname), __entry->gpnum,
> + __entry->cpu, __get_str(qsevent))
> +)
> +
> +#endif /* #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU) */
> +
> +/*
> + * Tracepoint for dyntick-idle entry/exit events. These take a string
> + * as argument: "Start" for entering dyntick-idle mode, "End" for
> + * leaving it, "--=" for events moving towards idle, and "++=" for events
> + * moving away from idle. "Error on entry: not idle task" and "Error on
> + * exit: not idle task" indicate that a non-idle task is erroneously
> + * toying with the idle loop.
> + *
> + * These events also take a pair of numbers, which indicate the nesting
> + * depth before and after the event of interest. Note that task-related
> + * events use the upper bits of each number, while interrupt-related
> + * events use the lower bits.
> + */
> +TRACE_EVENT(rcu_dyntick,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + TP_PROTO(char *polarity, long long oldnesting, long long newnesting),
> +
> + TP_ARGS(polarity, oldnesting, newnesting),
> +#else
> + TP_PROTO(char *polarity),
> +
> + TP_ARGS(polarity),
> +#endif
> +
> + TP_STRUCT__entry(
> + __string(polarity, polarity)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + __field(long long, oldnesting)
> + __field(long long, newnesting)
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(polarity, polarity)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + tp_assign(oldnesting, oldnesting)
> + tp_assign(newnesting, newnesting)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + TP_printk("%s %llx %llx", __get_str(polarity),
> + __entry->oldnesting, __entry->newnesting)
> +#else
> + TP_printk("%s", __get_str(polarity))
> +#endif
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +/*
> + * Tracepoint for RCU preparation for idle, the goal being to get RCU
> + * processing done so that the current CPU can shut off its scheduling
> + * clock and enter dyntick-idle mode. One way to accomplish this is
> + * to drain all RCU callbacks from this CPU, and the other is to have
> + * done everything RCU requires for the current grace period. In this
> + * latter case, the CPU will be awakened at the end of the current grace
> + * period in order to process the remainder of its callbacks.
> + *
> + * These tracepoints take a string as argument:
> + *
> + * "No callbacks": Nothing to do, no callbacks on this CPU.
> + * "In holdoff": Nothing to do, holding off after unsuccessful attempt.
> + * "Begin holdoff": Attempt failed, don't retry until next jiffy.
> + * "Dyntick with callbacks": Entering dyntick-idle despite callbacks.
> + * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks.
> + * "More callbacks": Still more callbacks, try again to clear them out.
> + * "Callbacks drained": All callbacks processed, off to dyntick idle!
> + * "Timer": Timer fired to cause CPU to continue processing callbacks.
> + * "Demigrate": Timer fired on wrong CPU, woke up correct CPU.
> + * "Cleanup after idle": Idle exited, timer canceled.
> + */
> +TRACE_EVENT(rcu_prep_idle,
> +
> + TP_PROTO(char *reason),
> +
> + TP_ARGS(reason),
> +
> + TP_STRUCT__entry(
> + __string(reason, reason)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(reason, reason)
> + ),
> +
> + TP_printk("%s", __get_str(reason))
> +)
> +#endif
> +
> +/*
> + * Tracepoint for the registration of a single RCU callback function.
> + * The first argument is the type of RCU, the second argument is
> + * a pointer to the RCU callback itself, the third element is the
> + * number of lazy callbacks queued, and the fourth element is the
> + * total number of callbacks queued.
> + */
> +TRACE_EVENT(rcu_callback,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen_lazy,
> + long qlen),
> +
> + TP_ARGS(rcuname, rhp, qlen_lazy, qlen),
> +#else
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen),
> +
> + TP_ARGS(rcuname, rhp, qlen),
> +#endif
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(void *, rhp)
> + __field(void *, func)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + __field(long, qlen_lazy)
> +#endif
> + __field(long, qlen)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(rhp, rhp)
> + tp_assign(func, rhp->func)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + tp_assign(qlen_lazy, qlen_lazy)
> +#endif
> + tp_assign(qlen, qlen)
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_printk("%s rhp=%p func=%pf %ld/%ld",
> + __get_str(rcuname), __entry->rhp, __entry->func,
> + __entry->qlen_lazy, __entry->qlen)
> +#else
> + TP_printk("%s rhp=%p func=%pf %ld",
> + __get_str(rcuname), __entry->rhp, __entry->func,
> + __entry->qlen)
> +#endif
> +)
> +
> +/*
> + * Tracepoint for the registration of a single RCU callback of the special
> + * kfree() form. The first argument is the RCU type, the second argument
> + * is a pointer to the RCU callback, the third argument is the offset
> + * of the callback within the enclosing RCU-protected data structure,
> + * the fourth argument is the number of lazy callbacks queued, and the
> + * fifth argument is the total number of callbacks queued.
> + */
> +TRACE_EVENT(rcu_kfree_callback,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset,
> + long qlen_lazy, long qlen),
> +
> + TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen),
> +#else
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset,
> + long qlen),
> +
> + TP_ARGS(rcuname, rhp, offset, qlen),
> +#endif
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(void *, rhp)
> + __field(unsigned long, offset)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + __field(long, qlen_lazy)
> +#endif
> + __field(long, qlen)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(rhp, rhp)
> + tp_assign(offset, offset)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + tp_assign(qlen_lazy, qlen_lazy)
> +#endif
> + tp_assign(qlen, qlen)
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_printk("%s rhp=%p func=%ld %ld/%ld",
> + __get_str(rcuname), __entry->rhp, __entry->offset,
> + __entry->qlen_lazy, __entry->qlen)
> +#else
> + TP_printk("%s rhp=%p func=%ld %ld",
> + __get_str(rcuname), __entry->rhp, __entry->offset,
> + __entry->qlen)
> +#endif
> +)
> +
> +/*
> + * Tracepoint for marking the beginning rcu_do_batch, performed to start
> + * RCU callback invocation. The first argument is the RCU flavor,
> + * the second is the number of lazy callbacks queued, the third is
> + * the total number of callbacks queued, and the fourth argument is
> + * the current RCU-callback batch limit.
> + */
> +TRACE_EVENT(rcu_batch_start,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_PROTO(char *rcuname, long qlen_lazy, long qlen, int blimit),
> +
> + TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
> +#else
> + TP_PROTO(char *rcuname, long qlen, int blimit),
> +
> + TP_ARGS(rcuname, qlen, blimit),
> +#endif
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + __field(long, qlen_lazy)
> +#endif
> + __field(long, qlen)
> + __field(int, blimit)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + tp_assign(qlen_lazy, qlen_lazy)
> +#endif
> + tp_assign(qlen, qlen)
> + tp_assign(blimit, blimit)
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> + TP_printk("%s CBs=%ld/%ld bl=%d",
> + __get_str(rcuname), __entry->qlen_lazy, __entry->qlen,
> + __entry->blimit)
> +#else
> + TP_printk("%s CBs=%ld bl=%d",
> + __get_str(rcuname), __entry->qlen, __entry->blimit)
> +#endif
> +)
> +
> +/*
> + * Tracepoint for the invocation of a single RCU callback function.
> + * The first argument is the type of RCU, and the second argument is
> + * a pointer to the RCU callback itself.
> + */
> +TRACE_EVENT(rcu_invoke_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp),
> +
> + TP_ARGS(rcuname, rhp),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(void *, rhp)
> + __field(void *, func)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(rhp, rhp)
> + tp_assign(func, rhp->func)
> + ),
> +
> + TP_printk("%s rhp=%p func=%pf",
> + __get_str(rcuname), __entry->rhp, __entry->func)
> +)
> +
> +/*
> + * Tracepoint for the invocation of a single RCU callback of the special
> + * kfree() form. The first argument is the RCU flavor, the second
> + * argument is a pointer to the RCU callback, and the third argument
> + * is the offset of the callback within the enclosing RCU-protected
> + * data structure.
> + */
> +TRACE_EVENT(rcu_invoke_kfree_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset),
> +
> + TP_ARGS(rcuname, rhp, offset),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(void *, rhp)
> + __field(unsigned long, offset)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(rhp, rhp)
> + tp_assign(offset, offset)
> + ),
> +
> + TP_printk("%s rhp=%p func=%ld",
> + __get_str(rcuname), __entry->rhp, __entry->offset)
> +)
> +
> +/*
> + * Tracepoint for exiting rcu_do_batch after RCU callbacks have been
> + * invoked. The first argument is the name of the RCU flavor,
> + * the second argument is number of callbacks actually invoked,
> + * the third argument (cb) is whether or not any of the callbacks that
> + * were ready to invoke at the beginning of this batch are still
> + * queued, the fourth argument (nr) is the return value of need_resched(),
> + * the fifth argument (iit) is 1 if the current task is the idle task,
> + * and the sixth argument (risk) is the return value from
> + * rcu_is_callbacks_kthread().
> + */
> +TRACE_EVENT(rcu_batch_end,
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + TP_PROTO(char *rcuname, int callbacks_invoked,
> + bool cb, bool nr, bool iit, bool risk),
> +
> + TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk),
> +#else
> + TP_PROTO(char *rcuname, int callbacks_invoked),
> +
> + TP_ARGS(rcuname, callbacks_invoked),
> +#endif
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __field(int, callbacks_invoked)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + __field(bool, cb)
> + __field(bool, nr)
> + __field(bool, iit)
> + __field(bool, risk)
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_assign(callbacks_invoked, callbacks_invoked)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + tp_assign(cb, cb)
> + tp_assign(nr, nr)
> + tp_assign(iit, iit)
> + tp_assign(risk, risk)
> +#endif
> + ),
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + TP_printk("%s CBs-invoked=%d idle=%c%c%c%c",
> + __get_str(rcuname), __entry->callbacks_invoked,
> + __entry->cb ? 'C' : '.',
> + __entry->nr ? 'S' : '.',
> + __entry->iit ? 'I' : '.',
> + __entry->risk ? 'R' : '.')
> +#else
> + TP_printk("%s CBs-invoked=%d",
> + __get_str(rcuname), __entry->callbacks_invoked)
> +#endif
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +/*
> + * Tracepoint for rcutorture readers. The first argument is the name
> + * of the RCU flavor from rcutorture's viewpoint and the second argument
> + * is the callback address.
> + */
> +TRACE_EVENT(rcu_torture_read,
> +
> + TP_PROTO(char *rcutorturename, struct rcu_head *rhp),
> +
> + TP_ARGS(rcutorturename, rhp),
> +
> + TP_STRUCT__entry(
> + __string(rcutorturename, rcutorturename)
> + __field(struct rcu_head *, rhp)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcutorturename, rcutorturename)
> + tp_assign(rhp, rhp)
> + ),
> +
> + TP_printk("%s torture read %p",
> + __get_str(rcutorturename), __entry->rhp)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> +/*
> + * Tracepoint for _rcu_barrier() execution. The string "s" describes
> + * the _rcu_barrier phase:
> + * "Begin": rcu_barrier_callback() started.
> + * "Check": rcu_barrier_callback() checking for piggybacking.
> + * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit.
> + * "Inc1": rcu_barrier_callback() piggyback check counter incremented.
> + * "Offline": rcu_barrier_callback() found offline CPU
> + * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks.
> + * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks.
> + * "IRQ": An rcu_barrier_callback() callback posted on remote CPU.
> + * "CB": An rcu_barrier_callback() invoked a callback, not the last.
> + * "LastCB": An rcu_barrier_callback() invoked the last callback.
> + * "Inc2": rcu_barrier_callback() piggyback check counter incremented.
> + * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument
> + * is the count of remaining callbacks, and "done" is the piggybacking count.
> + */
> +TRACE_EVENT(rcu_barrier,
> +
> + TP_PROTO(char *rcuname, char *s, int cpu, int cnt, unsigned long done),
> +
> + TP_ARGS(rcuname, s, cpu, cnt, done),
> +
> + TP_STRUCT__entry(
> + __string(rcuname, rcuname)
> + __string(s, s)
> + __field(int, cpu)
> + __field(int, cnt)
> + __field(unsigned long, done)
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(rcuname, rcuname)
> + tp_strcpy(s, s)
> + tp_assign(cpu, cpu)
> + tp_assign(cnt, cnt)
> + tp_assign(done, done)
> + ),
> +
> + TP_printk("%s %s cpu %d remaining %d # %lu",
> + __get_str(rcuname), __get_str(s), __entry->cpu, __entry->cnt,
> + __entry->done)
> +)
> +#endif
> +
> +#else /* #ifdef CONFIG_RCU_TRACE */
> +
> +#define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0)
> +#define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \
> + qsmask) do { } while (0)
> +#define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0)
> +#define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0)
> +#define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \
> + grplo, grphi, gp_tasks) do { } \
> + while (0)
> +#define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +#define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0)
> +#else
> +#define trace_rcu_dyntick(polarity) do { } while (0)
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +#define trace_rcu_prep_idle(reason) do { } while (0)
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> +#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0)
> +#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \
> + do { } while (0)
> +#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \
> + do { } while (0)
> +#else
> +#define trace_rcu_callback(rcuname, rhp, qlen) do { } while (0)
> +#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen) do { } while (0)
> +#define trace_rcu_batch_start(rcuname, qlen, blimit) do { } while (0)
> +#endif
> +#define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0)
> +#define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +#define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
> + do { } while (0)
> +#else
> +#define trace_rcu_batch_end(rcuname, callbacks_invoked) do { } while (0)
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +#define trace_rcu_torture_read(rcutorturename, rhp) do { } while (0)
> +#endif
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> +#define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0)
> +#endif
> +#endif /* #else #ifdef CONFIG_RCU_TRACE */
> +
> +#endif /* _TRACE_RCU_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/regmap.h b/instrumentation/events/lttng-module/regmap.h
> new file mode 100644
> index 0000000..df56ac0
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/regmap.h
> @@ -0,0 +1,188 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM regmap
> +
> +#if !defined(_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_REGMAP_H
> +
> +#include <linux/ktime.h>
> +#include <linux/tracepoint.h>
> +#include <linux/version.h>
> +
> +#ifndef _TRACE_REGMAP_DEF_
> +#define _TRACE_REGMAP_DEF_
> +struct device;
> +struct regmap;
> +#endif
> +
> +/*
> + * Log register events
> + */
> +DECLARE_EVENT_CLASS(regmap_reg,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( unsigned int, reg )
> + __field( unsigned int, val )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_assign(reg, reg)
> + tp_assign(val, val)
> + ),
> +
> + TP_printk("%s reg=%x val=%x", __get_str(name),
> + (unsigned int)__entry->reg,
> + (unsigned int)__entry->val)
> +)
> +
> +DEFINE_EVENT(regmap_reg, regmap_reg_write,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +)
> +
> +DEFINE_EVENT(regmap_reg, regmap_reg_read,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> +DEFINE_EVENT(regmap_reg, regmap_reg_read_cache,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +)
> +#endif
> +
> +DECLARE_EVENT_CLASS(regmap_block,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( unsigned int, reg )
> + __field( int, count )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_assign(reg, reg)
> + tp_assign(count, count)
> + ),
> +
> + TP_printk("%s reg=%x count=%d", __get_str(name),
> + (unsigned int)__entry->reg,
> + (int)__entry->count)
> +)
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_read_start,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +)
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_read_done,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +)
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_write_start,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +)
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_write_done,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +)
> +
> +TRACE_EVENT(regcache_sync,
> +
> + TP_PROTO(struct device *dev, const char *type,
> + const char *status),
> +
> + TP_ARGS(dev, type, status),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __string( status, status )
> + __string( type, type )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_strcpy(status, status)
> + tp_strcpy(type, type)
> + ),
> +
> + TP_printk("%s type=%s status=%s", __get_str(name),
> + __get_str(type), __get_str(status))
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
> +DECLARE_EVENT_CLASS(regmap_bool,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( int, flag )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_assign(flag, flag)
> + ),
> +
> + TP_printk("%s flag=%d", __get_str(name),
> + (int)__entry->flag)
> +)
> +
> +DEFINE_EVENT(regmap_bool, regmap_cache_only,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag)
> +
> +)
> +
> +DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag)
> +
> +)
> +#endif
> +
> +#endif /* _TRACE_REGMAP_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/rpm.h b/instrumentation/events/lttng-module/rpm.h
> new file mode 100644
> index 0000000..16bcad0
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/rpm.h
> @@ -0,0 +1,101 @@
> +
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM rpm
> +
> +#if !defined(_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RUNTIME_POWER_H
> +
> +#include <linux/ktime.h>
> +#include <linux/tracepoint.h>
> +
> +#ifndef _TRACE_RPM_DEF_
> +#define _TRACE_RPM_DEF_
> +struct device;
> +#endif
> +
> +/*
> + * The rpm_internal events are used for tracing some important
> + * runtime pm internal functions.
> + */
> +DECLARE_EVENT_CLASS(rpm_internal,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( int, flags )
> + __field( int , usage_count )
> + __field( int , disable_depth )
> + __field( int , runtime_auto )
> + __field( int , request_pending )
> + __field( int , irq_safe )
> + __field( int , child_count )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_assign(flags, flags)
> + tp_assign(usage_count, atomic_read(&dev->power.usage_count))
> + tp_assign(disable_depth, dev->power.disable_depth)
> + tp_assign(runtime_auto, dev->power.runtime_auto)
> + tp_assign(request_pending, dev->power.request_pending)
> + tp_assign(irq_safe, dev->power.irq_safe)
> + tp_assign(child_count, atomic_read(&dev->power.child_count))
> + ),
> +
> + TP_printk("%s flags-%x cnt-%-2d dep-%-2d auto-%-1d p-%-1d"
> + " irq-%-1d child-%d",
> + __get_str(name), __entry->flags,
> + __entry->usage_count,
> + __entry->disable_depth,
> + __entry->runtime_auto,
> + __entry->request_pending,
> + __entry->irq_safe,
> + __entry->child_count
> + )
> +)
> +DEFINE_EVENT(rpm_internal, rpm_suspend,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +)
> +DEFINE_EVENT(rpm_internal, rpm_resume,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +)
> +DEFINE_EVENT(rpm_internal, rpm_idle,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +)
> +
> +TRACE_EVENT(rpm_return_int,
> + TP_PROTO(struct device *dev, unsigned long ip, int ret),
> + TP_ARGS(dev, ip, ret),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev))
> + __field( unsigned long, ip )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + tp_strcpy(name, dev_name(dev))
> + tp_assign(ip, ip)
> + tp_assign(ret, ret)
> + ),
> +
> + TP_printk("%pS:%s ret=%d", (void *)__entry->ip, __get_str(name),
> + __entry->ret)
> +)
> +
> +#endif /* _TRACE_RUNTIME_POWER_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/sunrpc.h b/instrumentation/events/lttng-module/sunrpc.h
> new file mode 100644
> index 0000000..6320668
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/sunrpc.h
> @@ -0,0 +1,177 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM sunrpc
> +
> +#if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_SUNRPC_H
> +
> +#include <linux/sunrpc/sched.h>
> +#include <linux/sunrpc/clnt.h>
> +#include <linux/tracepoint.h>
> +
> +DECLARE_EVENT_CLASS(rpc_task_status,
> +
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_task *, task)
> + __field(const struct rpc_clnt *, clnt)
> + __field(int, status)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(task, task)
> + tp_assign(clnt, task->tk_client)
> + tp_assign(status, task->tk_status)
> + ),
> +
> + TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
> +)
> +
> +DEFINE_EVENT(rpc_task_status, rpc_call_status,
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task)
> +)
> +
> +DEFINE_EVENT(rpc_task_status, rpc_bind_status,
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task)
> +)
> +
> +TRACE_EVENT(rpc_connect_status,
> + TP_PROTO(struct rpc_task *task, int status),
> +
> + TP_ARGS(task, status),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_task *, task)
> + __field(const struct rpc_clnt *, clnt)
> + __field(int, status)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(task, task)
> + tp_assign(clnt, task->tk_client)
> + tp_assign(status, status)
> + ),
> +
> + TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
> +)
> +
> +DECLARE_EVENT_CLASS(rpc_task_running,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_clnt *, clnt)
> + __field(const struct rpc_task *, task)
> + __field(const void *, action)
> + __field(unsigned long, runstate)
> + __field(int, status)
> + __field(unsigned short, flags)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(clnt, clnt)
> + tp_assign(task, task)
> + tp_assign(action, action)
> + tp_assign(runstate, task->tk_runstate)
> + tp_assign(status, task->tk_status)
> + tp_assign(flags, task->tk_flags)
> + ),
> +
> + TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d action=%pf",
> + __entry->task,
> + __entry->clnt,
> + __entry->flags,
> + __entry->runstate,
> + __entry->status,
> + __entry->action
> + )
> +)
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_begin,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +)
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +)
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_complete,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +)
> +
> +DECLARE_EVENT_CLASS(rpc_task_queued,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_clnt *, clnt)
> + __field(const struct rpc_task *, task)
> + __field(unsigned long, timeout)
> + __field(unsigned long, runstate)
> + __field(int, status)
> + __field(unsigned short, flags)
> + __string(q_name, rpc_qname(q))
> + ),
> +
> + TP_fast_assign(
> + tp_assign(clnt, clnt)
> + tp_assign(task, task)
> + tp_assign(timeout, task->tk_timeout)
> + tp_assign(runstate, task->tk_runstate)
> + tp_assign(status, task->tk_status)
> + tp_assign(flags, task->tk_flags)
> + tp_strcpy(q_name, rpc_qname(q))
> + ),
> +
> + TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
> + __entry->task,
> + __entry->clnt,
> + __entry->flags,
> + __entry->runstate,
> + __entry->status,
> + __entry->timeout,
> + __get_str(q_name)
> + )
> +)
> +
> +DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q)
> +
> +)
> +
> +DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q)
> +
> +)
> +
> +#endif /* _TRACE_SUNRPC_H */
> +
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/workqueue.h b/instrumentation/events/lttng-module/workqueue.h
> new file mode 100644
> index 0000000..02115c7
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/workqueue.h
> @@ -0,0 +1,316 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM workqueue
> +
> +#if !defined(_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_WORKQUEUE_H
> +
> +#include <linux/tracepoint.h>
> +#include <linux/workqueue.h>
> +#include <linux/version.h>
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
> +
> +#ifndef _TRACE_WORKQUEUE_DEF_
> +#define _TRACE_WORKQUEUE_DEF_
> +
> +struct worker;
> +struct global_cwq;
> +
> +/* Have to duplicate all these definitions from kernel/workqueue.c */
> +/* Extracts only */
> +
> +enum {
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> + NR_WORKER_POOLS = 2, /* # worker pools per gcwq */
> +#endif
> + BUSY_WORKER_HASH_ORDER = 6, /* 64 pointers */
> + BUSY_WORKER_HASH_SIZE = 1 << BUSY_WORKER_HASH_ORDER,
> +};
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> +struct worker_pool {
> + struct global_cwq *gcwq; /* I: the owning gcwq */
> + unsigned int flags; /* X: flags */
> +
> + struct list_head worklist; /* L: list of pending works */
> + int nr_workers; /* L: total number of workers */
> + int nr_idle; /* L: currently idle ones */
> +
> + struct list_head idle_list; /* X: list of idle workers */
> + struct timer_list idle_timer; /* L: worker idle timeout */
> + struct timer_list mayday_timer; /* L: SOS timer for workers */
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + struct mutex assoc_mutex; /* protect GCWQ_DISASSOCUATED */
> +#else
> + struct mutex manager_mutex; /* mutex manager should hold */
> +#endif
> + struct ida worker_ida; /* L: for worker IDs */
> +};
> +
> +struct global_cwq {
> + spinlock_t lock; /* the gcwq lock */
> + unsigned int cpu; /* I: the associated cpu */
> + unsigned int flags; /* L: GCWQ_* flags */
> +
> + /* workers are chained either in busy_hash or pool idle_list */
> + struct hlist_head busy_hash[BUSY_WORKER_HASH_SIZE];
> + /* L: hash of busy workers */
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
> + struct worker_pool pools[NR_WORKER_POOLS];
> + /* normal and highpri pools */
> +#else
> + struct worker_pool pools[2]; /* normal and highpri pools */
> +
> + wait_queue_head_t rebind_hold; /* rebind hold wait */
> +#endif
> +} ____cacheline_aligned_in_smp;
> +
> +#else
> +
> +struct global_cwq {
> + spinlock_t lock; /* the gcwq lock */
> + struct list_head worklist; /* L: list of pending works */
> + unsigned int cpu; /* I: the associated cpu */
> + unsigned int flags; /* L: GCWQ_* flags */
> +
> + int nr_workers; /* L: total number of workers */
> + int nr_idle; /* L: currently idle ones */
> +
> + /* workers are chained either in the idle_list or busy_hash */
> + struct list_head idle_list; /* X: list of idle workers */
> + struct hlist_head busy_hash[BUSY_WORKER_HASH_SIZE];
> + /* L: hash of busy workers */
> +
> + struct timer_list idle_timer; /* L: worker idle timeout */
> + struct timer_list mayday_timer; /* L: SOS timer for dworkers */
> +
> + struct ida worker_ida; /* L: for worker IDs */
> +
> + struct task_struct *trustee; /* L: for gcwq shutdown */
> + unsigned int trustee_state; /* L: trustee state */
> + wait_queue_head_t trustee_wait; /* trustee wait */
> + struct worker *first_idle; /* L: first idle worker */
> +} ____cacheline_aligned_in_smp;
> +
> +#endif
> +
> +struct cpu_workqueue_struct {
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> + struct worker_pool *pool; /* I: The associated pool */
> +#else
> + struct global_cwq *gcwq; /* I: the associated gcwq */
> +#endif
> + struct workqueue_struct *wq; /* I: the owning workqueue */
> + int work_color; /* L: current color */
> + int flush_color; /* L: flushing color */
> + int nr_in_flight[WORK_NR_COLORS];
> + /* L: nr of in_flight works */
> + int nr_active; /* L: nr of active works */
> + int max_active; /* L: max active works */
> + struct list_head delayed_works; /* L: delayed works */
> +};
> +
> +#endif
> +
> +DECLARE_EVENT_CLASS(workqueue_work,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(work, work)
> + ),
> +
> + TP_printk("work struct %p", __entry->work)
> +)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> +/**
> + * workqueue_queue_work - called when a work gets queued
> + * @req_cpu: the requested cpu
> + * @cwq: pointer to struct cpu_workqueue_struct
> + * @work: pointer to struct work_struct
> + *
> + * This event occurs when a work is queued immediately or once a
> + * delayed work is actually queued on a workqueue (ie: once the delay
> + * has been reached).
> + */
> +TRACE_EVENT(workqueue_queue_work,
> +
> + TP_PROTO(unsigned int req_cpu, struct cpu_workqueue_struct *cwq,
> + struct work_struct *work),
> +
> + TP_ARGS(req_cpu, cwq, work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + __field( void *, function)
> + __field( void *, workqueue)
> + __field( unsigned int, req_cpu )
> + __field( unsigned int, cpu )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(work, work)
> + tp_assign(function, work->func)
> + tp_assign(workqueue, cwq->wq)
> + tp_assign(req_cpu, req_cpu)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
> + tp_assign(cpu, cwq->pool->gcwq->cpu)
> +#else
> + tp_assign(cpu, cwq->gcwq->cpu)
> +#endif
> + ),
> +
> + TP_printk("work struct=%p function=%pf workqueue=%p req_cpu=%u cpu=%u",
> + __entry->work, __entry->function, __entry->workqueue,
> + __entry->req_cpu, __entry->cpu)
> +)
> +
> +/**
> + * workqueue_activate_work - called when a work gets activated
> + * @work: pointer to struct work_struct
> + *
> + * This event occurs when a queued work is put on the active queue,
> + * which happens immediately after queueing unless @max_active limit
> + * is reached.
> + */
> +DEFINE_EVENT(workqueue_work, workqueue_activate_work,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work)
> +)
> +#endif
> +
> +/**
> + * workqueue_execute_start - called immediately before the workqueue callback
> + * @work: pointer to struct work_struct
> + *
> + * Allows to track workqueue execution.
> + */
> +TRACE_EVENT(workqueue_execute_start,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + __field( void *, function)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(work, work)
> + tp_assign(function, work->func)
> + ),
> +
> + TP_printk("work struct %p: function %pf", __entry->work, __entry->function)
> +)
> +
> +/**
> + * workqueue_execute_end - called immediately after the workqueue callback
> + * @work: pointer to struct work_struct
> + *
> + * Allows to track workqueue execution.
> + */
> +DEFINE_EVENT(workqueue_work, workqueue_execute_end,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work)
> +)
> +
> +#else
> +
> +DECLARE_EVENT_CLASS(workqueue,
> +
> + TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
> +
> + TP_ARGS(wq_thread, work),
> +
> + TP_STRUCT__entry(
> + __array(char, thread_comm, TASK_COMM_LEN)
> + __field(pid_t, thread_pid)
> + __field(work_func_t, func)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(thread_comm, wq_thread->comm, TASK_COMM_LEN)
> + tp_assign(thread_pid, wq_thread->pid)
> + tp_assign(func, work->func)
> + ),
> +
> + TP_printk("thread=%s:%d func=%pf", __entry->thread_comm,
> + __entry->thread_pid, __entry->func)
> +)
> +
> +DEFINE_EVENT(workqueue, workqueue_insertion,
> +
> + TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
> +
> + TP_ARGS(wq_thread, work)
> +)
> +
> +DEFINE_EVENT(workqueue, workqueue_execution,
> +
> + TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
> +
> + TP_ARGS(wq_thread, work)
> +)
> +
> +/* Trace the creation of one workqueue thread on a cpu */
> +TRACE_EVENT(workqueue_creation,
> +
> + TP_PROTO(struct task_struct *wq_thread, int cpu),
> +
> + TP_ARGS(wq_thread, cpu),
> +
> + TP_STRUCT__entry(
> + __array(char, thread_comm, TASK_COMM_LEN)
> + __field(pid_t, thread_pid)
> + __field(int, cpu)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(thread_comm, wq_thread->comm, TASK_COMM_LEN)
> + tp_assign(thread_pid, wq_thread->pid)
> + tp_assign(cpu, cpu)
> + ),
> +
> + TP_printk("thread=%s:%d cpu=%d", __entry->thread_comm,
> + __entry->thread_pid, __entry->cpu)
> +)
> +
> +TRACE_EVENT(workqueue_destruction,
> +
> + TP_PROTO(struct task_struct *wq_thread),
> +
> + TP_ARGS(wq_thread),
> +
> + TP_STRUCT__entry(
> + __array(char, thread_comm, TASK_COMM_LEN)
> + __field(pid_t, thread_pid)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(thread_comm, wq_thread->comm, TASK_COMM_LEN)
> + tp_assign(thread_pid, wq_thread->pid)
> + ),
> +
> + TP_printk("thread=%s:%d", __entry->thread_comm, __entry->thread_pid)
> +)
> +
> +#endif
> +
> +#endif /* _TRACE_WORKQUEUE_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/lttng-module/writeback.h b/instrumentation/events/lttng-module/writeback.h
> new file mode 100644
> index 0000000..b3d5538
> --- /dev/null
> +++ b/instrumentation/events/lttng-module/writeback.h
> @@ -0,0 +1,673 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM writeback
> +
> +#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_WRITEBACK_H
> +
> +#include <linux/backing-dev.h>
> +#include <linux/writeback.h>
> +#include <linux/version.h>
> +
> +#ifndef _TRACE_WRITEBACK_DEF_
> +#define _TRACE_WRITEBACK_DEF_
> +/* Have to duplicate it here from fs/fs-writeback.c */
> +struct wb_writeback_work {
> + long nr_pages;
> + struct super_block *sb;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> + unsigned long *older_than_this;
> +#endif
> + enum writeback_sync_modes sync_mode;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> + unsigned int tagged_writepages:1;
> +#endif
> + unsigned int for_kupdate:1;
> + unsigned int range_cyclic:1;
> + unsigned int for_background:1;
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + enum wb_reason reason; /* why was writeback initiated? */
> +#endif
> +
> + struct list_head list; /* pending work list */
> + struct completion *done; /* set if the caller waits */
> +};
> +static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
> +{
> + struct super_block *sb = inode->i_sb;
> +
> + if (strcmp(sb->s_type->name, "bdev") == 0)
> + return inode->i_mapping->backing_dev_info;
> +
> + return sb->s_bdi;
> +}
> +#endif
> +
> +#define show_inode_state(state) \
> + __print_flags(state, "|", \
> + {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
> + {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
> + {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
> + {I_NEW, "I_NEW"}, \
> + {I_WILL_FREE, "I_WILL_FREE"}, \
> + {I_FREEING, "I_FREEING"}, \
> + {I_CLEAR, "I_CLEAR"}, \
> + {I_SYNC, "I_SYNC"}, \
> + {I_REFERENCED, "I_REFERENCED"} \
> + )
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> +#define WB_WORK_REASON \
> + {WB_REASON_BACKGROUND, "background"}, \
> + {WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages"}, \
> + {WB_REASON_SYNC, "sync"}, \
> + {WB_REASON_PERIODIC, "periodic"}, \
> + {WB_REASON_LAPTOP_TIMER, "laptop_timer"}, \
> + {WB_REASON_FREE_MORE_MEM, "free_more_memory"}, \
> + {WB_REASON_FS_FREE_SPACE, "fs_free_space"}, \
> + {WB_REASON_FORKER_THREAD, "forker_thread"}
> +#endif
> +
> +DECLARE_EVENT_CLASS(writeback_work_class,
> + TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
> + TP_ARGS(bdi, work),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(long, nr_pages)
> + __field(dev_t, sb_dev)
> + __field(int, sync_mode)
> + __field(int, for_kupdate)
> + __field(int, range_cyclic)
> + __field(int, for_background)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + __field(int, reason)
> +#endif
> + ),
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(bdi->dev ? bdi->dev :
> + default_backing_dev_info.dev), 32)
> + tp_assign(nr_pages, work->nr_pages)
> + tp_assign(sb_dev, work->sb ? work->sb->s_dev : 0)
> + tp_assign(sync_mode, work->sync_mode)
> + tp_assign(for_kupdate, work->for_kupdate)
> + tp_assign(range_cyclic, work->range_cyclic)
> + tp_assign(for_background, work->for_background)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + tp_assign(reason, work->reason)
> +#endif
> + ),
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
> + "kupdate=%d range_cyclic=%d background=%d reason=%s",
> + __entry->name,
> + MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
> + __entry->nr_pages,
> + __entry->sync_mode,
> + __entry->for_kupdate,
> + __entry->range_cyclic,
> + __entry->for_background,
> + __print_symbolic(__entry->reason, WB_WORK_REASON)
> + )
> +#else
> + TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
> + "kupdate=%d range_cyclic=%d background=%d",
> + __entry->name,
> + MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
> + __entry->nr_pages,
> + __entry->sync_mode,
> + __entry->for_kupdate,
> + __entry->range_cyclic,
> + __entry->for_background
> + )
> +#endif
> +)
> +#define DEFINE_WRITEBACK_WORK_EVENT(name) \
> +DEFINE_EVENT(writeback_work_class, name, \
> + TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
> + TP_ARGS(bdi, work))
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread)
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_queue)
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_exec)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_start)
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_written)
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_wait)
> +#endif
> +
> +TRACE_EVENT(writeback_pages_written,
> + TP_PROTO(long pages_written),
> + TP_ARGS(pages_written),
> + TP_STRUCT__entry(
> + __field(long, pages)
> + ),
> + TP_fast_assign(
> + tp_assign(pages, pages_written)
> + ),
> + TP_printk("%ld", __entry->pages)
> +)
> +
> +DECLARE_EVENT_CLASS(writeback_class,
> + TP_PROTO(struct backing_dev_info *bdi),
> + TP_ARGS(bdi),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + ),
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(bdi->dev), 32)
> + ),
> + TP_printk("bdi %s",
> + __entry->name
> + )
> +)
> +#define DEFINE_WRITEBACK_EVENT(name) \
> +DEFINE_EVENT(writeback_class, name, \
> + TP_PROTO(struct backing_dev_info *bdi), \
> + TP_ARGS(bdi))
> +
> +DEFINE_WRITEBACK_EVENT(writeback_nowork)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
> +DEFINE_WRITEBACK_EVENT(writeback_wake_background)
> +#endif
> +DEFINE_WRITEBACK_EVENT(writeback_wake_thread)
> +DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread)
> +DEFINE_WRITEBACK_EVENT(writeback_bdi_register)
> +DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister)
> +DEFINE_WRITEBACK_EVENT(writeback_thread_start)
> +DEFINE_WRITEBACK_EVENT(writeback_thread_stop)
> +#if (LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
> +DEFINE_WRITEBACK_EVENT(balance_dirty_start)
> +DEFINE_WRITEBACK_EVENT(balance_dirty_wait)
> +
> +TRACE_EVENT(balance_dirty_written,
> +
> + TP_PROTO(struct backing_dev_info *bdi, int written),
> +
> + TP_ARGS(bdi, written),
> +
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(int, written)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(bdi->dev), 32)
> + tp_assign(written, written)
> + ),
> +
> + TP_printk("bdi %s written %d",
> + __entry->name,
> + __entry->written
> + )
> +)
> +#endif
> +
> +DECLARE_EVENT_CLASS(wbc_class,
> + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
> + TP_ARGS(wbc, bdi),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(long, nr_to_write)
> + __field(long, pages_skipped)
> + __field(int, sync_mode)
> + __field(int, for_kupdate)
> + __field(int, for_background)
> + __field(int, for_reclaim)
> + __field(int, range_cyclic)
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + __field(int, more_io)
> + __field(unsigned long, older_than_this)
> +#endif
> + __field(long, range_start)
> + __field(long, range_end)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(bdi->dev), 32)
> + tp_assign(nr_to_write, wbc->nr_to_write)
> + tp_assign(pages_skipped, wbc->pages_skipped)
> + tp_assign(sync_mode, wbc->sync_mode)
> + tp_assign(for_kupdate, wbc->for_kupdate)
> + tp_assign(for_background, wbc->for_background)
> + tp_assign(for_reclaim, wbc->for_reclaim)
> + tp_assign(range_cyclic, wbc->range_cyclic)
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + tp_assign(more_io, wbc->more_io)
> + tp_assign(older_than_this, wbc->older_than_this ?
> + *wbc->older_than_this : 0)
> +#endif
> + tp_assign(range_start, (long)wbc->range_start)
> + tp_assign(range_end, (long)wbc->range_end)
> + ),
> +
> + TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
> +#else
> + "bgrd=%d reclm=%d cyclic=%d "
> +#endif
> + "start=0x%lx end=0x%lx",
> + __entry->name,
> + __entry->nr_to_write,
> + __entry->pages_skipped,
> + __entry->sync_mode,
> + __entry->for_kupdate,
> + __entry->for_background,
> + __entry->for_reclaim,
> + __entry->range_cyclic,
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> + __entry->more_io,
> + __entry->older_than_this,
> +#endif
> + __entry->range_start,
> + __entry->range_end)
> +)
> +
> +#define DEFINE_WBC_EVENT(name) \
> +DEFINE_EVENT(wbc_class, name, \
> + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
> + TP_ARGS(wbc, bdi))
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
> +DEFINE_WBC_EVENT(wbc_writeback_start)
> +DEFINE_WBC_EVENT(wbc_writeback_written)
> +DEFINE_WBC_EVENT(wbc_writeback_wait)
> +DEFINE_WBC_EVENT(wbc_balance_dirty_start)
> +DEFINE_WBC_EVENT(wbc_balance_dirty_written)
> +DEFINE_WBC_EVENT(wbc_balance_dirty_wait)
> +#endif
> +DEFINE_WBC_EVENT(wbc_writepage)
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> +TRACE_EVENT(writeback_queue_io,
> + TP_PROTO(struct bdi_writeback *wb,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + struct wb_writeback_work *work,
> +#else
> + unsigned long *older_than_this,
> +#endif
> + int moved),
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + TP_ARGS(wb, work, moved),
> +#else
> + TP_ARGS(wb, older_than_this, moved),
> +#endif
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, older)
> + __field(long, age)
> + __field(int, moved)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + __field(int, reason)
> +#endif
> + ),
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(wb->bdi->dev), 32)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + tp_assign(older,
> + work->older_than_this ? *(work->older_than_this) : 0)
> + tp_assign(age, work->older_than_this ?
> + (jiffies - *(work->older_than_this)) * 1000 / HZ : -1)
> +#else
> + tp_assign(older, older_than_this ? *older_than_this : 0)
> + tp_assign(age, older_than_this ?
> + (jiffies - *older_than_this) * 1000 / HZ : -1)
> +#endif
> + tp_assign(moved, moved)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + tp_assign(reason, work->reason)
> +#endif
> + ),
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> + TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s",
> + __entry->name,
> + __entry->older, /* older_than_this in jiffies */
> + __entry->age, /* older_than_this in relative milliseconds */
> + __entry->moved,
> + __print_symbolic(__entry->reason, WB_WORK_REASON)
> + )
> +#else
> + TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
> + __entry->name,
> + __entry->older, /* older_than_this in jiffies */
> + __entry->age, /* older_than_this in relative milliseconds */
> + __entry->moved
> + )
> +#endif
> +)
> +
> +TRACE_EVENT(global_dirty_state,
> +
> + TP_PROTO(unsigned long background_thresh,
> + unsigned long dirty_thresh
> + ),
> +
> + TP_ARGS(background_thresh,
> + dirty_thresh
> + ),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_dirty)
> + __field(unsigned long, nr_writeback)
> + __field(unsigned long, nr_unstable)
> + __field(unsigned long, background_thresh)
> + __field(unsigned long, dirty_thresh)
> + __field(unsigned long, dirty_limit)
> + __field(unsigned long, nr_dirtied)
> + __field(unsigned long, nr_written)
> + ),
> +
> + TP_fast_assign(
> + tp_assign(nr_dirty, global_page_state(NR_FILE_DIRTY))
> + tp_assign(nr_writeback, global_page_state(NR_WRITEBACK))
> + tp_assign(nr_unstable, global_page_state(NR_UNSTABLE_NFS))
> + tp_assign(nr_dirtied, global_page_state(NR_DIRTIED))
> + tp_assign(nr_written, global_page_state(NR_WRITTEN))
> + tp_assign(background_thresh, background_thresh)
> + tp_assign(dirty_thresh, dirty_thresh)
> + tp_assign(dirty_limit, global_dirty_limit)
> + ),
> +
> + TP_printk("dirty=%lu writeback=%lu unstable=%lu "
> + "bg_thresh=%lu thresh=%lu limit=%lu "
> + "dirtied=%lu written=%lu",
> + __entry->nr_dirty,
> + __entry->nr_writeback,
> + __entry->nr_unstable,
> + __entry->background_thresh,
> + __entry->dirty_thresh,
> + __entry->dirty_limit,
> + __entry->nr_dirtied,
> + __entry->nr_written
> + )
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
> +
> +#define KBps(x) ((x) << (PAGE_SHIFT - 10))
> +
> +TRACE_EVENT(bdi_dirty_ratelimit,
> +
> + TP_PROTO(struct backing_dev_info *bdi,
> + unsigned long dirty_rate,
> + unsigned long task_ratelimit),
> +
> + TP_ARGS(bdi, dirty_rate, task_ratelimit),
> +
> + TP_STRUCT__entry(
> + __array(char, bdi, 32)
> + __field(unsigned long, write_bw)
> + __field(unsigned long, avg_write_bw)
> + __field(unsigned long, dirty_rate)
> + __field(unsigned long, dirty_ratelimit)
> + __field(unsigned long, task_ratelimit)
> + __field(unsigned long, balanced_dirty_ratelimit)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(bdi, dev_name(bdi->dev), 32)
> + tp_assign(write_bw, KBps(bdi->write_bandwidth))
> + tp_assign(avg_write_bw, KBps(bdi->avg_write_bandwidth))
> + tp_assign(dirty_rate, KBps(dirty_rate))
> + tp_assign(dirty_ratelimit, KBps(bdi->dirty_ratelimit))
> + tp_assign(task_ratelimit, KBps(task_ratelimit))
> + tp_assign(balanced_dirty_ratelimit,
> + KBps(bdi->balanced_dirty_ratelimit))
> + ),
> +
> + TP_printk("bdi %s: "
> + "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
> + "dirty_ratelimit=%lu task_ratelimit=%lu "
> + "balanced_dirty_ratelimit=%lu",
> + __entry->bdi,
> + __entry->write_bw, /* write bandwidth */
> + __entry->avg_write_bw, /* avg write bandwidth */
> + __entry->dirty_rate, /* bdi dirty rate */
> + __entry->dirty_ratelimit, /* base ratelimit */
> + __entry->task_ratelimit, /* ratelimit with position control */
> + __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
> + )
> +)
> +
> +TRACE_EVENT(balance_dirty_pages,
> +
> + TP_PROTO(struct backing_dev_info *bdi,
> + unsigned long thresh,
> + unsigned long bg_thresh,
> + unsigned long dirty,
> + unsigned long bdi_thresh,
> + unsigned long bdi_dirty,
> + unsigned long dirty_ratelimit,
> + unsigned long task_ratelimit,
> + unsigned long dirtied,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + unsigned long period,
> +#endif
> + long pause,
> + unsigned long start_time),
> +
> + TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
> + dirty_ratelimit, task_ratelimit,
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + dirtied, period, pause, start_time),
> +#else
> + dirtied, pause, start_time),
> +#endif
> + TP_STRUCT__entry(
> + __array( char, bdi, 32)
> + __field(unsigned long, limit)
> + __field(unsigned long, setpoint)
> + __field(unsigned long, dirty)
> + __field(unsigned long, bdi_setpoint)
> + __field(unsigned long, bdi_dirty)
> + __field(unsigned long, dirty_ratelimit)
> + __field(unsigned long, task_ratelimit)
> + __field(unsigned int, dirtied)
> + __field(unsigned int, dirtied_pause)
> + __field(unsigned long, paused)
> + __field( long, pause)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + __field(unsigned long, period)
> + __field( long, think)
> +#endif
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(bdi, dev_name(bdi->dev), 32)
> + tp_assign(limit, global_dirty_limit)
> + tp_assign(setpoint,
> + (global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
> + tp_assign(dirty, dirty)
> + tp_assign(bdi_setpoint,
> + ((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
> + bdi_thresh / (thresh + 1))
> + tp_assign(bdi_dirty, bdi_dirty)
> + tp_assign(dirty_ratelimit, KBps(dirty_ratelimit))
> + tp_assign(task_ratelimit, KBps(task_ratelimit))
> + tp_assign(dirtied, dirtied)
> + tp_assign(dirtied_pause, current->nr_dirtied_pause)
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + tp_assign(think, current->dirty_paused_when == 0 ? 0 :
> + (long)(jiffies - current->dirty_paused_when) * 1000/HZ)
> + tp_assign(period, period * 1000 / HZ)
> +#endif
> + tp_assign(pause, pause * 1000 / HZ)
> + tp_assign(paused, (jiffies - start_time) * 1000 / HZ)
> + ),
> +
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
> + TP_printk("bdi %s: "
> + "limit=%lu setpoint=%lu dirty=%lu "
> + "bdi_setpoint=%lu bdi_dirty=%lu "
> + "dirty_ratelimit=%lu task_ratelimit=%lu "
> + "dirtied=%u dirtied_pause=%u "
> + "paused=%lu pause=%ld period=%lu think=%ld",
> + __entry->bdi,
> + __entry->limit,
> + __entry->setpoint,
> + __entry->dirty,
> + __entry->bdi_setpoint,
> + __entry->bdi_dirty,
> + __entry->dirty_ratelimit,
> + __entry->task_ratelimit,
> + __entry->dirtied,
> + __entry->dirtied_pause,
> + __entry->paused, /* ms */
> + __entry->pause, /* ms */
> + __entry->period, /* ms */
> + __entry->think /* ms */
> + )
> +#else
> + TP_printk("bdi %s: "
> + "limit=%lu setpoint=%lu dirty=%lu "
> + "bdi_setpoint=%lu bdi_dirty=%lu "
> + "dirty_ratelimit=%lu task_ratelimit=%lu "
> + "dirtied=%u dirtied_pause=%u "
> + "paused=%lu pause=%ld",
> + __entry->bdi,
> + __entry->limit,
> + __entry->setpoint,
> + __entry->dirty,
> + __entry->bdi_setpoint,
> + __entry->bdi_dirty,
> + __entry->dirty_ratelimit,
> + __entry->task_ratelimit,
> + __entry->dirtied,
> + __entry->dirtied_pause,
> + __entry->paused, /* ms */
> + __entry->pause /* ms */
> + )
> +#endif
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
> +TRACE_EVENT(writeback_sb_inodes_requeue,
> +
> + TP_PROTO(struct inode *inode),
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, ino)
> + __field(unsigned long, state)
> + __field(unsigned long, dirtied_when)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(state, inode->i_state)
> + tp_assign(dirtied_when, inode->dirtied_when)
> + ),
> +
> + TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu",
> + __entry->name,
> + __entry->ino,
> + show_inode_state(__entry->state),
> + __entry->dirtied_when,
> + (jiffies - __entry->dirtied_when) / HZ
> + )
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
> +DECLARE_EVENT_CLASS(writeback_congest_waited_template,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed),
> +
> + TP_STRUCT__entry(
> + __field( unsigned int, usec_timeout )
> + __field( unsigned int, usec_delayed )
> + ),
> +
> + TP_fast_assign(
> + tp_assign(usec_timeout, usec_timeout)
> + tp_assign(usec_delayed, usec_delayed)
> + ),
> +
> + TP_printk("usec_timeout=%u usec_delayed=%u",
> + __entry->usec_timeout,
> + __entry->usec_delayed)
> +)
> +
> +DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed)
> +)
> +
> +DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed)
> +)
> +#endif
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
> +DECLARE_EVENT_CLASS(writeback_single_inode_template,
> +
> + TP_PROTO(struct inode *inode,
> + struct writeback_control *wbc,
> + unsigned long nr_to_write
> + ),
> +
> + TP_ARGS(inode, wbc, nr_to_write),
> +
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, ino)
> + __field(unsigned long, state)
> + __field(unsigned long, dirtied_when)
> + __field(unsigned long, writeback_index)
> + __field(long, nr_to_write)
> + __field(unsigned long, wrote)
> + ),
> +
> + TP_fast_assign(
> + tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
> + tp_assign(ino, inode->i_ino)
> + tp_assign(state, inode->i_state)
> + tp_assign(dirtied_when, inode->dirtied_when)
> + tp_assign(writeback_index, inode->i_mapping->writeback_index)
> + tp_assign(nr_to_write, nr_to_write)
> + tp_assign(wrote, nr_to_write - wbc->nr_to_write)
> + ),
> +
> + TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
> + "index=%lu to_write=%ld wrote=%lu",
> + __entry->name,
> + __entry->ino,
> + show_inode_state(__entry->state),
> + __entry->dirtied_when,
> + (jiffies - __entry->dirtied_when) / HZ,
> + __entry->writeback_index,
> + __entry->nr_to_write,
> + __entry->wrote
> + )
> +)
> +
> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
> +DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
> + TP_PROTO(struct inode *inode,
> + struct writeback_control *wbc,
> + unsigned long nr_to_write),
> + TP_ARGS(inode, wbc, nr_to_write)
> +)
> +#endif
> +
> +DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
> + TP_PROTO(struct inode *inode,
> + struct writeback_control *wbc,
> + unsigned long nr_to_write),
> + TP_ARGS(inode, wbc, nr_to_write)
> +)
> +#endif
> +
> +#endif /* _TRACE_WRITEBACK_H */
> +
> +/* This part must be outside protection */
> +#include "../../../probes/define_trace.h"
> diff --git a/instrumentation/events/mainline/btrfs.h b/instrumentation/events/mainline/btrfs.h
> new file mode 100644
> index 0000000..54fab04
> --- /dev/null
> +++ b/instrumentation/events/mainline/btrfs.h
> @@ -0,0 +1,918 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM btrfs
> +
> +#if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_BTRFS_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +#include <trace/events/gfpflags.h>
> +
> +struct btrfs_root;
> +struct btrfs_fs_info;
> +struct btrfs_inode;
> +struct extent_map;
> +struct btrfs_ordered_extent;
> +struct btrfs_delayed_ref_node;
> +struct btrfs_delayed_tree_ref;
> +struct btrfs_delayed_data_ref;
> +struct btrfs_delayed_ref_head;
> +struct btrfs_block_group_cache;
> +struct btrfs_free_cluster;
> +struct map_lookup;
> +struct extent_buffer;
> +
> +#define show_ref_type(type) \
> + __print_symbolic(type, \
> + { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
> + { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
> + { BTRFS_EXTENT_REF_V0_KEY, "EXTENT_REF_V0" }, \
> + { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
> + { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
> +
> +#define __show_root_type(obj) \
> + __print_symbolic_u64(obj, \
> + { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
> + { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
> + { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
> + { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
> + { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
> + { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
> + { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
> + { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
> + { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
> + { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
> +
> +#define show_root_type(obj) \
> + obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
> + (obj <= BTRFS_CSUM_TREE_OBJECTID )) ? __show_root_type(obj) : "-"
> +
> +#define BTRFS_GROUP_FLAGS \
> + { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
> + { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
> + { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
> + { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
> + { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
> + { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
> + { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}
> +
> +#define BTRFS_UUID_SIZE 16
> +
> +TRACE_EVENT(btrfs_transaction_commit,
> +
> + TP_PROTO(struct btrfs_root *root),
> +
> + TP_ARGS(root),
> +
> + TP_STRUCT__entry(
> + __field( u64, generation )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->generation = root->fs_info->generation;
> + __entry->root_objectid = root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), gen = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->generation)
> +);
> +
> +DECLARE_EVENT_CLASS(btrfs__inode,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( blkcnt_t, blocks )
> + __field( u64, disk_i_size )
> + __field( u64, generation )
> + __field( u64, last_trans )
> + __field( u64, logged_trans )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->ino = inode->i_ino;
> + __entry->blocks = inode->i_blocks;
> + __entry->disk_i_size = BTRFS_I(inode)->disk_i_size;
> + __entry->generation = BTRFS_I(inode)->generation;
> + __entry->last_trans = BTRFS_I(inode)->last_trans;
> + __entry->logged_trans = BTRFS_I(inode)->logged_trans;
> + __entry->root_objectid =
> + BTRFS_I(inode)->root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
> + "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->generation,
> + (unsigned long)__entry->ino,
> + (unsigned long long)__entry->blocks,
> + (unsigned long long)__entry->disk_i_size,
> + (unsigned long long)__entry->last_trans,
> + (unsigned long long)__entry->logged_trans)
> +);
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +);
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +);
> +
> +DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +);
> +
> +#define __show_map_type(type) \
> + __print_symbolic_u64(type, \
> + { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
> + { EXTENT_MAP_HOLE, "HOLE" }, \
> + { EXTENT_MAP_INLINE, "INLINE" }, \
> + { EXTENT_MAP_DELALLOC, "DELALLOC" })
> +
> +#define show_map_type(type) \
> + type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
> +
> +#define show_map_flags(flag) \
> + __print_flags(flag, "|", \
> + { EXTENT_FLAG_PINNED, "PINNED" }, \
> + { EXTENT_FLAG_COMPRESSED, "COMPRESSED" }, \
> + { EXTENT_FLAG_VACANCY, "VACANCY" }, \
> + { EXTENT_FLAG_PREALLOC, "PREALLOC" })
> +
> +TRACE_EVENT(btrfs_get_extent,
> +
> + TP_PROTO(struct btrfs_root *root, struct extent_map *map),
> +
> + TP_ARGS(root, map),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, start )
> + __field( u64, len )
> + __field( u64, orig_start )
> + __field( u64, block_start )
> + __field( u64, block_len )
> + __field( unsigned long, flags )
> + __field( int, refs )
> + __field( unsigned int, compress_type )
> + ),
> +
> + TP_fast_assign(
> + __entry->root_objectid = root->root_key.objectid;
> + __entry->start = map->start;
> + __entry->len = map->len;
> + __entry->orig_start = map->orig_start;
> + __entry->block_start = map->block_start;
> + __entry->block_len = map->block_len;
> + __entry->flags = map->flags;
> + __entry->refs = atomic_read(&map->refs);
> + __entry->compress_type = map->compress_type;
> + ),
> +
> + TP_printk("root = %llu(%s), start = %llu, len = %llu, "
> + "orig_start = %llu, block_start = %llu(%s), "
> + "block_len = %llu, flags = %s, refs = %u, "
> + "compress_type = %u",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len,
> + (unsigned long long)__entry->orig_start,
> + show_map_type(__entry->block_start),
> + (unsigned long long)__entry->block_len,
> + show_map_flags(__entry->flags),
> + __entry->refs, __entry->compress_type)
> +);
> +
> +#define show_ordered_flags(flags) \
> + __print_symbolic(flags, \
> + { BTRFS_ORDERED_IO_DONE, "IO_DONE" }, \
> + { BTRFS_ORDERED_COMPLETE, "COMPLETE" }, \
> + { BTRFS_ORDERED_NOCOW, "NOCOW" }, \
> + { BTRFS_ORDERED_COMPRESSED, "COMPRESSED" }, \
> + { BTRFS_ORDERED_PREALLOC, "PREALLOC" }, \
> + { BTRFS_ORDERED_DIRECT, "DIRECT" })
> +
> +DECLARE_EVENT_CLASS(btrfs__ordered_extent,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( u64, file_offset )
> + __field( u64, start )
> + __field( u64, len )
> + __field( u64, disk_len )
> + __field( u64, bytes_left )
> + __field( unsigned long, flags )
> + __field( int, compress_type )
> + __field( int, refs )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->ino = inode->i_ino;
> + __entry->file_offset = ordered->file_offset;
> + __entry->start = ordered->start;
> + __entry->len = ordered->len;
> + __entry->disk_len = ordered->disk_len;
> + __entry->bytes_left = ordered->bytes_left;
> + __entry->flags = ordered->flags;
> + __entry->compress_type = ordered->compress_type;
> + __entry->refs = atomic_read(&ordered->refs);
> + __entry->root_objectid =
> + BTRFS_I(inode)->root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %llu, file_offset = %llu, "
> + "start = %llu, len = %llu, disk_len = %llu, "
> + "bytes_left = %llu, flags = %s, compress_type = %d, "
> + "refs = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->ino,
> + (unsigned long long)__entry->file_offset,
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len,
> + (unsigned long long)__entry->disk_len,
> + (unsigned long long)__entry->bytes_left,
> + show_ordered_flags(__entry->flags),
> + __entry->compress_type, __entry->refs)
> +);
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +);
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +);
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +);
> +
> +DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
> +
> + TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
> +
> + TP_ARGS(inode, ordered)
> +);
> +
> +DECLARE_EVENT_CLASS(btrfs__writepage,
> +
> + TP_PROTO(struct page *page, struct inode *inode,
> + struct writeback_control *wbc),
> +
> + TP_ARGS(page, inode, wbc),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( long, nr_to_write )
> + __field( long, pages_skipped )
> + __field( loff_t, range_start )
> + __field( loff_t, range_end )
> + __field( char, for_kupdate )
> + __field( char, for_reclaim )
> + __field( char, range_cyclic )
> + __field( pgoff_t, writeback_index )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->ino = inode->i_ino;
> + __entry->index = page->index;
> + __entry->nr_to_write = wbc->nr_to_write;
> + __entry->pages_skipped = wbc->pages_skipped;
> + __entry->range_start = wbc->range_start;
> + __entry->range_end = wbc->range_end;
> + __entry->for_kupdate = wbc->for_kupdate;
> + __entry->for_reclaim = wbc->for_reclaim;
> + __entry->range_cyclic = wbc->range_cyclic;
> + __entry->writeback_index = inode->i_mapping->writeback_index;
> + __entry->root_objectid =
> + BTRFS_I(inode)->root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
> + "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
> + "range_end = %llu, for_kupdate = %d, "
> + "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, __entry->index,
> + __entry->nr_to_write, __entry->pages_skipped,
> + __entry->range_start, __entry->range_end,
> + __entry->for_kupdate,
> + __entry->for_reclaim, __entry->range_cyclic,
> + (unsigned long)__entry->writeback_index)
> +);
> +
> +DEFINE_EVENT(btrfs__writepage, __extent_writepage,
> +
> + TP_PROTO(struct page *page, struct inode *inode,
> + struct writeback_control *wbc),
> +
> + TP_ARGS(page, inode, wbc)
> +);
> +
> +TRACE_EVENT(btrfs_writepage_end_io_hook,
> +
> + TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
> +
> + TP_ARGS(page, start, end, uptodate),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( u64, start )
> + __field( u64, end )
> + __field( int, uptodate )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->ino = page->mapping->host->i_ino;
> + __entry->index = page->index;
> + __entry->start = start;
> + __entry->end = end;
> + __entry->uptodate = uptodate;
> + __entry->root_objectid =
> + BTRFS_I(page->mapping->host)->root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
> + "end = %llu, uptodate = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, (unsigned long)__entry->index,
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->end, __entry->uptodate)
> +);
> +
> +TRACE_EVENT(btrfs_sync_file,
> +
> + TP_PROTO(struct file *file, int datasync),
> +
> + TP_ARGS(file, datasync),
> +
> + TP_STRUCT__entry(
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( int, datasync )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + struct dentry *dentry = file->f_path.dentry;
> + struct inode *inode = dentry->d_inode;
> +
> + __entry->ino = inode->i_ino;
> + __entry->parent = dentry->d_parent->d_inode->i_ino;
> + __entry->datasync = datasync;
> + __entry->root_objectid =
> + BTRFS_I(inode)->root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
> + show_root_type(__entry->root_objectid),
> + (unsigned long)__entry->ino, (unsigned long)__entry->parent,
> + __entry->datasync)
> +);
> +
> +TRACE_EVENT(btrfs_sync_fs,
> +
> + TP_PROTO(int wait),
> +
> + TP_ARGS(wait),
> +
> + TP_STRUCT__entry(
> + __field( int, wait )
> + ),
> +
> + TP_fast_assign(
> + __entry->wait = wait;
> + ),
> +
> + TP_printk("wait = %d", __entry->wait)
> +);
> +
> +#define show_ref_action(action) \
> + __print_symbolic(action, \
> + { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
> + { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
> + { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
> + { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
> +
> +
> +TRACE_EVENT(btrfs_delayed_tree_ref,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_tree_ref *full_ref,
> + int action),
> +
> + TP_ARGS(ref, full_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( u64, parent )
> + __field( u64, ref_root )
> + __field( int, level )
> + __field( int, type )
> + __field( u64, seq )
> + ),
> +
> + TP_fast_assign(
> + __entry->bytenr = ref->bytenr;
> + __entry->num_bytes = ref->num_bytes;
> + __entry->action = action;
> + __entry->parent = full_ref->parent;
> + __entry->ref_root = full_ref->root;
> + __entry->level = full_ref->level;
> + __entry->type = ref->type;
> + __entry->seq = ref->seq;
> + ),
> +
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
> + "type = %s, seq = %llu",
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + show_root_type(__entry->parent),
> + show_root_type(__entry->ref_root),
> + __entry->level, show_ref_type(__entry->type),
> + (unsigned long long)__entry->seq)
> +);
> +
> +TRACE_EVENT(btrfs_delayed_data_ref,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_data_ref *full_ref,
> + int action),
> +
> + TP_ARGS(ref, full_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( u64, parent )
> + __field( u64, ref_root )
> + __field( u64, owner )
> + __field( u64, offset )
> + __field( int, type )
> + __field( u64, seq )
> + ),
> +
> + TP_fast_assign(
> + __entry->bytenr = ref->bytenr;
> + __entry->num_bytes = ref->num_bytes;
> + __entry->action = action;
> + __entry->parent = full_ref->parent;
> + __entry->ref_root = full_ref->root;
> + __entry->owner = full_ref->objectid;
> + __entry->offset = full_ref->offset;
> + __entry->type = ref->type;
> + __entry->seq = ref->seq;
> + ),
> +
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
> + "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
> + "offset = %llu, type = %s, seq = %llu",
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + show_root_type(__entry->parent),
> + show_root_type(__entry->ref_root),
> + (unsigned long long)__entry->owner,
> + (unsigned long long)__entry->offset,
> + show_ref_type(__entry->type),
> + (unsigned long long)__entry->seq)
> +);
> +
> +TRACE_EVENT(btrfs_delayed_ref_head,
> +
> + TP_PROTO(struct btrfs_delayed_ref_node *ref,
> + struct btrfs_delayed_ref_head *head_ref,
> + int action),
> +
> + TP_ARGS(ref, head_ref, action),
> +
> + TP_STRUCT__entry(
> + __field( u64, bytenr )
> + __field( u64, num_bytes )
> + __field( int, action )
> + __field( int, is_data )
> + ),
> +
> + TP_fast_assign(
> + __entry->bytenr = ref->bytenr;
> + __entry->num_bytes = ref->num_bytes;
> + __entry->action = action;
> + __entry->is_data = head_ref->is_data;
> + ),
> +
> + TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
> + (unsigned long long)__entry->bytenr,
> + (unsigned long long)__entry->num_bytes,
> + show_ref_action(__entry->action),
> + __entry->is_data)
> +);
> +
> +#define show_chunk_type(type) \
> + __print_flags(type, "|", \
> + { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
> + { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
> + { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
> + { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
> + { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
> + { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
> + { BTRFS_BLOCK_GROUP_RAID10, "RAID10"})
> +
> +DECLARE_EVENT_CLASS(btrfs__chunk,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size),
> +
> + TP_STRUCT__entry(
> + __field( int, num_stripes )
> + __field( u64, type )
> + __field( int, sub_stripes )
> + __field( u64, offset )
> + __field( u64, size )
> + __field( u64, root_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->num_stripes = map->num_stripes;
> + __entry->type = map->type;
> + __entry->sub_stripes = map->sub_stripes;
> + __entry->offset = offset;
> + __entry->size = size;
> + __entry->root_objectid = root->root_key.objectid;
> + ),
> +
> + TP_printk("root = %llu(%s), offset = %llu, size = %llu, "
> + "num_stripes = %d, sub_stripes = %d, type = %s",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->offset,
> + (unsigned long long)__entry->size,
> + __entry->num_stripes, __entry->sub_stripes,
> + show_chunk_type(__entry->type))
> +);
> +
> +DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size)
> +);
> +
> +DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
> +
> + TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
> + u64 offset, u64 size),
> +
> + TP_ARGS(root, map, offset, size)
> +);
> +
> +TRACE_EVENT(btrfs_cow_block,
> +
> + TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
> + struct extent_buffer *cow),
> +
> + TP_ARGS(root, buf, cow),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, buf_start )
> + __field( int, refs )
> + __field( u64, cow_start )
> + __field( int, buf_level )
> + __field( int, cow_level )
> + ),
> +
> + TP_fast_assign(
> + __entry->root_objectid = root->root_key.objectid;
> + __entry->buf_start = buf->start;
> + __entry->refs = atomic_read(&buf->refs);
> + __entry->cow_start = cow->start;
> + __entry->buf_level = btrfs_header_level(buf);
> + __entry->cow_level = btrfs_header_level(cow);
> + ),
> +
> + TP_printk("root = %llu(%s), refs = %d, orig_buf = %llu "
> + "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
> + show_root_type(__entry->root_objectid),
> + __entry->refs,
> + (unsigned long long)__entry->buf_start,
> + __entry->buf_level,
> + (unsigned long long)__entry->cow_start,
> + __entry->cow_level)
> +);
> +
> +TRACE_EVENT(btrfs_space_reservation,
> +
> + TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
> + u64 bytes, int reserve),
> +
> + TP_ARGS(fs_info, type, val, bytes, reserve),
> +
> + TP_STRUCT__entry(
> + __array( u8, fsid, BTRFS_UUID_SIZE )
> + __string( type, type )
> + __field( u64, val )
> + __field( u64, bytes )
> + __field( int, reserve )
> + ),
> +
> + TP_fast_assign(
> + memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
> + __assign_str(type, type);
> + __entry->val = val;
> + __entry->bytes = bytes;
> + __entry->reserve = reserve;
> + ),
> +
> + TP_printk("%pU: %s: %Lu %s %Lu", __entry->fsid, __get_str(type),
> + __entry->val, __entry->reserve ? "reserve" : "release",
> + __entry->bytes)
> +);
> +
> +DECLARE_EVENT_CLASS(btrfs__reserved_extent,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, start )
> + __field( u64, len )
> + ),
> +
> + TP_fast_assign(
> + __entry->root_objectid = root->root_key.objectid;
> + __entry->start = start;
> + __entry->len = len;
> + ),
> +
> + TP_printk("root = %llu(%s), start = %llu, len = %llu",
> + show_root_type(__entry->root_objectid),
> + (unsigned long long)__entry->start,
> + (unsigned long long)__entry->len)
> +);
> +
> +DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len)
> +);
> +
> +DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
> +
> + TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
> +
> + TP_ARGS(root, start, len)
> +);
> +
> +TRACE_EVENT(find_free_extent,
> +
> + TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
> + u64 data),
> +
> + TP_ARGS(root, num_bytes, empty_size, data),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, num_bytes )
> + __field( u64, empty_size )
> + __field( u64, data )
> + ),
> +
> + TP_fast_assign(
> + __entry->root_objectid = root->root_key.objectid;
> + __entry->num_bytes = num_bytes;
> + __entry->empty_size = empty_size;
> + __entry->data = data;
> + ),
> +
> + TP_printk("root = %Lu(%s), len = %Lu, empty_size = %Lu, "
> + "flags = %Lu(%s)", show_root_type(__entry->root_objectid),
> + __entry->num_bytes, __entry->empty_size, __entry->data,
> + __print_flags((unsigned long)__entry->data, "|",
> + BTRFS_GROUP_FLAGS))
> +);
> +
> +DECLARE_EVENT_CLASS(btrfs__reserve_extent,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len),
> +
> + TP_STRUCT__entry(
> + __field( u64, root_objectid )
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, len )
> + ),
> +
> + TP_fast_assign(
> + __entry->root_objectid = root->root_key.objectid;
> + __entry->bg_objectid = block_group->key.objectid;
> + __entry->flags = block_group->flags;
> + __entry->start = start;
> + __entry->len = len;
> + ),
> +
> + TP_printk("root = %Lu(%s), block_group = %Lu, flags = %Lu(%s), "
> + "start = %Lu, len = %Lu",
> + show_root_type(__entry->root_objectid), __entry->bg_objectid,
> + __entry->flags, __print_flags((unsigned long)__entry->flags,
> + "|", BTRFS_GROUP_FLAGS),
> + __entry->start, __entry->len)
> +);
> +
> +DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len)
> +);
> +
> +DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
> +
> + TP_PROTO(struct btrfs_root *root,
> + struct btrfs_block_group_cache *block_group, u64 start,
> + u64 len),
> +
> + TP_ARGS(root, block_group, start, len)
> +);
> +
> +TRACE_EVENT(btrfs_find_cluster,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
> + u64 bytes, u64 empty_size, u64 min_bytes),
> +
> + TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, bytes )
> + __field( u64, empty_size )
> + __field( u64, min_bytes )
> + ),
> +
> + TP_fast_assign(
> + __entry->bg_objectid = block_group->key.objectid;
> + __entry->flags = block_group->flags;
> + __entry->start = start;
> + __entry->bytes = bytes;
> + __entry->empty_size = empty_size;
> + __entry->min_bytes = min_bytes;
> + ),
> +
> + TP_printk("block_group = %Lu, flags = %Lu(%s), start = %Lu, len = %Lu,"
> + " empty_size = %Lu, min_bytes = %Lu", __entry->bg_objectid,
> + __entry->flags,
> + __print_flags((unsigned long)__entry->flags, "|",
> + BTRFS_GROUP_FLAGS), __entry->start,
> + __entry->bytes, __entry->empty_size, __entry->min_bytes)
> +);
> +
> +TRACE_EVENT(btrfs_failed_cluster_setup,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group),
> +
> + TP_ARGS(block_group),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + ),
> +
> + TP_fast_assign(
> + __entry->bg_objectid = block_group->key.objectid;
> + ),
> +
> + TP_printk("block_group = %Lu", __entry->bg_objectid)
> +);
> +
> +TRACE_EVENT(btrfs_setup_cluster,
> +
> + TP_PROTO(struct btrfs_block_group_cache *block_group,
> + struct btrfs_free_cluster *cluster, u64 size, int bitmap),
> +
> + TP_ARGS(block_group, cluster, size, bitmap),
> +
> + TP_STRUCT__entry(
> + __field( u64, bg_objectid )
> + __field( u64, flags )
> + __field( u64, start )
> + __field( u64, max_size )
> + __field( u64, size )
> + __field( int, bitmap )
> + ),
> +
> + TP_fast_assign(
> + __entry->bg_objectid = block_group->key.objectid;
> + __entry->flags = block_group->flags;
> + __entry->start = cluster->window_start;
> + __entry->max_size = cluster->max_size;
> + __entry->size = size;
> + __entry->bitmap = bitmap;
> + ),
> +
> + TP_printk("block_group = %Lu, flags = %Lu(%s), window_start = %Lu, "
> + "size = %Lu, max_size = %Lu, bitmap = %d",
> + __entry->bg_objectid,
> + __entry->flags,
> + __print_flags((unsigned long)__entry->flags, "|",
> + BTRFS_GROUP_FLAGS), __entry->start,
> + __entry->size, __entry->max_size, __entry->bitmap)
> +);
> +
> +struct extent_state;
> +TRACE_EVENT(alloc_extent_state,
> +
> + TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
> +
> + TP_ARGS(state, mask, IP),
> +
> + TP_STRUCT__entry(
> + __field(struct extent_state *, state)
> + __field(gfp_t, mask)
> + __field(unsigned long, ip)
> + ),
> +
> + TP_fast_assign(
> + __entry->state = state,
> + __entry->mask = mask,
> + __entry->ip = IP
> + ),
> +
> + TP_printk("state=%p; mask = %s; caller = %pF", __entry->state,
> + show_gfp_flags(__entry->mask), (void *)__entry->ip)
> +);
> +
> +TRACE_EVENT(free_extent_state,
> +
> + TP_PROTO(struct extent_state *state, unsigned long IP),
> +
> + TP_ARGS(state, IP),
> +
> + TP_STRUCT__entry(
> + __field(struct extent_state *, state)
> + __field(unsigned long, ip)
> + ),
> +
> + TP_fast_assign(
> + __entry->state = state,
> + __entry->ip = IP
> + ),
> +
> + TP_printk(" state=%p; caller = %pF", __entry->state,
> + (void *)__entry->ip)
> +);
> +
> +#endif /* _TRACE_BTRFS_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/compaction.h b/instrumentation/events/mainline/compaction.h
> new file mode 100644
> index 0000000..fde1b3e
> --- /dev/null
> +++ b/instrumentation/events/mainline/compaction.h
> @@ -0,0 +1,74 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM compaction
> +
> +#if !defined(_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_COMPACTION_H
> +
> +#include <linux/types.h>
> +#include <linux/tracepoint.h>
> +#include <trace/events/gfpflags.h>
> +
> +DECLARE_EVENT_CLASS(mm_compaction_isolate_template,
> +
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_scanned)
> + __field(unsigned long, nr_taken)
> + ),
> +
> + TP_fast_assign(
> + __entry->nr_scanned = nr_scanned;
> + __entry->nr_taken = nr_taken;
> + ),
> +
> + TP_printk("nr_scanned=%lu nr_taken=%lu",
> + __entry->nr_scanned,
> + __entry->nr_taken)
> +);
> +
> +DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_migratepages,
> +
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken)
> +);
> +
> +DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_freepages,
> + TP_PROTO(unsigned long nr_scanned,
> + unsigned long nr_taken),
> +
> + TP_ARGS(nr_scanned, nr_taken)
> +);
> +
> +TRACE_EVENT(mm_compaction_migratepages,
> +
> + TP_PROTO(unsigned long nr_migrated,
> + unsigned long nr_failed),
> +
> + TP_ARGS(nr_migrated, nr_failed),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_migrated)
> + __field(unsigned long, nr_failed)
> + ),
> +
> + TP_fast_assign(
> + __entry->nr_migrated = nr_migrated;
> + __entry->nr_failed = nr_failed;
> + ),
> +
> + TP_printk("nr_migrated=%lu nr_failed=%lu",
> + __entry->nr_migrated,
> + __entry->nr_failed)
> +);
> +
> +
> +#endif /* _TRACE_COMPACTION_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/ext4.h b/instrumentation/events/mainline/ext4.h
> new file mode 100644
> index 0000000..d49b285
> --- /dev/null
> +++ b/instrumentation/events/mainline/ext4.h
> @@ -0,0 +1,2061 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM ext4
> +
> +#if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_EXT4_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +
> +struct ext4_allocation_context;
> +struct ext4_allocation_request;
> +struct ext4_extent;
> +struct ext4_prealloc_space;
> +struct ext4_inode_info;
> +struct mpage_da_data;
> +struct ext4_map_blocks;
> +struct ext4_extent;
> +
> +#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
> +
> +TRACE_EVENT(ext4_free_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( uid_t, uid )
> + __field( gid_t, gid )
> + __field( __u64, blocks )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->uid = i_uid_read(inode);
> + __entry->gid = i_gid_read(inode);
> + __entry->blocks = inode->i_blocks;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->mode,
> + __entry->uid, __entry->gid, __entry->blocks)
> +);
> +
> +TRACE_EVENT(ext4_request_inode,
> + TP_PROTO(struct inode *dir, int mode),
> +
> + TP_ARGS(dir, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, dir )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = dir->i_sb->s_dev;
> + __entry->dir = dir->i_ino;
> + __entry->mode = mode;
> + ),
> +
> + TP_printk("dev %d,%d dir %lu mode 0%o",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->dir, __entry->mode)
> +);
> +
> +TRACE_EVENT(ext4_allocate_inode,
> + TP_PROTO(struct inode *inode, struct inode *dir, int mode),
> +
> + TP_ARGS(inode, dir, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, dir )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->dir = dir->i_ino;
> + __entry->mode = mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->dir, __entry->mode)
> +);
> +
> +TRACE_EVENT(ext4_evict_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, nlink )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->nlink = inode->i_nlink;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu nlink %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->nlink)
> +);
> +
> +TRACE_EVENT(ext4_drop_inode,
> + TP_PROTO(struct inode *inode, int drop),
> +
> + TP_ARGS(inode, drop),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, drop )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->drop = drop;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu drop %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->drop)
> +);
> +
> +TRACE_EVENT(ext4_mark_inode_dirty,
> + TP_PROTO(struct inode *inode, unsigned long IP),
> +
> + TP_ARGS(inode, IP),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field(unsigned long, ip )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->ip = IP;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu caller %pF",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, (void *)__entry->ip)
> +);
> +
> +TRACE_EVENT(ext4_begin_ordered_truncate,
> + TP_PROTO(struct inode *inode, loff_t new_size),
> +
> + TP_ARGS(inode, new_size),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, new_size )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->new_size = new_size;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu new_size %lld",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->new_size)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, len )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = pos;
> + __entry->len = len;
> + __entry->flags = flags;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %u flags %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->flags)
> +);
> +
> +DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags)
> +);
> +
> +DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int flags),
> +
> + TP_ARGS(inode, pos, len, flags)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__write_end,
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, len )
> + __field( unsigned int, copied )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = pos;
> + __entry->len = len;
> + __entry->copied = copied;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->copied)
> +);
> +
> +DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +);
> +
> +DEFINE_EVENT(ext4__write_end, ext4_writeback_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +);
> +
> +DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +);
> +
> +DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
> +
> + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
> + unsigned int copied),
> +
> + TP_ARGS(inode, pos, len, copied)
> +);
> +
> +TRACE_EVENT(ext4_da_writepages,
> + TP_PROTO(struct inode *inode, struct writeback_control *wbc),
> +
> + TP_ARGS(inode, wbc),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( long, nr_to_write )
> + __field( long, pages_skipped )
> + __field( loff_t, range_start )
> + __field( loff_t, range_end )
> + __field( pgoff_t, writeback_index )
> + __field( int, sync_mode )
> + __field( char, for_kupdate )
> + __field( char, range_cyclic )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->nr_to_write = wbc->nr_to_write;
> + __entry->pages_skipped = wbc->pages_skipped;
> + __entry->range_start = wbc->range_start;
> + __entry->range_end = wbc->range_end;
> + __entry->writeback_index = inode->i_mapping->writeback_index;
> + __entry->sync_mode = wbc->sync_mode;
> + __entry->for_kupdate = wbc->for_kupdate;
> + __entry->range_cyclic = wbc->range_cyclic;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
> + "range_start %lld range_end %lld sync_mode %d "
> + "for_kupdate %d range_cyclic %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->nr_to_write,
> + __entry->pages_skipped, __entry->range_start,
> + __entry->range_end, __entry->sync_mode,
> + __entry->for_kupdate, __entry->range_cyclic,
> + (unsigned long) __entry->writeback_index)
> +);
> +
> +TRACE_EVENT(ext4_da_write_pages,
> + TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
> +
> + TP_ARGS(inode, mpd),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, b_blocknr )
> + __field( __u32, b_size )
> + __field( __u32, b_state )
> + __field( unsigned long, first_page )
> + __field( int, io_done )
> + __field( int, pages_written )
> + __field( int, sync_mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->b_blocknr = mpd->b_blocknr;
> + __entry->b_size = mpd->b_size;
> + __entry->b_state = mpd->b_state;
> + __entry->first_page = mpd->first_page;
> + __entry->io_done = mpd->io_done;
> + __entry->pages_written = mpd->pages_written;
> + __entry->sync_mode = mpd->wbc->sync_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
> + "first_page %lu io_done %d pages_written %d sync_mode %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->b_blocknr, __entry->b_size,
> + __entry->b_state, __entry->first_page,
> + __entry->io_done, __entry->pages_written,
> + __entry->sync_mode
> + )
> +);
> +
> +TRACE_EVENT(ext4_da_writepages_result,
> + TP_PROTO(struct inode *inode, struct writeback_control *wbc,
> + int ret, int pages_written),
> +
> + TP_ARGS(inode, wbc, ret, pages_written),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + __field( int, pages_written )
> + __field( long, pages_skipped )
> + __field( pgoff_t, writeback_index )
> + __field( int, sync_mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->ret = ret;
> + __entry->pages_written = pages_written;
> + __entry->pages_skipped = wbc->pages_skipped;
> + __entry->writeback_index = inode->i_mapping->writeback_index;
> + __entry->sync_mode = wbc->sync_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
> + "sync_mode %d writeback_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->ret,
> + __entry->pages_written, __entry->pages_skipped,
> + __entry->sync_mode,
> + (unsigned long) __entry->writeback_index)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__page_op,
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = page->mapping->host->i_sb->s_dev;
> + __entry->ino = page->mapping->host->i_ino;
> + __entry->index = page->index;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu page_index %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->index)
> +);
> +
> +DEFINE_EVENT(ext4__page_op, ext4_writepage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +);
> +
> +DEFINE_EVENT(ext4__page_op, ext4_readpage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +);
> +
> +DEFINE_EVENT(ext4__page_op, ext4_releasepage,
> +
> + TP_PROTO(struct page *page),
> +
> + TP_ARGS(page)
> +);
> +
> +TRACE_EVENT(ext4_invalidatepage,
> + TP_PROTO(struct page *page, unsigned long offset),
> +
> + TP_ARGS(page, offset),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( pgoff_t, index )
> + __field( unsigned long, offset )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = page->mapping->host->i_sb->s_dev;
> + __entry->ino = page->mapping->host->i_ino;
> + __entry->index = page->index;
> + __entry->offset = offset;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->index, __entry->offset)
> +);
> +
> +TRACE_EVENT(ext4_discard_blocks,
> + TP_PROTO(struct super_block *sb, unsigned long long blk,
> + unsigned long long count),
> +
> + TP_ARGS(sb, blk, count),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( __u64, blk )
> + __field( __u64, count )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->blk = blk;
> + __entry->count = count;
> + ),
> +
> + TP_printk("dev %d,%d blk %llu count %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->blk, __entry->count)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__mb_new_pa,
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, pa_pstart )
> + __field( __u64, pa_lstart )
> + __field( __u32, pa_len )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = ac->ac_sb->s_dev;
> + __entry->ino = ac->ac_inode->i_ino;
> + __entry->pa_pstart = pa->pa_pstart;
> + __entry->pa_lstart = pa->pa_lstart;
> + __entry->pa_len = pa->pa_len;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
> +);
> +
> +DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
> +
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa)
> +);
> +
> +DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
> +
> + TP_PROTO(struct ext4_allocation_context *ac,
> + struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(ac, pa)
> +);
> +
> +TRACE_EVENT(ext4_mb_release_inode_pa,
> + TP_PROTO(struct ext4_prealloc_space *pa,
> + unsigned long long block, unsigned int count),
> +
> + TP_ARGS(pa, block, count),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( __u32, count )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = pa->pa_inode->i_sb->s_dev;
> + __entry->ino = pa->pa_inode->i_ino;
> + __entry->block = block;
> + __entry->count = count;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu block %llu count %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->block, __entry->count)
> +);
> +
> +TRACE_EVENT(ext4_mb_release_group_pa,
> + TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
> +
> + TP_ARGS(sb, pa),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( __u64, pa_pstart )
> + __field( __u32, pa_len )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->pa_pstart = pa->pa_pstart;
> + __entry->pa_len = pa->pa_len;
> + ),
> +
> + TP_printk("dev %d,%d pstart %llu len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->pa_pstart, __entry->pa_len)
> +);
> +
> +TRACE_EVENT(ext4_discard_preallocations,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino)
> +);
> +
> +TRACE_EVENT(ext4_mb_discard_preallocations,
> + TP_PROTO(struct super_block *sb, int needed),
> +
> + TP_ARGS(sb, needed),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( int, needed )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->needed = needed;
> + ),
> +
> + TP_printk("dev %d,%d needed %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->needed)
> +);
> +
> +TRACE_EVENT(ext4_request_blocks,
> + TP_PROTO(struct ext4_allocation_request *ar),
> +
> + TP_ARGS(ar),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( unsigned int, len )
> + __field( __u32, logical )
> + __field( __u32, lleft )
> + __field( __u32, lright )
> + __field( __u64, goal )
> + __field( __u64, pleft )
> + __field( __u64, pright )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = ar->inode->i_sb->s_dev;
> + __entry->ino = ar->inode->i_ino;
> + __entry->len = ar->len;
> + __entry->logical = ar->logical;
> + __entry->goal = ar->goal;
> + __entry->lleft = ar->lleft;
> + __entry->lright = ar->lright;
> + __entry->pleft = ar->pleft;
> + __entry->pright = ar->pright;
> + __entry->flags = ar->flags;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu flags %u len %u lblk %u goal %llu "
> + "lleft %u lright %u pleft %llu pright %llu ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->flags,
> + __entry->len, __entry->logical, __entry->goal,
> + __entry->lleft, __entry->lright, __entry->pleft,
> + __entry->pright)
> +);
> +
> +TRACE_EVENT(ext4_allocate_blocks,
> + TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
> +
> + TP_ARGS(ar, block),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( unsigned int, len )
> + __field( __u32, logical )
> + __field( __u32, lleft )
> + __field( __u32, lright )
> + __field( __u64, goal )
> + __field( __u64, pleft )
> + __field( __u64, pright )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = ar->inode->i_sb->s_dev;
> + __entry->ino = ar->inode->i_ino;
> + __entry->block = block;
> + __entry->len = ar->len;
> + __entry->logical = ar->logical;
> + __entry->goal = ar->goal;
> + __entry->lleft = ar->lleft;
> + __entry->lright = ar->lright;
> + __entry->pleft = ar->pleft;
> + __entry->pright = ar->pright;
> + __entry->flags = ar->flags;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %u "
> + "goal %llu lleft %u lright %u pleft %llu pright %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->flags,
> + __entry->len, __entry->block, __entry->logical,
> + __entry->goal, __entry->lleft, __entry->lright,
> + __entry->pleft, __entry->pright)
> +);
> +
> +TRACE_EVENT(ext4_free_blocks,
> + TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
> + int flags),
> +
> + TP_ARGS(inode, block, count, flags),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( unsigned long, count )
> + __field( int, flags )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->block = block;
> + __entry->count = count;
> + __entry->flags = flags;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->block, __entry->count,
> + __entry->flags)
> +);
> +
> +TRACE_EVENT(ext4_sync_file_enter,
> + TP_PROTO(struct file *file, int datasync),
> +
> + TP_ARGS(file, datasync),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( int, datasync )
> + ),
> +
> + TP_fast_assign(
> + struct dentry *dentry = file->f_path.dentry;
> +
> + __entry->dev = dentry->d_inode->i_sb->s_dev;
> + __entry->ino = dentry->d_inode->i_ino;
> + __entry->datasync = datasync;
> + __entry->parent = dentry->d_parent->d_inode->i_ino;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long) __entry->parent, __entry->datasync)
> +);
> +
> +TRACE_EVENT(ext4_sync_file_exit,
> + TP_PROTO(struct inode *inode, int ret),
> +
> + TP_ARGS(inode, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->ret)
> +);
> +
> +TRACE_EVENT(ext4_sync_fs,
> + TP_PROTO(struct super_block *sb, int wait),
> +
> + TP_ARGS(sb, wait),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( int, wait )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->wait = wait;
> + ),
> +
> + TP_printk("dev %d,%d wait %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->wait)
> +);
> +
> +TRACE_EVENT(ext4_alloc_da_blocks,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( unsigned int, data_blocks )
> + __field( unsigned int, meta_blocks )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
> + __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->data_blocks, __entry->meta_blocks)
> +);
> +
> +TRACE_EVENT(ext4_mballoc_alloc,
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u32, orig_logical )
> + __field( int, orig_start )
> + __field( __u32, orig_group )
> + __field( int, orig_len )
> + __field( __u32, goal_logical )
> + __field( int, goal_start )
> + __field( __u32, goal_group )
> + __field( int, goal_len )
> + __field( __u32, result_logical )
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + __field( __u16, found )
> + __field( __u16, groups )
> + __field( __u16, buddy )
> + __field( __u16, flags )
> + __field( __u16, tail )
> + __field( __u8, cr )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = ac->ac_inode->i_sb->s_dev;
> + __entry->ino = ac->ac_inode->i_ino;
> + __entry->orig_logical = ac->ac_o_ex.fe_logical;
> + __entry->orig_start = ac->ac_o_ex.fe_start;
> + __entry->orig_group = ac->ac_o_ex.fe_group;
> + __entry->orig_len = ac->ac_o_ex.fe_len;
> + __entry->goal_logical = ac->ac_g_ex.fe_logical;
> + __entry->goal_start = ac->ac_g_ex.fe_start;
> + __entry->goal_group = ac->ac_g_ex.fe_group;
> + __entry->goal_len = ac->ac_g_ex.fe_len;
> + __entry->result_logical = ac->ac_f_ex.fe_logical;
> + __entry->result_start = ac->ac_f_ex.fe_start;
> + __entry->result_group = ac->ac_f_ex.fe_group;
> + __entry->result_len = ac->ac_f_ex.fe_len;
> + __entry->found = ac->ac_found;
> + __entry->flags = ac->ac_flags;
> + __entry->groups = ac->ac_groups_scanned;
> + __entry->buddy = ac->ac_buddy;
> + __entry->tail = ac->ac_tail;
> + __entry->cr = ac->ac_criteria;
> + ),
> +
> + TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
> + "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
> + "tail %u broken %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->orig_group, __entry->orig_start,
> + __entry->orig_len, __entry->orig_logical,
> + __entry->goal_group, __entry->goal_start,
> + __entry->goal_len, __entry->goal_logical,
> + __entry->result_group, __entry->result_start,
> + __entry->result_len, __entry->result_logical,
> + __entry->found, __entry->groups, __entry->cr,
> + __entry->flags, __entry->tail,
> + __entry->buddy ? 1 << __entry->buddy : 0)
> +);
> +
> +TRACE_EVENT(ext4_mballoc_prealloc,
> + TP_PROTO(struct ext4_allocation_context *ac),
> +
> + TP_ARGS(ac),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u32, orig_logical )
> + __field( int, orig_start )
> + __field( __u32, orig_group )
> + __field( int, orig_len )
> + __field( __u32, result_logical )
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = ac->ac_inode->i_sb->s_dev;
> + __entry->ino = ac->ac_inode->i_ino;
> + __entry->orig_logical = ac->ac_o_ex.fe_logical;
> + __entry->orig_start = ac->ac_o_ex.fe_start;
> + __entry->orig_group = ac->ac_o_ex.fe_group;
> + __entry->orig_len = ac->ac_o_ex.fe_len;
> + __entry->result_logical = ac->ac_b_ex.fe_logical;
> + __entry->result_start = ac->ac_b_ex.fe_start;
> + __entry->result_group = ac->ac_b_ex.fe_group;
> + __entry->result_len = ac->ac_b_ex.fe_len;
> + ),
> +
> + TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->orig_group, __entry->orig_start,
> + __entry->orig_len, __entry->orig_logical,
> + __entry->result_group, __entry->result_start,
> + __entry->result_len, __entry->result_logical)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__mballoc,
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, result_start )
> + __field( __u32, result_group )
> + __field( int, result_len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->ino = inode ? inode->i_ino : 0;
> + __entry->result_start = start;
> + __entry->result_group = group;
> + __entry->result_len = len;
> + ),
> +
> + TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->result_group, __entry->result_start,
> + __entry->result_len)
> +);
> +
> +DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
> +
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len)
> +);
> +
> +DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
> +
> + TP_PROTO(struct super_block *sb,
> + struct inode *inode,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, inode, group, start, len)
> +);
> +
> +TRACE_EVENT(ext4_forget,
> + TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
> +
> + TP_ARGS(inode, is_metadata, block),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, block )
> + __field( int, is_metadata )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->block = block;
> + __entry->is_metadata = is_metadata;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->is_metadata, __entry->block)
> +);
> +
> +TRACE_EVENT(ext4_da_update_reserve_space,
> + TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
> +
> + TP_ARGS(inode, used_blocks, quota_claim),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, used_blocks )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( int, allocated_meta_blocks )
> + __field( int, quota_claim )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->i_blocks = inode->i_blocks;
> + __entry->used_blocks = used_blocks;
> + __entry->reserved_data_blocks =
> + EXT4_I(inode)->i_reserved_data_blocks;
> + __entry->reserved_meta_blocks =
> + EXT4_I(inode)->i_reserved_meta_blocks;
> + __entry->allocated_meta_blocks =
> + EXT4_I(inode)->i_allocated_meta_blocks;
> + __entry->quota_claim = quota_claim;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d "
> + "allocated_meta_blocks %d quota_claim %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->used_blocks, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
> + __entry->quota_claim)
> +);
> +
> +TRACE_EVENT(ext4_da_reserve_space,
> + TP_PROTO(struct inode *inode, int md_needed),
> +
> + TP_ARGS(inode, md_needed),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, md_needed )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->i_blocks = inode->i_blocks;
> + __entry->md_needed = md_needed;
> + __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
> + __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->md_needed, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks)
> +);
> +
> +TRACE_EVENT(ext4_da_release_space,
> + TP_PROTO(struct inode *inode, int freed_blocks),
> +
> + TP_ARGS(inode, freed_blocks),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, i_blocks )
> + __field( int, freed_blocks )
> + __field( int, reserved_data_blocks )
> + __field( int, reserved_meta_blocks )
> + __field( int, allocated_meta_blocks )
> + __field( __u16, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->i_blocks = inode->i_blocks;
> + __entry->freed_blocks = freed_blocks;
> + __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
> + __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
> + __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
> + __entry->mode = inode->i_mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
> + "reserved_data_blocks %d reserved_meta_blocks %d "
> + "allocated_meta_blocks %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->mode, __entry->i_blocks,
> + __entry->freed_blocks, __entry->reserved_data_blocks,
> + __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__bitmap_load,
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( __u32, group )
> +
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->group = group;
> + ),
> +
> + TP_printk("dev %d,%d group %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->group)
> +);
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +);
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +);
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +);
> +
> +DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
> +
> + TP_PROTO(struct super_block *sb, unsigned long group),
> +
> + TP_ARGS(sb, group)
> +);
> +
> +TRACE_EVENT(ext4_direct_IO_enter,
> + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
> +
> + TP_ARGS(inode, offset, len, rw),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned long, len )
> + __field( int, rw )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = offset;
> + __entry->len = len;
> + __entry->rw = rw;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len, __entry->rw)
> +);
> +
> +TRACE_EVENT(ext4_direct_IO_exit,
> + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
> + int rw, int ret),
> +
> + TP_ARGS(inode, offset, len, rw, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned long, len )
> + __field( int, rw )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = offset;
> + __entry->len = len;
> + __entry->rw = rw;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->len,
> + __entry->rw, __entry->ret)
> +);
> +
> +TRACE_EVENT(ext4_fallocate_enter,
> + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
> +
> + TP_ARGS(inode, offset, len, mode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( loff_t, len )
> + __field( int, mode )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = offset;
> + __entry->len = len;
> + __entry->mode = mode;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld len %lld mode %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->pos,
> + __entry->len, __entry->mode)
> +);
> +
> +TRACE_EVENT(ext4_fallocate_exit,
> + TP_PROTO(struct inode *inode, loff_t offset,
> + unsigned int max_blocks, int ret),
> +
> + TP_ARGS(inode, offset, max_blocks, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( loff_t, pos )
> + __field( unsigned int, blocks )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pos = offset;
> + __entry->blocks = max_blocks;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->pos, __entry->blocks,
> + __entry->ret)
> +);
> +
> +TRACE_EVENT(ext4_unlink_enter,
> + TP_PROTO(struct inode *parent, struct dentry *dentry),
> +
> + TP_ARGS(parent, dentry),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ino_t, parent )
> + __field( loff_t, size )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = dentry->d_inode->i_sb->s_dev;
> + __entry->ino = dentry->d_inode->i_ino;
> + __entry->parent = parent->i_ino;
> + __entry->size = dentry->d_inode->i_size;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu size %lld parent %lu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->size,
> + (unsigned long) __entry->parent)
> +);
> +
> +TRACE_EVENT(ext4_unlink_exit,
> + TP_PROTO(struct dentry *dentry, int ret),
> +
> + TP_ARGS(dentry, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = dentry->d_inode->i_sb->s_dev;
> + __entry->ino = dentry->d_inode->i_ino;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->ret)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__truncate,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( __u64, blocks )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->blocks = inode->i_blocks;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu blocks %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino, __entry->blocks)
> +);
> +
> +DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +);
> +
> +DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
> +
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode)
> +);
> +
> +/* 'ux' is the uninitialized extent. */
> +TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + struct ext4_extent *ux),
> +
> + TP_ARGS(inode, map, ux),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, m_lblk )
> + __field( unsigned, m_len )
> + __field( ext4_lblk_t, u_lblk )
> + __field( unsigned, u_len )
> + __field( ext4_fsblk_t, u_pblk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->m_lblk = map->m_lblk;
> + __entry->m_len = map->m_len;
> + __entry->u_lblk = le32_to_cpu(ux->ee_block);
> + __entry->u_len = ext4_ext_get_actual_len(ux);
> + __entry->u_pblk = ext4_ext_pblock(ux);
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
> + "u_pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->m_lblk, __entry->m_len,
> + __entry->u_lblk, __entry->u_len, __entry->u_pblk)
> +);
> +
> +/*
> + * 'ux' is the uninitialized extent.
> + * 'ix' is the initialized extent to which blocks are transferred.
> + */
> +TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + struct ext4_extent *ux, struct ext4_extent *ix),
> +
> + TP_ARGS(inode, map, ux, ix),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, m_lblk )
> + __field( unsigned, m_len )
> + __field( ext4_lblk_t, u_lblk )
> + __field( unsigned, u_len )
> + __field( ext4_fsblk_t, u_pblk )
> + __field( ext4_lblk_t, i_lblk )
> + __field( unsigned, i_len )
> + __field( ext4_fsblk_t, i_pblk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->m_lblk = map->m_lblk;
> + __entry->m_len = map->m_len;
> + __entry->u_lblk = le32_to_cpu(ux->ee_block);
> + __entry->u_len = ext4_ext_get_actual_len(ux);
> + __entry->u_pblk = ext4_ext_pblock(ux);
> + __entry->i_lblk = le32_to_cpu(ix->ee_block);
> + __entry->i_len = ext4_ext_get_actual_len(ix);
> + __entry->i_pblk = ext4_ext_pblock(ix);
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
> + "u_lblk %u u_len %u u_pblk %llu "
> + "i_lblk %u i_len %u i_pblk %llu ",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->m_lblk, __entry->m_len,
> + __entry->u_lblk, __entry->u_len, __entry->u_pblk,
> + __entry->i_lblk, __entry->i_len, __entry->i_pblk)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned int len, unsigned int flags),
> +
> + TP_ARGS(inode, lblk, len, flags),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( unsigned int, flags )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->lblk = lblk;
> + __entry->len = len;
> + __entry->flags = flags;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->len, __entry->flags)
> +);
> +
> +DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned len, unsigned flags),
> +
> + TP_ARGS(inode, lblk, len, flags)
> +);
> +
> +DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + unsigned len, unsigned flags),
> +
> + TP_ARGS(inode, lblk, len, flags)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned int len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pblk = pblk;
> + __entry->lblk = lblk;
> + __entry->len = len;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->pblk,
> + __entry->len, __entry->ret)
> +);
> +
> +DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret)
> +);
> +
> +DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
> + ext4_fsblk_t pblk, unsigned len, int ret),
> +
> + TP_ARGS(inode, lblk, pblk, len, ret)
> +);
> +
> +TRACE_EVENT(ext4_ext_load_extent,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
> +
> + TP_ARGS(inode, lblk, pblk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pblk = pblk;
> + __entry->lblk = lblk;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + __entry->lblk, __entry->pblk)
> +);
> +
> +TRACE_EVENT(ext4_load_inode,
> + TP_PROTO(struct inode *inode),
> +
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + ),
> +
> + TP_printk("dev %d,%d ino %ld",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino)
> +);
> +
> +TRACE_EVENT(ext4_journal_start,
> + TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
> +
> + TP_ARGS(sb, nblocks, IP),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field(unsigned long, ip )
> + __field( int, nblocks )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->ip = IP;
> + __entry->nblocks = nblocks;
> + ),
> +
> + TP_printk("dev %d,%d nblocks %d caller %pF",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->nblocks, (void *)__entry->ip)
> +);
> +
> +DECLARE_EVENT_CLASS(ext4__trim,
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len),
> +
> + TP_STRUCT__entry(
> + __field( int, dev_major )
> + __field( int, dev_minor )
> + __field( __u32, group )
> + __field( int, start )
> + __field( int, len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev_major = MAJOR(sb->s_dev);
> + __entry->dev_minor = MINOR(sb->s_dev);
> + __entry->group = group;
> + __entry->start = start;
> + __entry->len = len;
> + ),
> +
> + TP_printk("dev %d,%d group %u, start %d, len %d",
> + __entry->dev_major, __entry->dev_minor,
> + __entry->group, __entry->start, __entry->len)
> +);
> +
> +DEFINE_EVENT(ext4__trim, ext4_trim_extent,
> +
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len)
> +);
> +
> +DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
> +
> + TP_PROTO(struct super_block *sb,
> + ext4_group_t group,
> + ext4_grpblk_t start,
> + ext4_grpblk_t len),
> +
> + TP_ARGS(sb, group, start, len)
> +);
> +
> +TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
> + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
> + unsigned int allocated, ext4_fsblk_t newblock),
> +
> + TP_ARGS(inode, map, allocated, newblock),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( int, flags )
> + __field( ext4_lblk_t, lblk )
> + __field( ext4_fsblk_t, pblk )
> + __field( unsigned int, len )
> + __field( unsigned int, allocated )
> + __field( ext4_fsblk_t, newblk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->flags = map->m_flags;
> + __entry->lblk = map->m_lblk;
> + __entry->pblk = map->m_pblk;
> + __entry->len = map->m_len;
> + __entry->allocated = allocated;
> + __entry->newblk = newblock;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %d"
> + "allocated %d newblock %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
> + __entry->len, __entry->flags,
> + (unsigned int) __entry->allocated,
> + (unsigned long long) __entry->newblk)
> +);
> +
> +TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
> + TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
> +
> + TP_ARGS(sb, map, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( unsigned int, flags )
> + __field( ext4_lblk_t, lblk )
> + __field( ext4_fsblk_t, pblk )
> + __field( unsigned int, len )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = sb->s_dev;
> + __entry->flags = map->m_flags;
> + __entry->lblk = map->m_lblk;
> + __entry->pblk = map->m_pblk;
> + __entry->len = map->m_len;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + __entry->lblk, (unsigned long long) __entry->pblk,
> + __entry->len, __entry->flags, __entry->ret)
> +);
> +
> +TRACE_EVENT(ext4_ext_put_in_cache,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
> + ext4_fsblk_t start),
> +
> + TP_ARGS(inode, lblk, len, start),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + __field( ext4_fsblk_t, start )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->lblk = lblk;
> + __entry->len = len;
> + __entry->start = start;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->len,
> + (unsigned long long) __entry->start)
> +);
> +
> +TRACE_EVENT(ext4_ext_in_cache,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
> +
> + TP_ARGS(inode, lblk, ret),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->lblk = lblk;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u ret %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->ret)
> +
> +);
> +
> +TRACE_EVENT(ext4_find_delalloc_range,
> + TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
> + int reverse, int found, ext4_lblk_t found_blk),
> +
> + TP_ARGS(inode, from, to, reverse, found, found_blk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, from )
> + __field( ext4_lblk_t, to )
> + __field( int, reverse )
> + __field( int, found )
> + __field( ext4_lblk_t, found_blk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->from = from;
> + __entry->to = to;
> + __entry->reverse = reverse;
> + __entry->found = found;
> + __entry->found_blk = found_blk;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
> + "(blk = %u)",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->from, (unsigned) __entry->to,
> + __entry->reverse, __entry->found,
> + (unsigned) __entry->found_blk)
> +);
> +
> +TRACE_EVENT(ext4_get_reserved_cluster_alloc,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
> +
> + TP_ARGS(inode, lblk, len),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned int, len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->lblk = lblk;
> + __entry->len = len;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + __entry->len)
> +);
> +
> +TRACE_EVENT(ext4_ext_show_extent,
> + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
> + unsigned short len),
> +
> + TP_ARGS(inode, lblk, pblk, len),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + __field( ext4_lblk_t, lblk )
> + __field( unsigned short, len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pblk = pblk;
> + __entry->lblk = lblk;
> + __entry->len = len;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->lblk,
> + (unsigned long long) __entry->pblk,
> + (unsigned short) __entry->len)
> +);
> +
> +TRACE_EVENT(ext4_remove_blocks,
> + TP_PROTO(struct inode *inode, struct ext4_extent *ex,
> + ext4_lblk_t from, ext4_fsblk_t to,
> + ext4_fsblk_t partial_cluster),
> +
> + TP_ARGS(inode, ex, from, to, partial_cluster),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, from )
> + __field( ext4_lblk_t, to )
> + __field( ext4_fsblk_t, partial )
> + __field( ext4_fsblk_t, ee_pblk )
> + __field( ext4_lblk_t, ee_lblk )
> + __field( unsigned short, ee_len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->from = from;
> + __entry->to = to;
> + __entry->partial = partial_cluster;
> + __entry->ee_pblk = ext4_ext_pblock(ex);
> + __entry->ee_lblk = cpu_to_le32(ex->ee_block);
> + __entry->ee_len = ext4_ext_get_actual_len(ex);
> + ),
> +
> + TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
> + "from %u to %u partial_cluster %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->ee_lblk,
> + (unsigned long long) __entry->ee_pblk,
> + (unsigned short) __entry->ee_len,
> + (unsigned) __entry->from,
> + (unsigned) __entry->to,
> + (unsigned) __entry->partial)
> +);
> +
> +TRACE_EVENT(ext4_ext_rm_leaf,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start,
> + struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
> +
> + TP_ARGS(inode, start, ex, partial_cluster),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, partial )
> + __field( ext4_lblk_t, start )
> + __field( ext4_lblk_t, ee_lblk )
> + __field( ext4_fsblk_t, ee_pblk )
> + __field( short, ee_len )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->partial = partial_cluster;
> + __entry->start = start;
> + __entry->ee_lblk = le32_to_cpu(ex->ee_block);
> + __entry->ee_pblk = ext4_ext_pblock(ex);
> + __entry->ee_len = ext4_ext_get_actual_len(ex);
> + ),
> +
> + TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
> + "partial_cluster %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + (unsigned) __entry->ee_lblk,
> + (unsigned long long) __entry->ee_pblk,
> + (unsigned short) __entry->ee_len,
> + (unsigned) __entry->partial)
> +);
> +
> +TRACE_EVENT(ext4_ext_rm_idx,
> + TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
> +
> + TP_ARGS(inode, pblk),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_fsblk_t, pblk )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->pblk = pblk;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu index_pblk %llu",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned long long) __entry->pblk)
> +);
> +
> +TRACE_EVENT(ext4_ext_remove_space,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
> +
> + TP_ARGS(inode, start, depth),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, start )
> + __field( int, depth )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->start = start;
> + __entry->depth = depth;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu since %u depth %d",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + __entry->depth)
> +);
> +
> +TRACE_EVENT(ext4_ext_remove_space_done,
> + TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
> + ext4_lblk_t partial, unsigned short eh_entries),
> +
> + TP_ARGS(inode, start, depth, partial, eh_entries),
> +
> + TP_STRUCT__entry(
> + __field( dev_t, dev )
> + __field( ino_t, ino )
> + __field( ext4_lblk_t, start )
> + __field( int, depth )
> + __field( ext4_lblk_t, partial )
> + __field( unsigned short, eh_entries )
> + ),
> +
> + TP_fast_assign(
> + __entry->dev = inode->i_sb->s_dev;
> + __entry->ino = inode->i_ino;
> + __entry->start = start;
> + __entry->depth = depth;
> + __entry->partial = partial;
> + __entry->eh_entries = eh_entries;
> + ),
> +
> + TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
> + "remaining_entries %u",
> + MAJOR(__entry->dev), MINOR(__entry->dev),
> + (unsigned long) __entry->ino,
> + (unsigned) __entry->start,
> + __entry->depth,
> + (unsigned) __entry->partial,
> + (unsigned short) __entry->eh_entries)
> +);
> +
> +#endif /* _TRACE_EXT4_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/printk.h b/instrumentation/events/mainline/printk.h
> new file mode 100644
> index 0000000..94ec79c
> --- /dev/null
> +++ b/instrumentation/events/mainline/printk.h
> @@ -0,0 +1,41 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM printk
> +
> +#if !defined(_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_PRINTK_H
> +
> +#include <linux/tracepoint.h>
> +
> +TRACE_EVENT_CONDITION(console,
> + TP_PROTO(const char *log_buf, unsigned start, unsigned end,
> + unsigned log_buf_len),
> +
> + TP_ARGS(log_buf, start, end, log_buf_len),
> +
> + TP_CONDITION(start != end),
> +
> + TP_STRUCT__entry(
> + __dynamic_array(char, msg, end - start + 1)
> + ),
> +
> + TP_fast_assign(
> + if ((start & (log_buf_len - 1)) > (end & (log_buf_len - 1))) {
> + memcpy(__get_dynamic_array(msg),
> + log_buf + (start & (log_buf_len - 1)),
> + log_buf_len - (start & (log_buf_len - 1)));
> + memcpy((char *)__get_dynamic_array(msg) +
> + log_buf_len - (start & (log_buf_len - 1)),
> + log_buf, end & (log_buf_len - 1));
> + } else
> + memcpy(__get_dynamic_array(msg),
> + log_buf + (start & (log_buf_len - 1)),
> + end - start);
> + ((char *)__get_dynamic_array(msg))[end - start] = 0;
> + ),
> +
> + TP_printk("%s", __get_str(msg))
> +);
> +#endif /* _TRACE_PRINTK_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/random.h b/instrumentation/events/mainline/random.h
> new file mode 100644
> index 0000000..422df19
> --- /dev/null
> +++ b/instrumentation/events/mainline/random.h
> @@ -0,0 +1,134 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM random
> +
> +#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RANDOM_H
> +
> +#include <linux/writeback.h>
> +#include <linux/tracepoint.h>
> +
> +DECLARE_EVENT_CLASS(random__mix_pool_bytes,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP),
> +
> + TP_STRUCT__entry(
> + __field( const char *, pool_name )
> + __field( int, bytes )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + __entry->pool_name = pool_name;
> + __entry->bytes = bytes;
> + __entry->IP = IP;
> + ),
> +
> + TP_printk("%s pool: bytes %d caller %pF",
> + __entry->pool_name, __entry->bytes, (void *)__entry->IP)
> +);
> +
> +DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP)
> +);
> +
> +DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock,
> + TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
> +
> + TP_ARGS(pool_name, bytes, IP)
> +);
> +
> +TRACE_EVENT(credit_entropy_bits,
> + TP_PROTO(const char *pool_name, int bits, int entropy_count,
> + int entropy_total, unsigned long IP),
> +
> + TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP),
> +
> + TP_STRUCT__entry(
> + __field( const char *, pool_name )
> + __field( int, bits )
> + __field( int, entropy_count )
> + __field( int, entropy_total )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + __entry->pool_name = pool_name;
> + __entry->bits = bits;
> + __entry->entropy_count = entropy_count;
> + __entry->entropy_total = entropy_total;
> + __entry->IP = IP;
> + ),
> +
> + TP_printk("%s pool: bits %d entropy_count %d entropy_total %d "
> + "caller %pF", __entry->pool_name, __entry->bits,
> + __entry->entropy_count, __entry->entropy_total,
> + (void *)__entry->IP)
> +);
> +
> +TRACE_EVENT(get_random_bytes,
> + TP_PROTO(int nbytes, unsigned long IP),
> +
> + TP_ARGS(nbytes, IP),
> +
> + TP_STRUCT__entry(
> + __field( int, nbytes )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + __entry->nbytes = nbytes;
> + __entry->IP = IP;
> + ),
> +
> + TP_printk("nbytes %d caller %pF", __entry->nbytes, (void *)__entry->IP)
> +);
> +
> +DECLARE_EVENT_CLASS(random__extract_entropy,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP),
> +
> + TP_STRUCT__entry(
> + __field( const char *, pool_name )
> + __field( int, nbytes )
> + __field( int, entropy_count )
> + __field(unsigned long, IP )
> + ),
> +
> + TP_fast_assign(
> + __entry->pool_name = pool_name;
> + __entry->nbytes = nbytes;
> + __entry->entropy_count = entropy_count;
> + __entry->IP = IP;
> + ),
> +
> + TP_printk("%s pool: nbytes %d entropy_count %d caller %pF",
> + __entry->pool_name, __entry->nbytes, __entry->entropy_count,
> + (void *)__entry->IP)
> +);
> +
> +
> +DEFINE_EVENT(random__extract_entropy, extract_entropy,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP)
> +);
> +
> +DEFINE_EVENT(random__extract_entropy, extract_entropy_user,
> + TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
> + unsigned long IP),
> +
> + TP_ARGS(pool_name, nbytes, entropy_count, IP)
> +);
> +
> +
> +
> +#endif /* _TRACE_RANDOM_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/rcu.h b/instrumentation/events/mainline/rcu.h
> new file mode 100644
> index 0000000..5bde94d
> --- /dev/null
> +++ b/instrumentation/events/mainline/rcu.h
> @@ -0,0 +1,618 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM rcu
> +
> +#if !defined(_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RCU_H
> +
> +#include <linux/tracepoint.h>
> +
> +/*
> + * Tracepoint for start/end markers used for utilization calculations.
> + * By convention, the string is of the following forms:
> + *
> + * "Start <activity>" -- Mark the start of the specified activity,
> + * such as "context switch". Nesting is permitted.
> + * "End <activity>" -- Mark the end of the specified activity.
> + *
> + * An "@" character within "<activity>" is a comment character: Data
> + * reduction scripts will ignore the "@" and the remainder of the line.
> + */
> +TRACE_EVENT(rcu_utilization,
> +
> + TP_PROTO(char *s),
> +
> + TP_ARGS(s),
> +
> + TP_STRUCT__entry(
> + __field(char *, s)
> + ),
> +
> + TP_fast_assign(
> + __entry->s = s;
> + ),
> +
> + TP_printk("%s", __entry->s)
> +);
> +
> +#ifdef CONFIG_RCU_TRACE
> +
> +#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
> +
> +/*
> + * Tracepoint for grace-period events: starting and ending a grace
> + * period ("start" and "end", respectively), a CPU noting the start
> + * of a new grace period or the end of an old grace period ("cpustart"
> + * and "cpuend", respectively), a CPU passing through a quiescent
> + * state ("cpuqs"), a CPU coming online or going offline ("cpuonl"
> + * and "cpuofl", respectively), and a CPU being kicked for being too
> + * long in dyntick-idle mode ("kick").
> + */
> +TRACE_EVENT(rcu_grace_period,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, char *gpevent),
> +
> + TP_ARGS(rcuname, gpnum, gpevent),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(char *, gpevent)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->gpevent = gpevent;
> + ),
> +
> + TP_printk("%s %lu %s",
> + __entry->rcuname, __entry->gpnum, __entry->gpevent)
> +);
> +
> +/*
> + * Tracepoint for grace-period-initialization events. These are
> + * distinguished by the type of RCU, the new grace-period number, the
> + * rcu_node structure level, the starting and ending CPU covered by the
> + * rcu_node structure, and the mask of CPUs that will be waited for.
> + * All but the type of RCU are extracted from the rcu_node structure.
> + */
> +TRACE_EVENT(rcu_grace_period_init,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, u8 level,
> + int grplo, int grphi, unsigned long qsmask),
> +
> + TP_ARGS(rcuname, gpnum, level, grplo, grphi, qsmask),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(u8, level)
> + __field(int, grplo)
> + __field(int, grphi)
> + __field(unsigned long, qsmask)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->level = level;
> + __entry->grplo = grplo;
> + __entry->grphi = grphi;
> + __entry->qsmask = qsmask;
> + ),
> +
> + TP_printk("%s %lu %u %d %d %lx",
> + __entry->rcuname, __entry->gpnum, __entry->level,
> + __entry->grplo, __entry->grphi, __entry->qsmask)
> +);
> +
> +/*
> + * Tracepoint for tasks blocking within preemptible-RCU read-side
> + * critical sections. Track the type of RCU (which one day might
> + * include SRCU), the grace-period number that the task is blocking
> + * (the current or the next), and the task's PID.
> + */
> +TRACE_EVENT(rcu_preempt_task,
> +
> + TP_PROTO(char *rcuname, int pid, unsigned long gpnum),
> +
> + TP_ARGS(rcuname, pid, gpnum),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, pid)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->pid = pid;
> + ),
> +
> + TP_printk("%s %lu %d",
> + __entry->rcuname, __entry->gpnum, __entry->pid)
> +);
> +
> +/*
> + * Tracepoint for tasks that blocked within a given preemptible-RCU
> + * read-side critical section exiting that critical section. Track the
> + * type of RCU (which one day might include SRCU) and the task's PID.
> + */
> +TRACE_EVENT(rcu_unlock_preempted_task,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, int pid),
> +
> + TP_ARGS(rcuname, gpnum, pid),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, pid)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->pid = pid;
> + ),
> +
> + TP_printk("%s %lu %d", __entry->rcuname, __entry->gpnum, __entry->pid)
> +);
> +
> +/*
> + * Tracepoint for quiescent-state-reporting events. These are
> + * distinguished by the type of RCU, the grace-period number, the
> + * mask of quiescent lower-level entities, the rcu_node structure level,
> + * the starting and ending CPU covered by the rcu_node structure, and
> + * whether there are any blocked tasks blocking the current grace period.
> + * All but the type of RCU are extracted from the rcu_node structure.
> + */
> +TRACE_EVENT(rcu_quiescent_state_report,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum,
> + unsigned long mask, unsigned long qsmask,
> + u8 level, int grplo, int grphi, int gp_tasks),
> +
> + TP_ARGS(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(unsigned long, mask)
> + __field(unsigned long, qsmask)
> + __field(u8, level)
> + __field(int, grplo)
> + __field(int, grphi)
> + __field(u8, gp_tasks)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->mask = mask;
> + __entry->qsmask = qsmask;
> + __entry->level = level;
> + __entry->grplo = grplo;
> + __entry->grphi = grphi;
> + __entry->gp_tasks = gp_tasks;
> + ),
> +
> + TP_printk("%s %lu %lx>%lx %u %d %d %u",
> + __entry->rcuname, __entry->gpnum,
> + __entry->mask, __entry->qsmask, __entry->level,
> + __entry->grplo, __entry->grphi, __entry->gp_tasks)
> +);
> +
> +/*
> + * Tracepoint for quiescent states detected by force_quiescent_state().
> + * These trace events include the type of RCU, the grace-period number
> + * that was blocked by the CPU, the CPU itself, and the type of quiescent
> + * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline,
> + * or "kick" when kicking a CPU that has been in dyntick-idle mode for
> + * too long.
> + */
> +TRACE_EVENT(rcu_fqs,
> +
> + TP_PROTO(char *rcuname, unsigned long gpnum, int cpu, char *qsevent),
> +
> + TP_ARGS(rcuname, gpnum, cpu, qsevent),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(unsigned long, gpnum)
> + __field(int, cpu)
> + __field(char *, qsevent)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->gpnum = gpnum;
> + __entry->cpu = cpu;
> + __entry->qsevent = qsevent;
> + ),
> +
> + TP_printk("%s %lu %d %s",
> + __entry->rcuname, __entry->gpnum,
> + __entry->cpu, __entry->qsevent)
> +);
> +
> +#endif /* #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU) */
> +
> +/*
> + * Tracepoint for dyntick-idle entry/exit events. These take a string
> + * as argument: "Start" for entering dyntick-idle mode, "End" for
> + * leaving it, "--=" for events moving towards idle, and "++=" for events
> + * moving away from idle. "Error on entry: not idle task" and "Error on
> + * exit: not idle task" indicate that a non-idle task is erroneously
> + * toying with the idle loop.
> + *
> + * These events also take a pair of numbers, which indicate the nesting
> + * depth before and after the event of interest. Note that task-related
> + * events use the upper bits of each number, while interrupt-related
> + * events use the lower bits.
> + */
> +TRACE_EVENT(rcu_dyntick,
> +
> + TP_PROTO(char *polarity, long long oldnesting, long long newnesting),
> +
> + TP_ARGS(polarity, oldnesting, newnesting),
> +
> + TP_STRUCT__entry(
> + __field(char *, polarity)
> + __field(long long, oldnesting)
> + __field(long long, newnesting)
> + ),
> +
> + TP_fast_assign(
> + __entry->polarity = polarity;
> + __entry->oldnesting = oldnesting;
> + __entry->newnesting = newnesting;
> + ),
> +
> + TP_printk("%s %llx %llx", __entry->polarity,
> + __entry->oldnesting, __entry->newnesting)
> +);
> +
> +/*
> + * Tracepoint for RCU preparation for idle, the goal being to get RCU
> + * processing done so that the current CPU can shut off its scheduling
> + * clock and enter dyntick-idle mode. One way to accomplish this is
> + * to drain all RCU callbacks from this CPU, and the other is to have
> + * done everything RCU requires for the current grace period. In this
> + * latter case, the CPU will be awakened at the end of the current grace
> + * period in order to process the remainder of its callbacks.
> + *
> + * These tracepoints take a string as argument:
> + *
> + * "No callbacks": Nothing to do, no callbacks on this CPU.
> + * "In holdoff": Nothing to do, holding off after unsuccessful attempt.
> + * "Begin holdoff": Attempt failed, don't retry until next jiffy.
> + * "Dyntick with callbacks": Entering dyntick-idle despite callbacks.
> + * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks.
> + * "More callbacks": Still more callbacks, try again to clear them out.
> + * "Callbacks drained": All callbacks processed, off to dyntick idle!
> + * "Timer": Timer fired to cause CPU to continue processing callbacks.
> + * "Demigrate": Timer fired on wrong CPU, woke up correct CPU.
> + * "Cleanup after idle": Idle exited, timer canceled.
> + */
> +TRACE_EVENT(rcu_prep_idle,
> +
> + TP_PROTO(char *reason),
> +
> + TP_ARGS(reason),
> +
> + TP_STRUCT__entry(
> + __field(char *, reason)
> + ),
> +
> + TP_fast_assign(
> + __entry->reason = reason;
> + ),
> +
> + TP_printk("%s", __entry->reason)
> +);
> +
> +/*
> + * Tracepoint for the registration of a single RCU callback function.
> + * The first argument is the type of RCU, the second argument is
> + * a pointer to the RCU callback itself, the third element is the
> + * number of lazy callbacks queued, and the fourth element is the
> + * total number of callbacks queued.
> + */
> +TRACE_EVENT(rcu_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen_lazy,
> + long qlen),
> +
> + TP_ARGS(rcuname, rhp, qlen_lazy, qlen),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(void *, rhp)
> + __field(void *, func)
> + __field(long, qlen_lazy)
> + __field(long, qlen)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->rhp = rhp;
> + __entry->func = rhp->func;
> + __entry->qlen_lazy = qlen_lazy;
> + __entry->qlen = qlen;
> + ),
> +
> + TP_printk("%s rhp=%p func=%pf %ld/%ld",
> + __entry->rcuname, __entry->rhp, __entry->func,
> + __entry->qlen_lazy, __entry->qlen)
> +);
> +
> +/*
> + * Tracepoint for the registration of a single RCU callback of the special
> + * kfree() form. The first argument is the RCU type, the second argument
> + * is a pointer to the RCU callback, the third argument is the offset
> + * of the callback within the enclosing RCU-protected data structure,
> + * the fourth argument is the number of lazy callbacks queued, and the
> + * fifth argument is the total number of callbacks queued.
> + */
> +TRACE_EVENT(rcu_kfree_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset,
> + long qlen_lazy, long qlen),
> +
> + TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(void *, rhp)
> + __field(unsigned long, offset)
> + __field(long, qlen_lazy)
> + __field(long, qlen)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->rhp = rhp;
> + __entry->offset = offset;
> + __entry->qlen_lazy = qlen_lazy;
> + __entry->qlen = qlen;
> + ),
> +
> + TP_printk("%s rhp=%p func=%ld %ld/%ld",
> + __entry->rcuname, __entry->rhp, __entry->offset,
> + __entry->qlen_lazy, __entry->qlen)
> +);
> +
> +/*
> + * Tracepoint for marking the beginning rcu_do_batch, performed to start
> + * RCU callback invocation. The first argument is the RCU flavor,
> + * the second is the number of lazy callbacks queued, the third is
> + * the total number of callbacks queued, and the fourth argument is
> + * the current RCU-callback batch limit.
> + */
> +TRACE_EVENT(rcu_batch_start,
> +
> + TP_PROTO(char *rcuname, long qlen_lazy, long qlen, int blimit),
> +
> + TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(long, qlen_lazy)
> + __field(long, qlen)
> + __field(int, blimit)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->qlen_lazy = qlen_lazy;
> + __entry->qlen = qlen;
> + __entry->blimit = blimit;
> + ),
> +
> + TP_printk("%s CBs=%ld/%ld bl=%d",
> + __entry->rcuname, __entry->qlen_lazy, __entry->qlen,
> + __entry->blimit)
> +);
> +
> +/*
> + * Tracepoint for the invocation of a single RCU callback function.
> + * The first argument is the type of RCU, and the second argument is
> + * a pointer to the RCU callback itself.
> + */
> +TRACE_EVENT(rcu_invoke_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp),
> +
> + TP_ARGS(rcuname, rhp),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(void *, rhp)
> + __field(void *, func)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->rhp = rhp;
> + __entry->func = rhp->func;
> + ),
> +
> + TP_printk("%s rhp=%p func=%pf",
> + __entry->rcuname, __entry->rhp, __entry->func)
> +);
> +
> +/*
> + * Tracepoint for the invocation of a single RCU callback of the special
> + * kfree() form. The first argument is the RCU flavor, the second
> + * argument is a pointer to the RCU callback, and the third argument
> + * is the offset of the callback within the enclosing RCU-protected
> + * data structure.
> + */
> +TRACE_EVENT(rcu_invoke_kfree_callback,
> +
> + TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset),
> +
> + TP_ARGS(rcuname, rhp, offset),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(void *, rhp)
> + __field(unsigned long, offset)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->rhp = rhp;
> + __entry->offset = offset;
> + ),
> +
> + TP_printk("%s rhp=%p func=%ld",
> + __entry->rcuname, __entry->rhp, __entry->offset)
> +);
> +
> +/*
> + * Tracepoint for exiting rcu_do_batch after RCU callbacks have been
> + * invoked. The first argument is the name of the RCU flavor,
> + * the second argument is number of callbacks actually invoked,
> + * the third argument (cb) is whether or not any of the callbacks that
> + * were ready to invoke at the beginning of this batch are still
> + * queued, the fourth argument (nr) is the return value of need_resched(),
> + * the fifth argument (iit) is 1 if the current task is the idle task,
> + * and the sixth argument (risk) is the return value from
> + * rcu_is_callbacks_kthread().
> + */
> +TRACE_EVENT(rcu_batch_end,
> +
> + TP_PROTO(char *rcuname, int callbacks_invoked,
> + bool cb, bool nr, bool iit, bool risk),
> +
> + TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(int, callbacks_invoked)
> + __field(bool, cb)
> + __field(bool, nr)
> + __field(bool, iit)
> + __field(bool, risk)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->callbacks_invoked = callbacks_invoked;
> + __entry->cb = cb;
> + __entry->nr = nr;
> + __entry->iit = iit;
> + __entry->risk = risk;
> + ),
> +
> + TP_printk("%s CBs-invoked=%d idle=%c%c%c%c",
> + __entry->rcuname, __entry->callbacks_invoked,
> + __entry->cb ? 'C' : '.',
> + __entry->nr ? 'S' : '.',
> + __entry->iit ? 'I' : '.',
> + __entry->risk ? 'R' : '.')
> +);
> +
> +/*
> + * Tracepoint for rcutorture readers. The first argument is the name
> + * of the RCU flavor from rcutorture's viewpoint and the second argument
> + * is the callback address.
> + */
> +TRACE_EVENT(rcu_torture_read,
> +
> + TP_PROTO(char *rcutorturename, struct rcu_head *rhp),
> +
> + TP_ARGS(rcutorturename, rhp),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcutorturename)
> + __field(struct rcu_head *, rhp)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcutorturename = rcutorturename;
> + __entry->rhp = rhp;
> + ),
> +
> + TP_printk("%s torture read %p",
> + __entry->rcutorturename, __entry->rhp)
> +);
> +
> +/*
> + * Tracepoint for _rcu_barrier() execution. The string "s" describes
> + * the _rcu_barrier phase:
> + * "Begin": rcu_barrier_callback() started.
> + * "Check": rcu_barrier_callback() checking for piggybacking.
> + * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit.
> + * "Inc1": rcu_barrier_callback() piggyback check counter incremented.
> + * "Offline": rcu_barrier_callback() found offline CPU
> + * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks.
> + * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks.
> + * "IRQ": An rcu_barrier_callback() callback posted on remote CPU.
> + * "CB": An rcu_barrier_callback() invoked a callback, not the last.
> + * "LastCB": An rcu_barrier_callback() invoked the last callback.
> + * "Inc2": rcu_barrier_callback() piggyback check counter incremented.
> + * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument
> + * is the count of remaining callbacks, and "done" is the piggybacking count.
> + */
> +TRACE_EVENT(rcu_barrier,
> +
> + TP_PROTO(char *rcuname, char *s, int cpu, int cnt, unsigned long done),
> +
> + TP_ARGS(rcuname, s, cpu, cnt, done),
> +
> + TP_STRUCT__entry(
> + __field(char *, rcuname)
> + __field(char *, s)
> + __field(int, cpu)
> + __field(int, cnt)
> + __field(unsigned long, done)
> + ),
> +
> + TP_fast_assign(
> + __entry->rcuname = rcuname;
> + __entry->s = s;
> + __entry->cpu = cpu;
> + __entry->cnt = cnt;
> + __entry->done = done;
> + ),
> +
> + TP_printk("%s %s cpu %d remaining %d # %lu",
> + __entry->rcuname, __entry->s, __entry->cpu, __entry->cnt,
> + __entry->done)
> +);
> +
> +#else /* #ifdef CONFIG_RCU_TRACE */
> +
> +#define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0)
> +#define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \
> + qsmask) do { } while (0)
> +#define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0)
> +#define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0)
> +#define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \
> + grplo, grphi, gp_tasks) do { } \
> + while (0)
> +#define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0)
> +#define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0)
> +#define trace_rcu_prep_idle(reason) do { } while (0)
> +#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0)
> +#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \
> + do { } while (0)
> +#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \
> + do { } while (0)
> +#define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0)
> +#define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
> +#define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
> + do { } while (0)
> +#define trace_rcu_torture_read(rcutorturename, rhp) do { } while (0)
> +#define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0)
> +
> +#endif /* #else #ifdef CONFIG_RCU_TRACE */
> +
> +#endif /* _TRACE_RCU_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/regmap.h b/instrumentation/events/mainline/regmap.h
> new file mode 100644
> index 0000000..41a7dbd
> --- /dev/null
> +++ b/instrumentation/events/mainline/regmap.h
> @@ -0,0 +1,181 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM regmap
> +
> +#if !defined(_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_REGMAP_H
> +
> +#include <linux/ktime.h>
> +#include <linux/tracepoint.h>
> +
> +struct device;
> +struct regmap;
> +
> +/*
> + * Log register events
> + */
> +DECLARE_EVENT_CLASS(regmap_reg,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( unsigned int, reg )
> + __field( unsigned int, val )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __entry->reg = reg;
> + __entry->val = val;
> + ),
> +
> + TP_printk("%s reg=%x val=%x", __get_str(name),
> + (unsigned int)__entry->reg,
> + (unsigned int)__entry->val)
> +);
> +
> +DEFINE_EVENT(regmap_reg, regmap_reg_write,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +);
> +
> +DEFINE_EVENT(regmap_reg, regmap_reg_read,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +);
> +
> +DEFINE_EVENT(regmap_reg, regmap_reg_read_cache,
> +
> + TP_PROTO(struct device *dev, unsigned int reg,
> + unsigned int val),
> +
> + TP_ARGS(dev, reg, val)
> +
> +);
> +
> +DECLARE_EVENT_CLASS(regmap_block,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( unsigned int, reg )
> + __field( int, count )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __entry->reg = reg;
> + __entry->count = count;
> + ),
> +
> + TP_printk("%s reg=%x count=%d", __get_str(name),
> + (unsigned int)__entry->reg,
> + (int)__entry->count)
> +);
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_read_start,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +);
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_read_done,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +);
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_write_start,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +);
> +
> +DEFINE_EVENT(regmap_block, regmap_hw_write_done,
> +
> + TP_PROTO(struct device *dev, unsigned int reg, int count),
> +
> + TP_ARGS(dev, reg, count)
> +);
> +
> +TRACE_EVENT(regcache_sync,
> +
> + TP_PROTO(struct device *dev, const char *type,
> + const char *status),
> +
> + TP_ARGS(dev, type, status),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __string( status, status )
> + __string( type, type )
> + __field( int, type )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __assign_str(status, status);
> + __assign_str(type, type);
> + ),
> +
> + TP_printk("%s type=%s status=%s", __get_str(name),
> + __get_str(type), __get_str(status))
> +);
> +
> +DECLARE_EVENT_CLASS(regmap_bool,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( int, flag )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __entry->flag = flag;
> + ),
> +
> + TP_printk("%s flag=%d", __get_str(name),
> + (int)__entry->flag)
> +);
> +
> +DEFINE_EVENT(regmap_bool, regmap_cache_only,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag)
> +
> +);
> +
> +DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
> +
> + TP_PROTO(struct device *dev, bool flag),
> +
> + TP_ARGS(dev, flag)
> +
> +);
> +
> +#endif /* _TRACE_REGMAP_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/rpm.h b/instrumentation/events/mainline/rpm.h
> new file mode 100644
> index 0000000..33f85b6
> --- /dev/null
> +++ b/instrumentation/events/mainline/rpm.h
> @@ -0,0 +1,100 @@
> +
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM rpm
> +
> +#if !defined(_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_RUNTIME_POWER_H
> +
> +#include <linux/ktime.h>
> +#include <linux/tracepoint.h>
> +
> +struct device;
> +
> +/*
> + * The rpm_internal events are used for tracing some important
> + * runtime pm internal functions.
> + */
> +DECLARE_EVENT_CLASS(rpm_internal,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev) )
> + __field( int, flags )
> + __field( int , usage_count )
> + __field( int , disable_depth )
> + __field( int , runtime_auto )
> + __field( int , request_pending )
> + __field( int , irq_safe )
> + __field( int , child_count )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __entry->flags = flags;
> + __entry->usage_count = atomic_read(
> + &dev->power.usage_count);
> + __entry->disable_depth = dev->power.disable_depth;
> + __entry->runtime_auto = dev->power.runtime_auto;
> + __entry->request_pending = dev->power.request_pending;
> + __entry->irq_safe = dev->power.irq_safe;
> + __entry->child_count = atomic_read(
> + &dev->power.child_count);
> + ),
> +
> + TP_printk("%s flags-%x cnt-%-2d dep-%-2d auto-%-1d p-%-1d"
> + " irq-%-1d child-%d",
> + __get_str(name), __entry->flags,
> + __entry->usage_count,
> + __entry->disable_depth,
> + __entry->runtime_auto,
> + __entry->request_pending,
> + __entry->irq_safe,
> + __entry->child_count
> + )
> +);
> +DEFINE_EVENT(rpm_internal, rpm_suspend,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +);
> +DEFINE_EVENT(rpm_internal, rpm_resume,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +);
> +DEFINE_EVENT(rpm_internal, rpm_idle,
> +
> + TP_PROTO(struct device *dev, int flags),
> +
> + TP_ARGS(dev, flags)
> +);
> +
> +TRACE_EVENT(rpm_return_int,
> + TP_PROTO(struct device *dev, unsigned long ip, int ret),
> + TP_ARGS(dev, ip, ret),
> +
> + TP_STRUCT__entry(
> + __string( name, dev_name(dev))
> + __field( unsigned long, ip )
> + __field( int, ret )
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, dev_name(dev));
> + __entry->ip = ip;
> + __entry->ret = ret;
> + ),
> +
> + TP_printk("%pS:%s ret=%d", (void *)__entry->ip, __get_str(name),
> + __entry->ret)
> +);
> +
> +#endif /* _TRACE_RUNTIME_POWER_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/sunrpc.h b/instrumentation/events/mainline/sunrpc.h
> new file mode 100644
> index 0000000..43be87d
> --- /dev/null
> +++ b/instrumentation/events/mainline/sunrpc.h
> @@ -0,0 +1,177 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM sunrpc
> +
> +#if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_SUNRPC_H
> +
> +#include <linux/sunrpc/sched.h>
> +#include <linux/sunrpc/clnt.h>
> +#include <linux/tracepoint.h>
> +
> +DECLARE_EVENT_CLASS(rpc_task_status,
> +
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_task *, task)
> + __field(const struct rpc_clnt *, clnt)
> + __field(int, status)
> + ),
> +
> + TP_fast_assign(
> + __entry->task = task;
> + __entry->clnt = task->tk_client;
> + __entry->status = task->tk_status;
> + ),
> +
> + TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
> +);
> +
> +DEFINE_EVENT(rpc_task_status, rpc_call_status,
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task)
> +);
> +
> +DEFINE_EVENT(rpc_task_status, rpc_bind_status,
> + TP_PROTO(struct rpc_task *task),
> +
> + TP_ARGS(task)
> +);
> +
> +TRACE_EVENT(rpc_connect_status,
> + TP_PROTO(struct rpc_task *task, int status),
> +
> + TP_ARGS(task, status),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_task *, task)
> + __field(const struct rpc_clnt *, clnt)
> + __field(int, status)
> + ),
> +
> + TP_fast_assign(
> + __entry->task = task;
> + __entry->clnt = task->tk_client;
> + __entry->status = status;
> + ),
> +
> + TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
> +);
> +
> +DECLARE_EVENT_CLASS(rpc_task_running,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_clnt *, clnt)
> + __field(const struct rpc_task *, task)
> + __field(const void *, action)
> + __field(unsigned long, runstate)
> + __field(int, status)
> + __field(unsigned short, flags)
> + ),
> +
> + TP_fast_assign(
> + __entry->clnt = clnt;
> + __entry->task = task;
> + __entry->action = action;
> + __entry->runstate = task->tk_runstate;
> + __entry->status = task->tk_status;
> + __entry->flags = task->tk_flags;
> + ),
> +
> + TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d action=%pf",
> + __entry->task,
> + __entry->clnt,
> + __entry->flags,
> + __entry->runstate,
> + __entry->status,
> + __entry->action
> + )
> +);
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_begin,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +);
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +);
> +
> +DEFINE_EVENT(rpc_task_running, rpc_task_complete,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
> +
> + TP_ARGS(clnt, task, action)
> +
> +);
> +
> +DECLARE_EVENT_CLASS(rpc_task_queued,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q),
> +
> + TP_STRUCT__entry(
> + __field(const struct rpc_clnt *, clnt)
> + __field(const struct rpc_task *, task)
> + __field(unsigned long, timeout)
> + __field(unsigned long, runstate)
> + __field(int, status)
> + __field(unsigned short, flags)
> + __string(q_name, rpc_qname(q))
> + ),
> +
> + TP_fast_assign(
> + __entry->clnt = clnt;
> + __entry->task = task;
> + __entry->timeout = task->tk_timeout;
> + __entry->runstate = task->tk_runstate;
> + __entry->status = task->tk_status;
> + __entry->flags = task->tk_flags;
> + __assign_str(q_name, rpc_qname(q));
> + ),
> +
> + TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
> + __entry->task,
> + __entry->clnt,
> + __entry->flags,
> + __entry->runstate,
> + __entry->status,
> + __entry->timeout,
> + __get_str(q_name)
> + )
> +);
> +
> +DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q)
> +
> +);
> +
> +DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
> +
> + TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
> +
> + TP_ARGS(clnt, task, q)
> +
> +);
> +
> +#endif /* _TRACE_SUNRPC_H */
> +
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/workqueue.h b/instrumentation/events/mainline/workqueue.h
> new file mode 100644
> index 0000000..f28d1b6
> --- /dev/null
> +++ b/instrumentation/events/mainline/workqueue.h
> @@ -0,0 +1,121 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM workqueue
> +
> +#if !defined(_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_WORKQUEUE_H
> +
> +#include <linux/tracepoint.h>
> +#include <linux/workqueue.h>
> +
> +DECLARE_EVENT_CLASS(workqueue_work,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + ),
> +
> + TP_fast_assign(
> + __entry->work = work;
> + ),
> +
> + TP_printk("work struct %p", __entry->work)
> +);
> +
> +/**
> + * workqueue_queue_work - called when a work gets queued
> + * @req_cpu: the requested cpu
> + * @cwq: pointer to struct cpu_workqueue_struct
> + * @work: pointer to struct work_struct
> + *
> + * This event occurs when a work is queued immediately or once a
> + * delayed work is actually queued on a workqueue (ie: once the delay
> + * has been reached).
> + */
> +TRACE_EVENT(workqueue_queue_work,
> +
> + TP_PROTO(unsigned int req_cpu, struct cpu_workqueue_struct *cwq,
> + struct work_struct *work),
> +
> + TP_ARGS(req_cpu, cwq, work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + __field( void *, function)
> + __field( void *, workqueue)
> + __field( unsigned int, req_cpu )
> + __field( unsigned int, cpu )
> + ),
> +
> + TP_fast_assign(
> + __entry->work = work;
> + __entry->function = work->func;
> + __entry->workqueue = cwq->wq;
> + __entry->req_cpu = req_cpu;
> + __entry->cpu = cwq->pool->gcwq->cpu;
> + ),
> +
> + TP_printk("work struct=%p function=%pf workqueue=%p req_cpu=%u cpu=%u",
> + __entry->work, __entry->function, __entry->workqueue,
> + __entry->req_cpu, __entry->cpu)
> +);
> +
> +/**
> + * workqueue_activate_work - called when a work gets activated
> + * @work: pointer to struct work_struct
> + *
> + * This event occurs when a queued work is put on the active queue,
> + * which happens immediately after queueing unless @max_active limit
> + * is reached.
> + */
> +DEFINE_EVENT(workqueue_work, workqueue_activate_work,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work)
> +);
> +
> +/**
> + * workqueue_execute_start - called immediately before the workqueue callback
> + * @work: pointer to struct work_struct
> + *
> + * Allows to track workqueue execution.
> + */
> +TRACE_EVENT(workqueue_execute_start,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work),
> +
> + TP_STRUCT__entry(
> + __field( void *, work )
> + __field( void *, function)
> + ),
> +
> + TP_fast_assign(
> + __entry->work = work;
> + __entry->function = work->func;
> + ),
> +
> + TP_printk("work struct %p: function %pf", __entry->work, __entry->function)
> +);
> +
> +/**
> + * workqueue_execute_end - called immediately after the workqueue callback
> + * @work: pointer to struct work_struct
> + *
> + * Allows to track workqueue execution.
> + */
> +DEFINE_EVENT(workqueue_work, workqueue_execute_end,
> +
> + TP_PROTO(struct work_struct *work),
> +
> + TP_ARGS(work)
> +);
> +
> +#endif /* _TRACE_WORKQUEUE_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/instrumentation/events/mainline/writeback.h b/instrumentation/events/mainline/writeback.h
> new file mode 100644
> index 0000000..b453d92
> --- /dev/null
> +++ b/instrumentation/events/mainline/writeback.h
> @@ -0,0 +1,492 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM writeback
> +
> +#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_WRITEBACK_H
> +
> +#include <linux/backing-dev.h>
> +#include <linux/writeback.h>
> +
> +#define show_inode_state(state) \
> + __print_flags(state, "|", \
> + {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
> + {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
> + {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
> + {I_NEW, "I_NEW"}, \
> + {I_WILL_FREE, "I_WILL_FREE"}, \
> + {I_FREEING, "I_FREEING"}, \
> + {I_CLEAR, "I_CLEAR"}, \
> + {I_SYNC, "I_SYNC"}, \
> + {I_REFERENCED, "I_REFERENCED"} \
> + )
> +
> +#define WB_WORK_REASON \
> + {WB_REASON_BACKGROUND, "background"}, \
> + {WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages"}, \
> + {WB_REASON_SYNC, "sync"}, \
> + {WB_REASON_PERIODIC, "periodic"}, \
> + {WB_REASON_LAPTOP_TIMER, "laptop_timer"}, \
> + {WB_REASON_FREE_MORE_MEM, "free_more_memory"}, \
> + {WB_REASON_FS_FREE_SPACE, "fs_free_space"}, \
> + {WB_REASON_FORKER_THREAD, "forker_thread"}
> +
> +struct wb_writeback_work;
> +
> +DECLARE_EVENT_CLASS(writeback_work_class,
> + TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
> + TP_ARGS(bdi, work),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(long, nr_pages)
> + __field(dev_t, sb_dev)
> + __field(int, sync_mode)
> + __field(int, for_kupdate)
> + __field(int, range_cyclic)
> + __field(int, for_background)
> + __field(int, reason)
> + ),
> + TP_fast_assign(
> + struct device *dev = bdi->dev;
> + if (!dev)
> + dev = default_backing_dev_info.dev;
> + strncpy(__entry->name, dev_name(dev), 32);
> + __entry->nr_pages = work->nr_pages;
> + __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
> + __entry->sync_mode = work->sync_mode;
> + __entry->for_kupdate = work->for_kupdate;
> + __entry->range_cyclic = work->range_cyclic;
> + __entry->for_background = work->for_background;
> + __entry->reason = work->reason;
> + ),
> + TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
> + "kupdate=%d range_cyclic=%d background=%d reason=%s",
> + __entry->name,
> + MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
> + __entry->nr_pages,
> + __entry->sync_mode,
> + __entry->for_kupdate,
> + __entry->range_cyclic,
> + __entry->for_background,
> + __print_symbolic(__entry->reason, WB_WORK_REASON)
> + )
> +);
> +#define DEFINE_WRITEBACK_WORK_EVENT(name) \
> +DEFINE_EVENT(writeback_work_class, name, \
> + TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
> + TP_ARGS(bdi, work))
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
> +DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
> +
> +TRACE_EVENT(writeback_pages_written,
> + TP_PROTO(long pages_written),
> + TP_ARGS(pages_written),
> + TP_STRUCT__entry(
> + __field(long, pages)
> + ),
> + TP_fast_assign(
> + __entry->pages = pages_written;
> + ),
> + TP_printk("%ld", __entry->pages)
> +);
> +
> +DECLARE_EVENT_CLASS(writeback_class,
> + TP_PROTO(struct backing_dev_info *bdi),
> + TP_ARGS(bdi),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + ),
> + TP_fast_assign(
> + strncpy(__entry->name, dev_name(bdi->dev), 32);
> + ),
> + TP_printk("bdi %s",
> + __entry->name
> + )
> +);
> +#define DEFINE_WRITEBACK_EVENT(name) \
> +DEFINE_EVENT(writeback_class, name, \
> + TP_PROTO(struct backing_dev_info *bdi), \
> + TP_ARGS(bdi))
> +
> +DEFINE_WRITEBACK_EVENT(writeback_nowork);
> +DEFINE_WRITEBACK_EVENT(writeback_wake_background);
> +DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
> +DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
> +DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
> +DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
> +DEFINE_WRITEBACK_EVENT(writeback_thread_start);
> +DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
> +
> +DECLARE_EVENT_CLASS(wbc_class,
> + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
> + TP_ARGS(wbc, bdi),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(long, nr_to_write)
> + __field(long, pages_skipped)
> + __field(int, sync_mode)
> + __field(int, for_kupdate)
> + __field(int, for_background)
> + __field(int, for_reclaim)
> + __field(int, range_cyclic)
> + __field(long, range_start)
> + __field(long, range_end)
> + ),
> +
> + TP_fast_assign(
> + strncpy(__entry->name, dev_name(bdi->dev), 32);
> + __entry->nr_to_write = wbc->nr_to_write;
> + __entry->pages_skipped = wbc->pages_skipped;
> + __entry->sync_mode = wbc->sync_mode;
> + __entry->for_kupdate = wbc->for_kupdate;
> + __entry->for_background = wbc->for_background;
> + __entry->for_reclaim = wbc->for_reclaim;
> + __entry->range_cyclic = wbc->range_cyclic;
> + __entry->range_start = (long)wbc->range_start;
> + __entry->range_end = (long)wbc->range_end;
> + ),
> +
> + TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
> + "bgrd=%d reclm=%d cyclic=%d "
> + "start=0x%lx end=0x%lx",
> + __entry->name,
> + __entry->nr_to_write,
> + __entry->pages_skipped,
> + __entry->sync_mode,
> + __entry->for_kupdate,
> + __entry->for_background,
> + __entry->for_reclaim,
> + __entry->range_cyclic,
> + __entry->range_start,
> + __entry->range_end)
> +)
> +
> +#define DEFINE_WBC_EVENT(name) \
> +DEFINE_EVENT(wbc_class, name, \
> + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
> + TP_ARGS(wbc, bdi))
> +DEFINE_WBC_EVENT(wbc_writepage);
> +
> +TRACE_EVENT(writeback_queue_io,
> + TP_PROTO(struct bdi_writeback *wb,
> + struct wb_writeback_work *work,
> + int moved),
> + TP_ARGS(wb, work, moved),
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, older)
> + __field(long, age)
> + __field(int, moved)
> + __field(int, reason)
> + ),
> + TP_fast_assign(
> + unsigned long *older_than_this = work->older_than_this;
> + strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
> + __entry->older = older_than_this ? *older_than_this : 0;
> + __entry->age = older_than_this ?
> + (jiffies - *older_than_this) * 1000 / HZ : -1;
> + __entry->moved = moved;
> + __entry->reason = work->reason;
> + ),
> + TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s",
> + __entry->name,
> + __entry->older, /* older_than_this in jiffies */
> + __entry->age, /* older_than_this in relative milliseconds */
> + __entry->moved,
> + __print_symbolic(__entry->reason, WB_WORK_REASON)
> + )
> +);
> +
> +TRACE_EVENT(global_dirty_state,
> +
> + TP_PROTO(unsigned long background_thresh,
> + unsigned long dirty_thresh
> + ),
> +
> + TP_ARGS(background_thresh,
> + dirty_thresh
> + ),
> +
> + TP_STRUCT__entry(
> + __field(unsigned long, nr_dirty)
> + __field(unsigned long, nr_writeback)
> + __field(unsigned long, nr_unstable)
> + __field(unsigned long, background_thresh)
> + __field(unsigned long, dirty_thresh)
> + __field(unsigned long, dirty_limit)
> + __field(unsigned long, nr_dirtied)
> + __field(unsigned long, nr_written)
> + ),
> +
> + TP_fast_assign(
> + __entry->nr_dirty = global_page_state(NR_FILE_DIRTY);
> + __entry->nr_writeback = global_page_state(NR_WRITEBACK);
> + __entry->nr_unstable = global_page_state(NR_UNSTABLE_NFS);
> + __entry->nr_dirtied = global_page_state(NR_DIRTIED);
> + __entry->nr_written = global_page_state(NR_WRITTEN);
> + __entry->background_thresh = background_thresh;
> + __entry->dirty_thresh = dirty_thresh;
> + __entry->dirty_limit = global_dirty_limit;
> + ),
> +
> + TP_printk("dirty=%lu writeback=%lu unstable=%lu "
> + "bg_thresh=%lu thresh=%lu limit=%lu "
> + "dirtied=%lu written=%lu",
> + __entry->nr_dirty,
> + __entry->nr_writeback,
> + __entry->nr_unstable,
> + __entry->background_thresh,
> + __entry->dirty_thresh,
> + __entry->dirty_limit,
> + __entry->nr_dirtied,
> + __entry->nr_written
> + )
> +);
> +
> +#define KBps(x) ((x) << (PAGE_SHIFT - 10))
> +
> +TRACE_EVENT(bdi_dirty_ratelimit,
> +
> + TP_PROTO(struct backing_dev_info *bdi,
> + unsigned long dirty_rate,
> + unsigned long task_ratelimit),
> +
> + TP_ARGS(bdi, dirty_rate, task_ratelimit),
> +
> + TP_STRUCT__entry(
> + __array(char, bdi, 32)
> + __field(unsigned long, write_bw)
> + __field(unsigned long, avg_write_bw)
> + __field(unsigned long, dirty_rate)
> + __field(unsigned long, dirty_ratelimit)
> + __field(unsigned long, task_ratelimit)
> + __field(unsigned long, balanced_dirty_ratelimit)
> + ),
> +
> + TP_fast_assign(
> + strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
> + __entry->write_bw = KBps(bdi->write_bandwidth);
> + __entry->avg_write_bw = KBps(bdi->avg_write_bandwidth);
> + __entry->dirty_rate = KBps(dirty_rate);
> + __entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
> + __entry->task_ratelimit = KBps(task_ratelimit);
> + __entry->balanced_dirty_ratelimit =
> + KBps(bdi->balanced_dirty_ratelimit);
> + ),
> +
> + TP_printk("bdi %s: "
> + "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
> + "dirty_ratelimit=%lu task_ratelimit=%lu "
> + "balanced_dirty_ratelimit=%lu",
> + __entry->bdi,
> + __entry->write_bw, /* write bandwidth */
> + __entry->avg_write_bw, /* avg write bandwidth */
> + __entry->dirty_rate, /* bdi dirty rate */
> + __entry->dirty_ratelimit, /* base ratelimit */
> + __entry->task_ratelimit, /* ratelimit with position control */
> + __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
> + )
> +);
> +
> +TRACE_EVENT(balance_dirty_pages,
> +
> + TP_PROTO(struct backing_dev_info *bdi,
> + unsigned long thresh,
> + unsigned long bg_thresh,
> + unsigned long dirty,
> + unsigned long bdi_thresh,
> + unsigned long bdi_dirty,
> + unsigned long dirty_ratelimit,
> + unsigned long task_ratelimit,
> + unsigned long dirtied,
> + unsigned long period,
> + long pause,
> + unsigned long start_time),
> +
> + TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
> + dirty_ratelimit, task_ratelimit,
> + dirtied, period, pause, start_time),
> +
> + TP_STRUCT__entry(
> + __array( char, bdi, 32)
> + __field(unsigned long, limit)
> + __field(unsigned long, setpoint)
> + __field(unsigned long, dirty)
> + __field(unsigned long, bdi_setpoint)
> + __field(unsigned long, bdi_dirty)
> + __field(unsigned long, dirty_ratelimit)
> + __field(unsigned long, task_ratelimit)
> + __field(unsigned int, dirtied)
> + __field(unsigned int, dirtied_pause)
> + __field(unsigned long, paused)
> + __field( long, pause)
> + __field(unsigned long, period)
> + __field( long, think)
> + ),
> +
> + TP_fast_assign(
> + unsigned long freerun = (thresh + bg_thresh) / 2;
> + strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
> +
> + __entry->limit = global_dirty_limit;
> + __entry->setpoint = (global_dirty_limit + freerun) / 2;
> + __entry->dirty = dirty;
> + __entry->bdi_setpoint = __entry->setpoint *
> + bdi_thresh / (thresh + 1);
> + __entry->bdi_dirty = bdi_dirty;
> + __entry->dirty_ratelimit = KBps(dirty_ratelimit);
> + __entry->task_ratelimit = KBps(task_ratelimit);
> + __entry->dirtied = dirtied;
> + __entry->dirtied_pause = current->nr_dirtied_pause;
> + __entry->think = current->dirty_paused_when == 0 ? 0 :
> + (long)(jiffies - current->dirty_paused_when) * 1000/HZ;
> + __entry->period = period * 1000 / HZ;
> + __entry->pause = pause * 1000 / HZ;
> + __entry->paused = (jiffies - start_time) * 1000 / HZ;
> + ),
> +
> +
> + TP_printk("bdi %s: "
> + "limit=%lu setpoint=%lu dirty=%lu "
> + "bdi_setpoint=%lu bdi_dirty=%lu "
> + "dirty_ratelimit=%lu task_ratelimit=%lu "
> + "dirtied=%u dirtied_pause=%u "
> + "paused=%lu pause=%ld period=%lu think=%ld",
> + __entry->bdi,
> + __entry->limit,
> + __entry->setpoint,
> + __entry->dirty,
> + __entry->bdi_setpoint,
> + __entry->bdi_dirty,
> + __entry->dirty_ratelimit,
> + __entry->task_ratelimit,
> + __entry->dirtied,
> + __entry->dirtied_pause,
> + __entry->paused, /* ms */
> + __entry->pause, /* ms */
> + __entry->period, /* ms */
> + __entry->think /* ms */
> + )
> +);
> +
> +TRACE_EVENT(writeback_sb_inodes_requeue,
> +
> + TP_PROTO(struct inode *inode),
> + TP_ARGS(inode),
> +
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, ino)
> + __field(unsigned long, state)
> + __field(unsigned long, dirtied_when)
> + ),
> +
> + TP_fast_assign(
> + strncpy(__entry->name,
> + dev_name(inode_to_bdi(inode)->dev), 32);
> + __entry->ino = inode->i_ino;
> + __entry->state = inode->i_state;
> + __entry->dirtied_when = inode->dirtied_when;
> + ),
> +
> + TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu",
> + __entry->name,
> + __entry->ino,
> + show_inode_state(__entry->state),
> + __entry->dirtied_when,
> + (jiffies - __entry->dirtied_when) / HZ
> + )
> +);
> +
> +DECLARE_EVENT_CLASS(writeback_congest_waited_template,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed),
> +
> + TP_STRUCT__entry(
> + __field( unsigned int, usec_timeout )
> + __field( unsigned int, usec_delayed )
> + ),
> +
> + TP_fast_assign(
> + __entry->usec_timeout = usec_timeout;
> + __entry->usec_delayed = usec_delayed;
> + ),
> +
> + TP_printk("usec_timeout=%u usec_delayed=%u",
> + __entry->usec_timeout,
> + __entry->usec_delayed)
> +);
> +
> +DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed)
> +);
> +
> +DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
> +
> + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
> +
> + TP_ARGS(usec_timeout, usec_delayed)
> +);
> +
> +DECLARE_EVENT_CLASS(writeback_single_inode_template,
> +
> + TP_PROTO(struct inode *inode,
> + struct writeback_control *wbc,
> + unsigned long nr_to_write
> + ),
> +
> + TP_ARGS(inode, wbc, nr_to_write),
> +
> + TP_STRUCT__entry(
> + __array(char, name, 32)
> + __field(unsigned long, ino)
> + __field(unsigned long, state)
> + __field(unsigned long, dirtied_when)
> + __field(unsigned long, writeback_index)
> + __field(long, nr_to_write)
> + __field(unsigned long, wrote)
> + ),
> +
> + TP_fast_assign(
> + strncpy(__entry->name,
> + dev_name(inode_to_bdi(inode)->dev), 32);
> + __entry->ino = inode->i_ino;
> + __entry->state = inode->i_state;
> + __entry->dirtied_when = inode->dirtied_when;
> + __entry->writeback_index = inode->i_mapping->writeback_index;
> + __entry->nr_to_write = nr_to_write;
> + __entry->wrote = nr_to_write - wbc->nr_to_write;
> + ),
> +
> + TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
> + "index=%lu to_write=%ld wrote=%lu",
> + __entry->name,
> + __entry->ino,
> + show_inode_state(__entry->state),
> + __entry->dirtied_when,
> + (jiffies - __entry->dirtied_when) / HZ,
> + __entry->writeback_index,
> + __entry->nr_to_write,
> + __entry->wrote
> + )
> +);
> +
> +DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
> + TP_PROTO(struct inode *inode,
> + struct writeback_control *wbc,
> + unsigned long nr_to_write),
> + TP_ARGS(inode, wbc, nr_to_write)
> +);
> +
> +#endif /* _TRACE_WRITEBACK_H */
> +
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> diff --git a/probes/Makefile b/probes/Makefile
> index 779616d..088cd5f 100644
> --- a/probes/Makefile
> +++ b/probes/Makefile
> @@ -121,6 +121,79 @@ endif
> #obj-m += lttng-probe-lock.o
> #endif
>
> +ifneq ($(CONFIG_BTRFS_FS),)
> +btrfs_dep = $(srctree)/fs/btrfs/*.h
> +btrfs = $(shell \
> + if [ $(VERSION) -ge 3 \
> + -o \( $(VERSION) -eq 2 -a $(PATCHLEVEL) -ge 6 -a $(SUBLEVEL) -ge 39 \) ] ; then \
> + echo "lttng-probe-btrfs.o" ; fi;)
> +ifneq ($(btrfs),)
> +ifeq ($(wildcard $(btrfs_dep)),)
> +$(warning Files $(btrfs_dep) not found. Probe "btrfs" is disabled. Use full kernel source tree to enable it.)
> +btrfs =
> +endif
> +endif
> +obj-m += $(btrfs)
> +endif
> +
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 \
> + -o \( $(VERSION) -eq 2 -a $(PATCHLEVEL) -ge 6 -a $(SUBLEVEL) -ge 38 \) ] ; then \
> + echo "lttng-probe-compaction.o" ; fi;)
> +
> +ifneq ($(CONFIG_EXT4_FS),)
> +ext4_dep = $(srctree)/fs/ext4/*.h
> +ext4 = lttng-probe-ext4.o
> +ifeq ($(wildcard $(ext4_dep)),)
> +$(warning Files $(ext4_dep) not found. Probe "ext4" is disabled. Use full kernel source tree to enable it.)
> +ext4 =
> +endif
> +obj-m += $(ext4)
> +endif
> +
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 -a $(PATCHLEVEL) -ge 4 ] ; then \
> + echo "lttng-probe-printk.o" ; fi;)
> +ifneq ($(CONFIG_FRAME_WARN),0)
> +CFLAGS_lttng-probe-printk.o += -Wframe-larger-than=2200
> +endif
> +
> +obj-m += $(shell \
> + if [ \( $(VERSION) -eq 3 -a $(PATCHLEVEL) -ge 6 \) \
> + -o \( $(VERSION) -eq 3 -a $(PATCHLEVEL) -eq 5 -a $(SUBLEVEL) -ge 2 \) \
> + -o \( $(VERSION) -eq 3 -a $(PATCHLEVEL) -eq 4 -a $(SUBLEVEL) -ge 9 \) \
> + -o \( $(VERSION) -eq 3 -a $(PATCHLEVEL) -eq 0 -a $(SUBLEVEL) -ge 41 \) ] ; then \
> + echo "lttng-probe-random.o" ; fi;)
> +
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 -a $(PATCHLEVEL) -ge 2 ] ; then \
> + echo "lttng-probe-rcu.o" ; fi;)
> +
> +ifneq ($(CONFIG_REGMAP),)
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 -a $(PATCHLEVEL) -ge 2 ] ; then \
> + echo "lttng-probe-regmap.o" ; fi;)
> +endif
> +
> +ifneq ($(CONFIG_PM_RUNTIME),)
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 -a $(PATCHLEVEL) -ge 2 ] ; then \
> + echo "lttng-probe-rpm.o" ; fi;)
> +endif
> +
> +ifneq ($(CONFIG_SUNRPC),)
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 -a $(PATCHLEVEL) -ge 4 ] ; then \
> + echo "lttng-probe-sunrpc.o" ; fi;)
> +endif
> +
> +obj-m += lttng-probe-workqueue.o
> +
> +obj-m += $(shell \
> + if [ $(VERSION) -ge 3 \
> + -o \( $(VERSION) -eq 2 -a $(PATCHLEVEL) -ge 6 -a $(SUBLEVEL) -ge 36 \) ] ; then \
> + echo "lttng-probe-writeback.o" ; fi;)
> +
>
> ifneq ($(CONFIG_KPROBES),)
> obj-m += lttng-kprobes.o
> diff --git a/probes/lttng-probe-btrfs.c b/probes/lttng-probe-btrfs.c
> new file mode 100644
> index 0000000..4b5f84e
> --- /dev/null
> +++ b/probes/lttng-probe-btrfs.c
> @@ -0,0 +1,48 @@
> +/*
> + * probes/lttng-probe-btrfs.c
> + *
> + * LTTng btrfs probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/fs.h>
> +#include <../fs/btrfs/ctree.h>
> +#include <../fs/btrfs/transaction.h>
> +#include <../fs/btrfs/volumes.h>
> +#include <linux/dcache.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/btrfs.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/btrfs.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng btrfs probes");
> diff --git a/probes/lttng-probe-compaction.c b/probes/lttng-probe-compaction.c
> new file mode 100644
> index 0000000..13b9959
> --- /dev/null
> +++ b/probes/lttng-probe-compaction.c
> @@ -0,0 +1,43 @@
> +/*
> + * probes/lttng-probe-compaction.c
> + *
> + * LTTng compaction probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/compaction.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/compaction.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng compaction probes");
> diff --git a/probes/lttng-probe-ext4.c b/probes/lttng-probe-ext4.c
> new file mode 100644
> index 0000000..19c9b68
> --- /dev/null
> +++ b/probes/lttng-probe-ext4.c
> @@ -0,0 +1,50 @@
> +/*
> + * probes/lttng-probe-ext4.c
> + *
> + * LTTng ext4 probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/fs.h>
> +#include <../fs/ext4/ext4.h>
> +#include <../fs/ext4/mballoc.h>
> +#include <linux/dcache.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/ext4.h>
> +
> +#include "../lttng-kernel-version.h"
> +#include "../wrapper/tracepoint.h"
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/ext4.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng ext4 probes");
> diff --git a/probes/lttng-probe-printk.c b/probes/lttng-probe-printk.c
> new file mode 100644
> index 0000000..1fe1f01
> --- /dev/null
> +++ b/probes/lttng-probe-printk.c
> @@ -0,0 +1,43 @@
> +/*
> + * probes/lttng-probe-printk.c
> + *
> + * LTTng printk probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/printk.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/printk.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng printk probes");
> diff --git a/probes/lttng-probe-random.c b/probes/lttng-probe-random.c
> new file mode 100644
> index 0000000..df9f551
> --- /dev/null
> +++ b/probes/lttng-probe-random.c
> @@ -0,0 +1,43 @@
> +/*
> + * probes/lttng-probe-random.c
> + *
> + * LTTng random probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/random.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/random.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng random probes");
> diff --git a/probes/lttng-probe-rcu.c b/probes/lttng-probe-rcu.c
> new file mode 100644
> index 0000000..5216500
> --- /dev/null
> +++ b/probes/lttng-probe-rcu.c
> @@ -0,0 +1,44 @@
> +/*
> + * probes/lttng-probe-rcu.c
> + *
> + * LTTng rcu probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/rcupdate.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/rcu.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/rcu.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng rcu probes");
> diff --git a/probes/lttng-probe-regmap.c b/probes/lttng-probe-regmap.c
> new file mode 100644
> index 0000000..7c1fd00
> --- /dev/null
> +++ b/probes/lttng-probe-regmap.c
> @@ -0,0 +1,44 @@
> +/*
> + * probes/lttng-probe-regmap.c
> + *
> + * LTTng regmap probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/device.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/regmap.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/regmap.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng regmap probes");
> diff --git a/probes/lttng-probe-rpm.c b/probes/lttng-probe-rpm.c
> new file mode 100644
> index 0000000..607e9e5
> --- /dev/null
> +++ b/probes/lttng-probe-rpm.c
> @@ -0,0 +1,44 @@
> +/*
> + * probes/lttng-probe-rpm.c
> + *
> + * LTTng rpm probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/device.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/rpm.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/rpm.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng rpm probes");
> diff --git a/probes/lttng-probe-sunrpc.c b/probes/lttng-probe-sunrpc.c
> new file mode 100644
> index 0000000..504413e
> --- /dev/null
> +++ b/probes/lttng-probe-sunrpc.c
> @@ -0,0 +1,43 @@
> +/*
> + * probes/lttng-probe-sunrpc.c
> + *
> + * LTTng sunrpc probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/sunrpc.h>
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/sunrpc.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng sunrpc probes");
> diff --git a/probes/lttng-probe-workqueue.c b/probes/lttng-probe-workqueue.c
> new file mode 100644
> index 0000000..6f36e00
> --- /dev/null
> +++ b/probes/lttng-probe-workqueue.c
> @@ -0,0 +1,48 @@
> +/*
> + * probes/lttng-probe-workqueue.c
> + *
> + * LTTng workqueue probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/idr.h>
> +
> +struct cpu_workqueue_struct;
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/workqueue.h>
> +
> +#include "../wrapper/tracepoint.h"
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/workqueue.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng workqueue probes");
> diff --git a/probes/lttng-probe-writeback.c b/probes/lttng-probe-writeback.c
> new file mode 100644
> index 0000000..0a5c022
> --- /dev/null
> +++ b/probes/lttng-probe-writeback.c
> @@ -0,0 +1,69 @@
> +/*
> + * probes/lttng-probe-writeback.c
> + *
> + * LTTng writeback probes.
> + *
> + * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
> + * Copyright (C) 2012 Mentor Graphics Corp.
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; only
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/mm.h>
> +
> +/*
> + * Create the tracepoint static inlines from the kernel to validate that our
> + * trace event macros match the kernel we run on.
> + */
> +#include <trace/events/writeback.h>
> +
> +#include "../lttng-kernel-version.h"
> +
> +/* #if <check version number if global_dirty_limit will be exported> */
> +#ifdef CONFIG_KALLSYMS
> +#include "../wrapper/kallsyms.h"
> +
> +static unsigned long *wrapper_global_dirty_limit_sym = 0;
> +static inline
> +unsigned long wrapper_global_dirty_limit(void)
> +{
> + if (!wrapper_global_dirty_limit_sym)
> + wrapper_global_dirty_limit_sym =
> + (void *)kallsyms_lookup_funcptr("global_dirty_limit");
> + if (wrapper_global_dirty_limit_sym)
> + return *wrapper_global_dirty_limit_sym;
> + else {
> + printk(KERN_WARNING "LTTng: global_dirty_limit symbol lookup failed.\n");
> + return 0;
> + }
> +}
> +#define global_dirty_limit wrapper_global_dirty_limit()
> +#endif
> +/* #endif <check version number> */
> +
> +/*
> + * Create LTTng tracepoint probes.
> + */
> +#define LTTNG_PACKAGE_BUILD
> +#define CREATE_TRACE_POINTS
> +#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
> +
> +#include "../instrumentation/events/lttng-module/writeback.h"
> +
> +MODULE_LICENSE("GPL and additional rights");
> +MODULE_AUTHOR("Andrew Gabbasov <andrew_gabbasov at mentor.com>");
> +MODULE_DESCRIPTION("LTTng writeback probes");
> --
> 1.7.10.4
>
>
> _______________________________________________
> lttng-dev mailing list
> lttng-dev at lists.lttng.org
> http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
--
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
More information about the lttng-dev
mailing list