six locks: Improve six_lock_count

six_lock_count now counts up whether a write lock held, and this patch
now also correctly counts six_lock->intent_lock_recurse.

Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>

4 files changed, 20 insertions, 13 deletions

diff --git a/fs/bcachefs/btree_locking.c b/fs/bcachefs/btree_locking.c
index 69e20140f91f..962f40c0b192 100644
--- a/fs/bcachefs/btree_locking.c
+++ b/fs/bcachefs/btree_locking.c
@@ -22,15 +22,19 @@ struct six_lock_count bch2_btree_node_lock_counts(struct btree_trans *trans,
 						  unsigned level)
 {
 	struct btree_path *path;
-	struct six_lock_count ret = { 0, 0 };
+	struct six_lock_count ret;
+
+	memset(&ret, 0, sizeof(ret));
 
 	if (IS_ERR_OR_NULL(b))
 		return ret;
 
 	trans_for_each_path(trans, path)
 		if (path != skip && path->l[level].b == b) {
-			ret.read += btree_node_read_locked(path, level);
-			ret.intent += btree_node_intent_locked(path, level);
+			int t = btree_node_locked_type(path, level);
+
+			if (t != BTREE_NODE_UNLOCKED)
+				ret.n[t]++;
 		}
 
 	return ret;
@@ -48,7 +52,7 @@ void bch2_btree_node_unlock_write(struct btree_trans *trans,
 
 void __bch2_btree_node_lock_write(struct btree_trans *trans, struct btree *b)
 {
-	int readers = bch2_btree_node_lock_counts(trans, NULL, b, b->c.level).read;
+	int readers = bch2_btree_node_lock_counts(trans, NULL, b, b->c.level).n[SIX_LOCK_read];
 
 	/*
 	 * Must drop our read locks before calling six_lock_write() -
diff --git a/include/linux/six.h b/include/linux/six.h
index 41ddf63b7470..52e668cb7be9 100644
--- a/include/linux/six.h
+++ b/include/linux/six.h
@@ -201,8 +201,7 @@ void six_lock_pcpu_free(struct six_lock *);
 void six_lock_pcpu_alloc(struct six_lock *);
 
 struct six_lock_count {
-	unsigned read;
-	unsigned intent;
+	unsigned n[3];
 };
 
 struct six_lock_count six_lock_counts(struct six_lock *);
diff --git a/include/trace/events/bcachefs.h b/include/trace/events/bcachefs.h
index 32ea634f02a0..deaca44e7378 100644
--- a/include/trace/events/bcachefs.h
+++ b/include/trace/events/bcachefs.h
@@ -453,11 +453,11 @@ TRACE_EVENT(btree_node_upgrade_fail,
 		__entry->locked			= btree_node_locked(path, level);
 
 		c = bch2_btree_node_lock_counts(trans, NULL, path->l[level].b, level),
-		__entry->self_read_count	= c.read;
-		__entry->self_intent_count	= c.intent;
+		__entry->self_read_count	= c.n[SIX_LOCK_read];
+		__entry->self_intent_count	= c.n[SIX_LOCK_intent];
 		c = six_lock_counts(&path->l[level].b->c.lock);
-		__entry->read_count		= c.read;
-		__entry->intent_count		= c.intent;
+		__entry->read_count		= c.n[SIX_LOCK_read];
+		__entry->intent_count		= c.n[SIX_LOCK_read];
 	),
 
 	TP_printk("%s %pS btree %s pos %llu:%llu:%u, locked %u held %u:%u lock count %u:%u",
diff --git a/kernel/locking/six.c b/kernel/locking/six.c
index 5b2d92c6e91c..4350ed408fe9 100644
--- a/kernel/locking/six.c
+++ b/kernel/locking/six.c
@@ -763,15 +763,19 @@ EXPORT_SYMBOL_GPL(six_lock_pcpu_alloc);
  */
 struct six_lock_count six_lock_counts(struct six_lock *lock)
 {
-	struct six_lock_count ret = { 0, lock->state.intent_lock };
+	struct six_lock_count ret;
+
+	ret.n[SIX_LOCK_read]	= 0;
+	ret.n[SIX_LOCK_intent]	= lock->state.intent_lock + lock->intent_lock_recurse;
+	ret.n[SIX_LOCK_write]	= lock->state.seq & 1;
 
 	if (!lock->readers)
-		ret.read += lock->state.read_lock;
+		ret.n[SIX_LOCK_read] += lock->state.read_lock;
 	else {
 		int cpu;
 
 		for_each_possible_cpu(cpu)
-			ret.read += *per_cpu_ptr(lock->readers, cpu);
+			ret.n[SIX_LOCK_read] += *per_cpu_ptr(lock->readers, cpu);
 	}
 
 	return ret;