For btrfs tree locking, there are only 2 functions can sleep:
- btrfs_tree_read_lock()
It will wait for any blocking writers
- btrfs_tree_lock()
It will wait for any blocking readers or writers
Other functions only depends on rwlock which won't sleep.
We doesn't really care about the spinning lock version.
The overheads introduced are:
- two ktime_get() calls
- several if branches
- percpu_counter_add()
Which should be smaller than to ftrace function_graph.
Signed-off-by: Qu Wenruo <w...@suse.com>
---
fs/btrfs/locking.c | 11 +++++++++++
fs/btrfs/perf.c | 20 ++++++++++++++++++++
fs/btrfs/perf.h | 8 ++++++++
3 files changed, 39 insertions(+)
diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index 1da768e5ef75..c23c8f7450e8 100644
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -11,6 +11,7 @@
#include "ctree.h"
#include "extent_io.h"
#include "locking.h"
+#include "perf.h"
static void btrfs_assert_tree_read_locked(struct extent_buffer *eb);
@@ -85,10 +86,14 @@ void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb,
int rw)
*/
void btrfs_tree_read_lock(struct extent_buffer *eb)
{
+ u64 start_ns;
+
+ start_ns = btrfs_perf_start();
again:
BUG_ON(!atomic_read(&eb->blocking_writers) &&
current->pid == eb->lock_owner);
+
read_lock(&eb->lock);
if (atomic_read(&eb->blocking_writers) &&
current->pid == eb->lock_owner) {
@@ -101,16 +106,19 @@ void btrfs_tree_read_lock(struct extent_buffer *eb)
BUG_ON(eb->lock_nested);
eb->lock_nested = 1;
read_unlock(&eb->lock);
+ btrfs_perf_end(eb->fs_info, btrfs_header_owner(eb), start_ns);
return;
}
if (atomic_read(&eb->blocking_writers)) {
read_unlock(&eb->lock);
+
wait_event(eb->write_lock_wq,
atomic_read(&eb->blocking_writers) == 0);
goto again;
}
atomic_inc(&eb->read_locks);
atomic_inc(&eb->spinning_readers);
+ btrfs_perf_end(eb->fs_info, btrfs_header_owner(eb), start_ns);
}
/*
@@ -227,7 +235,9 @@ void btrfs_tree_read_unlock_blocking(struct extent_buffer
*eb)
*/
void btrfs_tree_lock(struct extent_buffer *eb)
{
+ u64 start_ns;
WARN_ON(eb->lock_owner == current->pid);
+ start_ns = btrfs_perf_start();
again:
wait_event(eb->read_lock_wq, atomic_read(&eb->blocking_readers) == 0);
wait_event(eb->write_lock_wq, atomic_read(&eb->blocking_writers) == 0);
@@ -248,6 +258,7 @@ void btrfs_tree_lock(struct extent_buffer *eb)
atomic_inc(&eb->spinning_writers);
atomic_inc(&eb->write_locks);
eb->lock_owner = current->pid;
+ btrfs_perf_end(eb->fs_info, btrfs_header_owner(eb), start_ns);
}
/*
diff --git a/fs/btrfs/perf.c b/fs/btrfs/perf.c
index 2880111f3b0c..893bfad8e6d3 100644
--- a/fs/btrfs/perf.c
+++ b/fs/btrfs/perf.c
@@ -50,3 +50,23 @@ void btrfs_perf_free_profiler(struct btrfs_fs_info *fs_info)
kfree(profiler);
}
+void btrfs_perf_end(struct btrfs_fs_info *fs_info, u64 eb_owner, u64 start_ns)
+{
+ struct btrfs_perf_profiler *profiler = fs_info->profiler;
+ u64 end_ns;
+ int i;
+
+ if (!profiler)
+ return;
+
+ end_ns = ktime_get_ns();
+ if (eb_owner == BTRFS_ROOT_TREE_OBJECTID)
+ i = BTRFS_PERF_TREE_LOCK_ROOT;
+ else if (is_fstree(eb_owner))
+ i = BTRFS_PERF_TREE_LOCK_FS;
+ else if (eb_owner == BTRFS_EXTENT_TREE_OBJECTID)
+ i = BTRFS_PERF_TREE_LOCK_EXTENT;
+ else
+ i = BTRFS_PERF_TREE_LOCK_OTHER;
+ percpu_counter_add(&profiler->perf_counters[i], end_ns - start_ns);
+}
diff --git a/fs/btrfs/perf.h b/fs/btrfs/perf.h
index 9dbea6458d86..7cf4b8c9a0ad 100644
--- a/fs/btrfs/perf.h
+++ b/fs/btrfs/perf.h
@@ -24,4 +24,12 @@ struct btrfs_perf_profiler {
struct btrfs_perf_profiler *btrfs_perf_alloc_profiler(void);
void btrfs_perf_free_profiler(struct btrfs_fs_info *fs_info);
+void btrfs_perf_update_lock(struct btrfs_fs_info *fs_info,
+ u64 eb_owner, u64 ns_diff);
+static inline u64 btrfs_perf_start(void)
+{
+ return ktime_get_ns();
+}
+
+void btrfs_perf_end(struct btrfs_fs_info *fs_info, u64 eb_owner, u64 start_ns);
#endif
--
2.21.0
