[PATCH lttng-modules 2/3] Fix: update writeback instrumentation for kernel 4.14

[PATCH lttng-modules 2/3] Fix: update writeback instrumentation for kernel 4.14

[Michael Jeanson]

See upstream commits:

  commit 11fb998986a72aa7e997d96d63d52582a01228c5
  Author: Mel Gorman <mgorman@techsingularity.net>
  Date:   Thu Jul 28 15:46:20 2016 -0700

    mm: move most file-based accounting to the node

    There are now a number of accounting oddities such as mapped file pages
    being accounted for on the node while the total number of file pages are
    accounted on the zone.  This can be coped with to some extent but it's
    confusing so this patch moves the relevant file-based accounted.  Due to
    throttling logic in the page allocator for reliable OOM detection, it is
    still necessary to track dirty and writeback pages on a per-zone basis.

  commit c4a25635b60d08853a3e4eaae3ab34419a36cfa2
  Author: Mel Gorman <mgorman@techsingularity.net>
  Date:   Thu Jul 28 15:46:23 2016 -0700

    mm: move vmscan writes and file write accounting to the node

    As reclaim is now node-based, it follows that page write activity due to
    page reclaim should also be accounted for on the node.  For consistency,
    also account page writes and page dirtying on a per-node basis.

    After this patch, there are a few remaining zone counters that may appear
    strange but are fine.  NUMA stats are still per-zone as this is a
    user-space interface that tools consume.  NR_MLOCK, NR_SLAB_*,
    NR_PAGETABLE, NR_KERNEL_STACK and NR_BOUNCE are all allocations that
    potentially pin low memory and cannot trivially be reclaimed on demand.
    This information is still useful for debugging a page allocation failure
    warning.

Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
---
 instrumentation/events/lttng-module/writeback.h | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/instrumentation/events/lttng-module/writeback.h b/instrumentation/events/lttng-module/writeback.h
index 6006c29..c472b33 100644
--- a/instrumentation/events/lttng-module/writeback.h
+++ b/instrumentation/events/lttng-module/writeback.h
@@ -400,6 +400,31 @@ LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
 	)
 )
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
+
+	writeback_global_dirty_state,
+
+	TP_PROTO(unsigned long background_thresh,
+		 unsigned long dirty_thresh
+	),
+
+	TP_ARGS(background_thresh,
+		dirty_thresh
+	),
+
+	TP_FIELDS(
+		ctf_integer(unsigned long, nr_dirty, global_node_page_state(NR_FILE_DIRTY))
+		ctf_integer(unsigned long, nr_writeback, global_node_page_state(NR_WRITEBACK))
+		ctf_integer(unsigned long, nr_unstable, global_node_page_state(NR_UNSTABLE_NFS))
+		ctf_integer(unsigned long, nr_dirtied, global_node_page_state(NR_DIRTIED))
+		ctf_integer(unsigned long, nr_written, global_node_page_state(NR_WRITTEN))
+		ctf_integer(unsigned long, background_thresh, background_thresh)
+		ctf_integer(unsigned long, dirty_thresh, dirty_thresh)
+		ctf_integer(unsigned long, dirty_limit, global_dirty_limit)
+	)
+)
+#else
 LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
 
 	writeback_global_dirty_state,
@@ -424,6 +449,7 @@ LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
 	)
 )
 #endif
+#endif
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
 
-- 
2.7.4

_______________________________________________
lttng-dev mailing list
lttng-dev@lists.lttng.org
https://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev

[PATCH lttng-modules 3/3] Fix: update btrfs instrumentation for kernel 4.14

[Michael Jeanson]

See upstream commit:

  Author: Jeff Mahoney <jeffm@suse.com>
  Date:   Wed Jun 28 21:56:54 2017 -0600

    btrfs: constify tracepoint arguments

    Tracepoint arguments are all read-only.  If we mark the arguments
    as const, we're able to keep or convert those arguments to const
    where appropriate.

Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
---
 instrumentation/events/lttng-module/btrfs.h | 497 +++++++++++++++++++++++++++-
 1 file changed, 486 insertions(+), 11 deletions(-)

diff --git a/instrumentation/events/lttng-module/btrfs.h b/instrumentation/events/lttng-module/btrfs.h
index 72777bc..48b7cae 100644
--- a/instrumentation/events/lttng-module/btrfs.h
+++ b/instrumentation/events/lttng-module/btrfs.h
@@ -32,6 +32,58 @@ struct extent_state;
 
 #define BTRFS_UUID_SIZE 16
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit,
+
+	TP_PROTO(const struct btrfs_root *root),
+
+	TP_ARGS(root),
+
+	TP_FIELDS(
+		ctf_integer(u64, generation, root->fs_info->generation)
+		ctf_integer(u64, root_objectid, root->root_key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode,
+
+	TP_PROTO(const struct inode *inode),
+
+	TP_ARGS(inode),
+
+	TP_FIELDS(
+		ctf_integer(ino_t, ino, inode->i_ino)
+		ctf_integer(blkcnt_t, blocks, inode->i_blocks)
+		ctf_integer(u64, disk_i_size, BTRFS_I(inode)->disk_i_size)
+		ctf_integer(u64, generation, BTRFS_I(inode)->generation)
+		ctf_integer(u64, last_trans, BTRFS_I(inode)->last_trans)
+		ctf_integer(u64, logged_trans, BTRFS_I(inode)->logged_trans)
+		ctf_integer(u64, root_objectid,
+				BTRFS_I(inode)->root->root_key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new,
+
+	TP_PROTO(const struct inode *inode),
+
+	TP_ARGS(inode)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request,
+
+	TP_PROTO(const struct inode *inode),
+
+	TP_ARGS(inode)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict,
+
+	TP_PROTO(const struct inode *inode),
+
+	TP_ARGS(inode)
+)
+#else
 LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit,
 
 	TP_PROTO(struct btrfs_root *root),
@@ -82,8 +134,32 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict,
 
 	TP_ARGS(inode)
 )
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+
+LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
+
+	TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode,
+		const struct extent_map *map),
+
+	TP_ARGS(root, inode, map),
+
+	TP_FIELDS(
+		ctf_integer(u64, root_objectid, root->root_key.objectid)
+		ctf_integer(u64, ino, btrfs_ino(inode))
+		ctf_integer(u64, start, map->start)
+		ctf_integer(u64, len, map->len)
+		ctf_integer(u64, orig_start, map->orig_start)
+		ctf_integer(u64, block_start, map->block_start)
+		ctf_integer(u64, block_len, map->block_len)
+		ctf_integer(unsigned long, flags, map->flags)
+		ctf_integer(int, refs, refcount_read(&map->refs))
+		ctf_integer(unsigned int, compress_type, map->compress_type)
+	)
+)
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 
 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 
@@ -175,7 +251,29 @@ LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 
 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
+
+	TP_PROTO(const struct inode *inode,
+		 const struct btrfs_ordered_extent *ordered),
+
+	TP_ARGS(inode, ordered),
+
+	TP_FIELDS(
+		ctf_integer(ino_t, ino, inode->i_ino)
+		ctf_integer(u64, file_offset, ordered->file_offset)
+		ctf_integer(u64, start, ordered->start)
+		ctf_integer(u64, len, ordered->len)
+		ctf_integer(u64, disk_len, ordered->disk_len)
+		ctf_integer(u64, bytes_left, ordered->bytes_left)
+		ctf_integer(unsigned long, flags, ordered->flags)
+		ctf_integer(int, compress_type, ordered->compress_type)
+		ctf_integer(int, refs, refcount_read(&ordered->refs))
+		ctf_integer(u64, root_objectid,
+				BTRFS_I(inode)->root->root_key.objectid)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 
 	TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
@@ -219,6 +317,107 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 )
 #endif
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
+
+	TP_PROTO(const struct inode *inode,
+		 const struct btrfs_ordered_extent *ordered),
+
+	TP_ARGS(inode, ordered)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
+
+	TP_PROTO(const struct inode *inode,
+		 const struct btrfs_ordered_extent *ordered),
+
+	TP_ARGS(inode, ordered)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
+
+	TP_PROTO(const struct inode *inode,
+		 const struct btrfs_ordered_extent *ordered),
+
+	TP_ARGS(inode, ordered)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
+
+	TP_PROTO(const struct inode *inode,
+		 const struct btrfs_ordered_extent *ordered),
+
+	TP_ARGS(inode, ordered)
+)
+
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
+
+	TP_PROTO(const struct page *page, const struct inode *inode,
+		 const struct writeback_control *wbc),
+
+	TP_ARGS(page, inode, wbc),
+
+	TP_FIELDS(
+		ctf_integer(ino_t, ino, inode->i_ino)
+		ctf_integer(pgoff_t, index, page->index)
+		ctf_integer(long, nr_to_write, wbc->nr_to_write)
+		ctf_integer(long, pages_skipped, wbc->pages_skipped)
+		ctf_integer(loff_t, range_start, wbc->range_start)
+		ctf_integer(loff_t, range_end, wbc->range_end)
+		ctf_integer(char, for_kupdate, wbc->for_kupdate)
+		ctf_integer(char, for_reclaim, wbc->for_reclaim)
+		ctf_integer(char, range_cyclic, wbc->range_cyclic)
+		ctf_integer(pgoff_t, writeback_index,
+				inode->i_mapping->writeback_index)
+		ctf_integer(u64, root_objectid,
+				BTRFS_I(inode)->root->root_key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs__writepage,
+
+	__extent_writepage,
+
+	btrfs__extent_writepage,
+
+	TP_PROTO(const struct page *page, const struct inode *inode,
+		 const struct writeback_control *wbc),
+
+	TP_ARGS(page, inode, wbc)
+)
+
+LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook,
+
+	TP_PROTO(const struct page *page, u64 start, u64 end, int uptodate),
+
+	TP_ARGS(page, start, end, uptodate),
+
+	TP_FIELDS(
+		ctf_integer(ino_t, ino, page->mapping->host->i_ino)
+		ctf_integer(pgoff_t, index, page->index)
+		ctf_integer(u64, start, start)
+		ctf_integer(u64, end, end)
+		ctf_integer(int, uptodate, uptodate)
+		ctf_integer(u64, root_objectid,
+			BTRFS_I(page->mapping->host)->root->root_key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
+
+	TP_PROTO(const struct file *file, int datasync),
+
+	TP_ARGS(file, datasync),
+
+	TP_FIELDS(
+		ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino)
+		ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino)
+		ctf_integer(int, datasync, datasync)
+		ctf_integer(u64, root_objectid,
+			BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
+	)
+)
+#else
 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
 
 	TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
@@ -317,8 +516,20 @@ LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
 			BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
 	)
 )
+#endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
+
+	TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),
+
+	TP_ARGS(fs_info, wait),
+
+	TP_FIELDS(
+		ctf_integer(int, wait, wait)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
 
 	TP_PROTO(struct btrfs_fs_info *fs_info, int wait),
@@ -342,6 +553,25 @@ LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
 )
 #endif
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
+
+	TP_PROTO(const struct btrfs_fs_info *fs_info,
+		 const struct btrfs_block_group_cache *block_group, int create),
+
+	TP_ARGS(fs_info, block_group, create),
+
+	TP_FIELDS(
+		ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
+		ctf_integer(u64, offset, block_group->key.objectid)
+		ctf_integer(u64, size, block_group->key.offset)
+		ctf_integer(u64, flags, block_group->flags)
+		ctf_integer(u64, bytes_used, btrfs_block_group_used(&block_group->item))
+		ctf_integer(u64, bytes_super, block_group->bytes_super)
+		ctf_integer(int, create, create)
+	)
+)
+#else
 LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
 
 	TP_PROTO(struct btrfs_fs_info *fs_info,
@@ -359,8 +589,30 @@ LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
 		ctf_integer(int, create, create)
 	)
 )
+#endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
+
+	TP_PROTO(const struct btrfs_fs_info *fs_info,
+		 const struct btrfs_delayed_ref_node *ref,
+		 const struct btrfs_delayed_tree_ref *full_ref,
+		 int action),
+
+	TP_ARGS(fs_info, ref, full_ref, action),
+
+	TP_FIELDS(
+		ctf_integer(u64, bytenr, ref->bytenr)
+		ctf_integer(u64, num_bytes, ref->num_bytes)
+		ctf_integer(int, action, action)
+		ctf_integer(u64, parent, full_ref->parent)
+		ctf_integer(u64, ref_root, full_ref->root)
+		ctf_integer(int, level, full_ref->level)
+		ctf_integer(int, type, ref->type)
+		ctf_integer(u64, seq, ref->seq)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
 
 	TP_PROTO(struct btrfs_fs_info *fs_info,
@@ -464,7 +716,42 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_ref_head,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
+
+	TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
+		 u64 offset, u64 size),
+
+	TP_ARGS(fs_info, map, offset, size),
+
+	TP_FIELDS(
+		ctf_integer(int, num_stripes, map->num_stripes)
+		ctf_integer(u64, type, map->type)
+		ctf_integer(int, sub_stripes, map->sub_stripes)
+		ctf_integer(u64, offset, offset)
+		ctf_integer(u64, size, size)
+		ctf_integer(u64, root_objectid, fs_info->chunk_root->root_key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_alloc,
+
+	TP_PROTO(const struct btrfs_fs_info *info, const struct map_lookup *map,
+		 u64 offset, u64 size),
+
+	TP_ARGS(info, map, offset, size)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
+
+	TP_PROTO(const struct btrfs_fs_info *info, const struct map_lookup *map,
+		 u64 offset, u64 size),
+
+	TP_ARGS(info, map, offset, size)
+)
+
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
 
 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
 
@@ -536,6 +823,24 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
 
 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
+
+	TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf,
+		 const struct extent_buffer *cow),
+
+	TP_ARGS(root, buf, cow),
+
+	TP_FIELDS(
+		ctf_integer(u64, root_objectid, root->root_key.objectid)
+		ctf_integer(u64, buf_start, buf->start)
+		ctf_integer(int, refs, atomic_read(&buf->refs))
+		ctf_integer(u64, cow_start, cow->start)
+		ctf_integer(int, buf_level, btrfs_header_level(buf))
+		ctf_integer(int, cow_level, btrfs_header_level(cow))
+	)
+)
+#else
 LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
 
 	TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
@@ -552,8 +857,25 @@ LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
 		ctf_integer(int, cow_level, btrfs_header_level(cow))
 	)
 )
+#endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
+
+	TP_PROTO(const struct btrfs_fs_info *fs_info, char *type, u64 val,
+		 u64 bytes, int reserve),
+
+	TP_ARGS(fs_info, type, val, bytes, reserve),
+
+	TP_FIELDS(
+		ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
+		ctf_string(type, type)
+		ctf_integer(u64, val, val)
+		ctf_integer(u64, bytes, bytes)
+		ctf_integer(int, reserve, reserve)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
 LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
 
 	TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
@@ -571,7 +893,35 @@ LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
+
+	TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
+
+	TP_ARGS(info, start, len),
+
+	TP_FIELDS(
+		ctf_integer(u64, start, start)
+		ctf_integer(u64, len, len)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
+
+	TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
+
+	TP_ARGS(info, start, len)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_free,
+
+	TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
+
+	TP_ARGS(info, start, len)
+)
+
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
 
 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
 
@@ -630,14 +980,64 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_f
 
 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
 
 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
 
 	btrfs_find_free_extent,
 
+	TP_PROTO(const struct btrfs_fs_info *info, u64 num_bytes, u64 empty_size,
+		 u64 data),
+
+	TP_ARGS(info, num_bytes, empty_size, data),
+
+	TP_FIELDS(
+		ctf_integer(u64, num_bytes, num_bytes)
+		ctf_integer(u64, empty_size, empty_size)
+		ctf_integer(u64, data, data)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
+
+	TP_PROTO(const struct btrfs_fs_info *info,
+		 const struct btrfs_block_group_cache *block_group, u64 start,
+		 u64 len),
+
+	TP_ARGS(info, block_group, start, len),
+
+	TP_FIELDS(
+		ctf_integer(u64, bg_objectid, block_group->key.objectid)
+		ctf_integer(u64, flags, block_group->flags)
+		ctf_integer(u64, start, start)
+		ctf_integer(u64, len, len)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
+
+	TP_PROTO(const struct btrfs_fs_info *info,
+		 const struct btrfs_block_group_cache *block_group, u64 start,
+		 u64 len),
+
+	TP_ARGS(info, block_group, start, len)
+)
+
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
+
+	TP_PROTO(const struct btrfs_fs_info *info,
+		 const struct btrfs_block_group_cache *block_group, u64 start,
+		 u64 len),
+
+	TP_ARGS(info, block_group, start, len)
+)
+
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+
+LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
+
+	btrfs_find_free_extent,
+
 	TP_PROTO(struct btrfs_fs_info *info, u64 num_bytes, u64 empty_size,
 		 u64 data),
 
@@ -684,7 +1084,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
 	TP_ARGS(info, block_group, start, len)
 )
 
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
 
 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
 
@@ -740,6 +1140,52 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
 
 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
+
+	TP_PROTO(const 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_FIELDS(
+		ctf_integer(u64, bg_objectid, block_group->key.objectid)
+		ctf_integer(u64, flags, block_group->flags)
+		ctf_integer(u64, start, start)
+		ctf_integer(u64, bytes, bytes)
+		ctf_integer(u64, empty_size, empty_size)
+		ctf_integer(u64, min_bytes, min_bytes)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup,
+
+	TP_PROTO(const struct btrfs_block_group_cache *block_group),
+
+	TP_ARGS(block_group),
+
+	TP_FIELDS(
+		ctf_integer(u64, bg_objectid, block_group->key.objectid)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
+
+	TP_PROTO(const struct btrfs_block_group_cache *block_group,
+		 const struct btrfs_free_cluster *cluster, u64 size, int bitmap),
+
+	TP_ARGS(block_group, cluster, size, bitmap),
+
+	TP_FIELDS(
+		ctf_integer(u64, bg_objectid, block_group->key.objectid)
+		ctf_integer(u64, flags, block_group->flags)
+		ctf_integer(u64, start, cluster->window_start)
+		ctf_integer(u64, max_size, cluster->max_size)
+		ctf_integer(u64, size, size)
+		ctf_integer(int, bitmap, bitmap)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
 LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
 
 	TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
@@ -786,7 +1232,36 @@ LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
 )
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state,
+
+	btrfs_alloc_extent_state,
+
+	TP_PROTO(const struct extent_state *state, gfp_t mask, unsigned long IP),
+
+	TP_ARGS(state, mask, IP),
+
+	TP_FIELDS(
+		ctf_integer_hex(const struct extent_state *, state, state)
+		ctf_integer(gfp_t, mask, mask)
+		ctf_integer(unsigned long, ip, IP)
+	)
+)
+
+LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state,
+
+	btrfs_free_extent_state,
+
+	TP_PROTO(const struct extent_state *state, unsigned long IP),
+
+	TP_ARGS(state, IP),
+
+	TP_FIELDS(
+		ctf_integer_hex(const struct extent_state *, state, state)
+		ctf_integer(unsigned long, ip, IP)
+	)
+)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
 LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state,
 
 	btrfs_alloc_extent_state,
-- 
2.7.4

_______________________________________________
lttng-dev mailing list
lttng-dev@lists.lttng.org
https://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev

Re: [PATCH lttng-modules 1/3] Fix: update block instrumentation for kernel 4.14

[Mathieu Desnoyers]

All 3 patches merged into master, 2.10, 2.9, thanks!

Mathieu

----- On Sep 20, 2017, at 12:12 PM, Michael Jeanson mjeanson@efficios.com wrote:

> See upstream commit:
> 
>  commit 74d46992e0d9dee7f1f376de0d56d31614c8a17a
>  Author: Christoph Hellwig <hch@lst.de>
>  Date:   Wed Aug 23 19:10:32 2017 +0200
> 
>    block: replace bi_bdev with a gendisk pointer and partitions index
> 
>    This way we don't need a block_device structure to submit I/O.  The
>    block_device has different life time rules from the gendisk and
>    request_queue and is usually only available when the block device node
>    is open.  Other callers need to explicitly create one (e.g. the lightnvm
>    passthrough code, or the new nvme multipathing code).
> 
>    For the actual I/O path all that we need is the gendisk, which exists
>    once per block device.  But given that the block layer also does
>    partition remapping we additionally need a partition index, which is
>    used for said remapping in generic_make_request.
> 
>    Note that all the block drivers generally want request_queue or
>    sometimes the gendisk, so this removes a layer of indirection all
>    over the stack.
> 
> Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
> ---
> instrumentation/events/lttng-module/block.h | 23 +++++++++++++++--------
> 1 file changed, 15 insertions(+), 8 deletions(-)
> 
> diff --git a/instrumentation/events/lttng-module/block.h
> b/instrumentation/events/lttng-module/block.h
> index c43d747..80ea25c 100644
> --- a/instrumentation/events/lttng-module/block.h
> +++ b/instrumentation/events/lttng-module/block.h
> @@ -33,6 +33,13 @@ enum {
> 
> #endif /* _TRACE_BLOCK_DEF_ */
> 
> +
> +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
> +#define lttng_bio_dev(bio) bio_dev(bio)
> +#else
> +#define lttng_bio_dev(bio) ((bio)->bi_bdev ? (bio)->bi_bdev->bd_dev : 0)
> +#endif
> +
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
> 
> #define lttng_req_op(rq)	req_op(rq)
> @@ -611,7 +618,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
> 	TP_ARGS(q, bio),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
> @@ -652,7 +659,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complete,
> #endif
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
> @@ -682,7 +689,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
> 	TP_ARGS(q, rq, bio),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
> @@ -744,7 +751,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_queue,
> 	TP_ARGS(q, bio),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
> @@ -769,7 +776,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
> 	TP_ARGS(q, bio),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> 		ctf_integer(sector_t, sector, bio->bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
> 		blk_rwbs_ctf_integer(unsigned int, rwbs,
> @@ -831,7 +838,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
> 	TP_ARGS(q, bio, rw),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio ? bio->bi_bdev->bd_dev : 0)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0)
> 		ctf_integer(unsigned int, nr_sector,
> @@ -992,7 +999,7 @@ LTTNG_TRACEPOINT_EVENT(block_split,
> 	TP_ARGS(q, bio, new_sector),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		blk_rwbs_ctf_integer(unsigned int, rwbs,
> @@ -1031,7 +1038,7 @@ LTTNG_TRACEPOINT_EVENT(block_remap,
> 	TP_ARGS(q, bio, dev, from),
> 
> 	TP_FIELDS(
> -		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
> +		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
> #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
> 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
> 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
> --
> 2.7.4

-- 
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
_______________________________________________
lttng-dev mailing list
lttng-dev@lists.lttng.org
https://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev

[PATCH lttng-modules 1/3] Fix: update block instrumentation for kernel 4.14

[Michael Jeanson]

See upstream commit:

  commit 74d46992e0d9dee7f1f376de0d56d31614c8a17a
  Author: Christoph Hellwig <hch@lst.de>
  Date:   Wed Aug 23 19:10:32 2017 +0200

    block: replace bi_bdev with a gendisk pointer and partitions index

    This way we don't need a block_device structure to submit I/O.  The
    block_device has different life time rules from the gendisk and
    request_queue and is usually only available when the block device node
    is open.  Other callers need to explicitly create one (e.g. the lightnvm
    passthrough code, or the new nvme multipathing code).

    For the actual I/O path all that we need is the gendisk, which exists
    once per block device.  But given that the block layer also does
    partition remapping we additionally need a partition index, which is
    used for said remapping in generic_make_request.

    Note that all the block drivers generally want request_queue or
    sometimes the gendisk, so this removes a layer of indirection all
    over the stack.

Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
---
 instrumentation/events/lttng-module/block.h | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/instrumentation/events/lttng-module/block.h b/instrumentation/events/lttng-module/block.h
index c43d747..80ea25c 100644
--- a/instrumentation/events/lttng-module/block.h
+++ b/instrumentation/events/lttng-module/block.h
@@ -33,6 +33,13 @@ enum {
 
 #endif /* _TRACE_BLOCK_DEF_ */
 
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#define lttng_bio_dev(bio) bio_dev(bio)
+#else
+#define lttng_bio_dev(bio) ((bio)->bi_bdev ? (bio)->bi_bdev->bd_dev : 0)
+#endif
+
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 
 #define lttng_req_op(rq)	req_op(rq)
@@ -611,7 +618,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
 	TP_ARGS(q, bio),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
@@ -652,7 +659,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_complete,
 #endif
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
@@ -682,7 +689,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
 	TP_ARGS(q, rq, bio),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
@@ -744,7 +751,7 @@ LTTNG_TRACEPOINT_EVENT(block_bio_queue,
 	TP_ARGS(q, bio),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
@@ -769,7 +776,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
 	TP_ARGS(q, bio),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev ? bio->bi_bdev->bd_dev : 0)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 		ctf_integer(sector_t, sector, bio->bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio->bi_size >> 9)
 		blk_rwbs_ctf_integer(unsigned int, rwbs,
@@ -831,7 +838,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
 	TP_ARGS(q, bio, rw),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio ? bio->bi_bdev->bd_dev : 0)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0)
 		ctf_integer(unsigned int, nr_sector,
@@ -992,7 +999,7 @@ LTTNG_TRACEPOINT_EVENT(block_split,
 	TP_ARGS(q, bio, new_sector),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		blk_rwbs_ctf_integer(unsigned int, rwbs,
@@ -1031,7 +1038,7 @@ LTTNG_TRACEPOINT_EVENT(block_remap,
 	TP_ARGS(q, bio, dev, from),
 
 	TP_FIELDS(
-		ctf_integer(dev_t, dev, bio->bi_bdev->bd_dev)
+		ctf_integer(dev_t, dev, lttng_bio_dev(bio))
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
 		ctf_integer(sector_t, sector, bio->bi_iter.bi_sector)
 		ctf_integer(unsigned int, nr_sector, bio_sectors(bio))
-- 
2.7.4

_______________________________________________
lttng-dev mailing list
lttng-dev@lists.lttng.org
https://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev