Btrfs: add tracepoints for flush events

We want to track when we're triggering flushing from our reservation code and
what flushing is being done when we start flushing.  Thanks,

Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 2e04c9d6f21d08a61c3b840f4a82424cb6b8275a..83a6a931af09b96ad998a797378a9d43b7da6ba7 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2626,6 +2626,15 @@ enum btrfs_reserve_flush_enum {
        BTRFS_RESERVE_FLUSH_ALL,
 };
 
+enum btrfs_flush_state {
+       FLUSH_DELAYED_ITEMS_NR  =       1,
+       FLUSH_DELAYED_ITEMS     =       2,
+       FLUSH_DELALLOC          =       3,
+       FLUSH_DELALLOC_WAIT     =       4,
+       ALLOC_CHUNK             =       5,
+       COMMIT_TRANS            =       6,
+};
+
 int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);
 int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes);
 void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 5d24ec44d99b3d69c83d79fed6280d1e334dab8b..31ded6aae1f098d7ca8963d182d1f42547555a22 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -4835,15 +4835,6 @@ commit:
        return btrfs_commit_transaction(trans, root);
 }
 
-enum flush_state {
-       FLUSH_DELAYED_ITEMS_NR  =       1,
-       FLUSH_DELAYED_ITEMS     =       2,
-       FLUSH_DELALLOC          =       3,
-       FLUSH_DELALLOC_WAIT     =       4,
-       ALLOC_CHUNK             =       5,
-       COMMIT_TRANS            =       6,
-};
-
 struct reserve_ticket {
        u64 bytes;
        int error;
@@ -4901,6 +4892,8 @@ static int flush_space(struct btrfs_root *root,
                break;
        }
 
+       trace_btrfs_flush_space(root->fs_info, space_info->flags, num_bytes,
+                               orig_bytes, state, ret);
        return ret;
 }
 
@@ -5178,6 +5171,10 @@ static int __reserve_metadata_bytes(struct btrfs_root *root,
                        list_add_tail(&ticket.list, &space_info->tickets);
                        if (!space_info->flush) {
                                space_info->flush = 1;
+                               trace_btrfs_trigger_flush(root->fs_info,
+                                                         space_info->flags,
+                                                         orig_bytes, flush,
+                                                         "enospc");
                                queue_work(system_unbound_wq,
                                           &root->fs_info->async_reclaim_work);
                        }
@@ -5194,9 +5191,14 @@ static int __reserve_metadata_bytes(struct btrfs_root *root,
                 */
                if (!root->fs_info->log_root_recovering &&
                    need_do_async_reclaim(space_info, root->fs_info, used) &&
-                   !work_busy(&root->fs_info->async_reclaim_work))
+                   !work_busy(&root->fs_info->async_reclaim_work)) {
+                       trace_btrfs_trigger_flush(root->fs_info,
+                                                 space_info->flags,
+                                                 orig_bytes, flush,
+                                                 "preempt");
                        queue_work(system_unbound_wq,
                                   &root->fs_info->async_reclaim_work);
+               }
        }
        spin_unlock(&space_info->lock);
        if (!ret || flush == BTRFS_RESERVE_NO_FLUSH)

diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 985e01b6c849d7459ddda406205093103ebaafe2..226c7f283247d28b69219b6d600df88f90b367ce 100644 (file)
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -784,6 +784,88 @@ TRACE_EVENT(btrfs_space_reservation,
                  __entry->bytes)
 );
 
+#define show_flush_action(action)                                              \
+       __print_symbolic(action,                                                \
+               { BTRFS_RESERVE_NO_FLUSH,       "BTRFS_RESERVE_NO_FLUSH"},      \
+               { BTRFS_RESERVE_FLUSH_LIMIT,    "BTRFS_RESERVE_FLUSH_LIMIT"},   \
+               { BTRFS_RESERVE_FLUSH_ALL,      "BTRFS_RESERVE_FLUSH_ALL"})
+
+TRACE_EVENT(btrfs_trigger_flush,
+
+       TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
+                int flush, char *reason),
+
+       TP_ARGS(fs_info, flags, bytes, flush, reason),
+
+       TP_STRUCT__entry(
+               __array(        u8,     fsid,   BTRFS_UUID_SIZE )
+               __field(        u64,    flags                   )
+               __field(        u64,    bytes                   )
+               __field(        int,    flush                   )
+               __string(       reason, reason                  )
+       ),
+
+       TP_fast_assign(
+               memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
+               __entry->flags  = flags;
+               __entry->bytes  = bytes;
+               __entry->flush  = flush;
+               __assign_str(reason, reason)
+       ),
+
+       TP_printk("%pU: %s: flush = %d(%s), flags = %llu(%s), bytes = %llu",
+                 __entry->fsid, __get_str(reason), __entry->flush,
+                 show_flush_action(__entry->flush),
+                 (unsigned long long)__entry->flags,
+                 __print_flags((unsigned long)__entry->flags, "|",
+                               BTRFS_GROUP_FLAGS),
+                 (unsigned long long)__entry->bytes)
+);
+
+#define show_flush_state(state)                                                        \
+       __print_symbolic(state,                                                 \
+               { FLUSH_DELAYED_ITEMS_NR,       "FLUSH_DELAYED_ITEMS_NR"},      \
+               { FLUSH_DELAYED_ITEMS,          "FLUSH_DELAYED_ITEMS"},         \
+               { FLUSH_DELALLOC,               "FLUSH_DELALLOC"},              \
+               { FLUSH_DELALLOC_WAIT,          "FLUSH_DELALLOC_WAIT"},         \
+               { ALLOC_CHUNK,                  "ALLOC_CHUNK"},                 \
+               { COMMIT_TRANS,                 "COMMIT_TRANS"})
+
+TRACE_EVENT(btrfs_flush_space,
+
+       TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,
+                u64 orig_bytes, int state, int ret),
+
+       TP_ARGS(fs_info, flags, num_bytes, orig_bytes, state, ret),
+
+       TP_STRUCT__entry(
+               __array(        u8,     fsid,   BTRFS_UUID_SIZE )
+               __field(        u64,    flags                   )
+               __field(        u64,    num_bytes               )
+               __field(        u64,    orig_bytes              )
+               __field(        int,    state                   )
+               __field(        int,    ret                     )
+       ),
+
+       TP_fast_assign(
+               memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
+               __entry->flags          =       flags;
+               __entry->num_bytes      =       num_bytes;
+               __entry->orig_bytes     =       orig_bytes;
+               __entry->state          =       state;
+               __entry->ret            =       ret;
+       ),
+
+       TP_printk("%pU: state = %d(%s), flags = %llu(%s), num_bytes = %llu, "
+                 "orig_bytes = %llu, ret = %d", __entry->fsid, __entry->state,
+                 show_flush_state(__entry->state),
+                 (unsigned long long)__entry->flags,
+                 __print_flags((unsigned long)__entry->flags, "|",
+                               BTRFS_GROUP_FLAGS),
+                 (unsigned long long)__entry->num_bytes,
+                 (unsigned long long)__entry->orig_bytes, __entry->ret)
+);
+
 DECLARE_EVENT_CLASS(btrfs__reserved_extent,
 
        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),