Skip to contentSkip to conversation

rcu/kvfree: Add runtime sleep check for single argument

PATCH In review Uladzislau Rezki (Sony) 2 participants 3 messages Dec 6, 2022 RCU

lore
Share & tools
lore

Uladzislau Rezki (Sony)

author maintainer
#0 lore raw

PATCH 1/1 rcu/kvfree: Add runtime sleep check for single argument

A single argument can be invoked only from a sleepable context. There is already a might_sleep() check to mitigate such cases. The problem is that it requires a kernel to be built with a CONFIG_DEBUG_ATOMIC_SLEEP option.

In order to improve an extra runtime_assert_can_sleep() function is introduced by this patch. It is a run-time checking. Please note it only covers PREEMPT kernels.

---
 kernel/rcu/tree.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +16 -1
index d155f2594317..bb798f07e768 100644
@@ -3232,6 +3232,19 @@ add_ptr_to_bulk_krc_lock(struct kfree_rcu_cpu **krcp,
 	return true;
 }
 
+static void
+runtime_assert_can_sleep(void)
+{
+	if (!IS_ENABLED(CONFIG_PREEMPT_COUNT))
+		return;
+
+	if (preemptible())
+		return;
+
+	WARN_ONCE(1, "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
+		in_atomic(), irqs_disabled(), current->pid, current->comm);
+}
+
 /*
  * Queue a request for lazy invocation of the appropriate free routine
  * after a grace period.  Please note that three paths are maintained,
@@ -3257,8 +3270,10 @@ void kvfree_call_rcu(struct rcu_head *head, void *ptr)
 	 * only. For other places please embed an rcu_head to
 	 * your data.
 	 */
-	if (!head)
+	if (!head) {
+		runtime_assert_can_sleep();
 		might_sleep();
+	}
 
 	// Queue the object but don't yet schedule the batch.
 	if (debug_rcu_head_queue(ptr)) {
Signature · 1 line
2.30.2
#1 lore raw

Hello Vlad,

Quoted 11 lines · Uladzislau Rezki (Sony)

A single argument can be invoked only from a sleepable context. There is already a might_sleep() check to mitigate such cases.
The problem is that it requires a kernel to
be built with a CONFIG_DEBUG_ATOMIC_SLEEP option.

In order to improve an extra runtime_assert_can_sleep() function is introduced by this patch. It is a run-time checking. Please note it only covers PREEMPT

I would call it preemptible kernels.

Quoted 1 line

kernels.

Also, It is not clear at all from the commit message about what we are checking and why. Neither is it clear why the might_sleep() is insufficient.

The whole point of doing this is, the purpose of might_sleep() is to check whether we are blocking in an atomic context. That will not help Eric issue which is totally different - we would like to know if we are using an API where we can block instead of an API where we do not need to, by providing additional rcu_head space.

Quoted 11 lines

---
kernel/rcu/tree.c | 17 ++++++++++++++++-

1 file changed, 16 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +0 -0
index d155f2594317..bb798f07e768 100644
@@ -3232,6 +3232,19 @@ add_ptr_to_bulk_krc_lock(struct kfree_rcu_cpu **krcp,
   return true;

kernel/rcu/tree.c add_ptr_to_bulk_krc_lock(struct kfree_rcu_cpu **krcp, · line 3242

Quoted 10 lines
kernel/rcu/tree.c +8 -0
 }
 
+static void
+runtime_assert_can_sleep(void)
+{
+    if (!IS_ENABLED(CONFIG_PREEMPT_COUNT))
+        return;
+
+    if (preemptible())
+        return;

These 2 iffs can be combined into 2-3 lines in this function. No need to add more LOC than needed.

Quoted 9 lines
kernel/rcu/tree.c +5 -0
+
+    WARN_ONCE(1, "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
+        in_atomic(), irqs_disabled(), current->pid, current->comm);
+}
+
 /*
 * Queue a request for lazy invocation of the appropriate free routine
 * after a grace period.  Please note that three paths are maintained,

kernel/rcu/tree.c void kvfree_call_rcu(struct rcu_head *head, void *ptr) · line 3275

Quoted 7 lines
kernel/rcu/tree.c +2 -1
@@ -3257,8 +3270,10 @@ void kvfree_call_rcu(struct rcu_head *head, void *ptr)
    * only. For other places please embed an rcu_head to
    * your data.
    */
-    if (!head)
+    if (!head) {
+        runtime_assert_can_sleep();
       might_sleep();

runtime_assert_preemptible() is a better name with a comment about big comment on top of the new function about false negatives for non-preemptible kernels. Can sleep sounds like might sleep which just adds confusion and does not help code readers.

Also Paul raised a point about using 1-arg API in some sleepable contexts where the caller does not want to introduce new space for the head. Have we confirmed there are not any? If there are, the warning will fire for those, as false-positives.

Cheers,

- Joel

Quoted 7 lines
kernel/rcu/tree.c +1 -0
+    }
 
   // Queue the object but don't yet schedule the batch.
   if (debug_rcu_head_queue(ptr)) {
Signature · 1 line
2.30.2
author maintainer
#2 lore raw
Quoted 35 lines · Joel Fernandes

Hello Vlad,

Quoted 11 lines · Uladzislau Rezki (Sony)

A single argument can be invoked only from a sleepable context. There is already a might_sleep() check to mitigate such cases.
The problem is that it requires a kernel to
be built with a CONFIG_DEBUG_ATOMIC_SLEEP option.

In order to improve an extra runtime_assert_can_sleep() function is introduced by this patch. It is a run-time checking. Please note it only covers PREEMPT

I would call it preemptible kernels.

Quoted 1 line

kernels.

Also, It is not clear at all from the commit message about what we are checking and why. Neither is it clear why the might_sleep() is insufficient.

The whole point of doing this is, the purpose of might_sleep() is to check whether we are blocking in an atomic context. That will not help Eric issue which is totally different - we would like to know if we are using an API where we can block instead of an API where we do not need to, by providing additional rcu_head space.

Quoted 13 lines

---
kernel/rcu/tree.c | 17 ++++++++++++++++-

1 file changed, 16 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +0 -0
index d155f2594317..bb798f07e768 100644
@@ -3232,6 +3232,19 @@ add_ptr_to_bulk_krc_lock(struct kfree_rcu_cpu **krcp,
   return true;
 }
 
Quoted 11 lines

kernel/rcu/tree.c add_ptr_to_bulk_krc_lock(struct kfree_rcu_cpu **krcp, · line 3242

Quoted 8 lines
kernel/rcu/tree.c +8 -0
+static void
+runtime_assert_can_sleep(void)
+{
+    if (!IS_ENABLED(CONFIG_PREEMPT_COUNT))
+        return;
+
+    if (preemptible())
+        return;

These 2 iffs can be combined into 2-3 lines in this function. No need to add more LOC than needed.

It can be.

Quoted 19 lines
Quoted 9 lines
kernel/rcu/tree.c +5 -0
+
+    WARN_ONCE(1, "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
+        in_atomic(), irqs_disabled(), current->pid, current->comm);
+}
+
 /*
 * Queue a request for lazy invocation of the appropriate free routine
 * after a grace period.  Please note that three paths are maintained,

kernel/rcu/tree.c void kvfree_call_rcu(struct rcu_head *head, void *ptr) · line 3275

Quoted 7 lines
kernel/rcu/tree.c +2 -1
@@ -3257,8 +3270,10 @@ void kvfree_call_rcu(struct rcu_head *head, void *ptr)
    * only. For other places please embed an rcu_head to
    * your data.
    */
-    if (!head)
+    if (!head) {
+        runtime_assert_can_sleep();
       might_sleep();

runtime_assert_preemptible() is a better name with a comment about big comment on top of the new function about false negatives for non-preemptible kernels. Can sleep sounds like might sleep which just adds confusion and does not help code readers.

Quoted 2 lines

Also Paul raised a point about using 1-arg API in some sleepable contexts where the caller does not want to introduce new space for the head. Have we confirmed there are not any? If there are, the warning will fire for those, as false-positives.

single argument is only for sleepable contexts. This is a rule.

--
Uladzislau Rezki