The first RCU-based object iteration loop has to put almost all the
objects into the gray list and so cannot skip taking the object lock.
One way to avoid soft lockup is to insert occasional cond_resched()
into the loop. This cannot be done while holding the RCU read lock
which is to protect objects from removal. However, putting an object
into the gray list means getting a reference to the object. That will
prevent the object from removal as well without the need to hold the
RCU read lock. So insert a cond_resched() call after every 64k objects
are put into the gray list.
Signed-off-by: Waiman Long <longman@xxxxxxxxxx>
---
mm/kmemleak.c | 20 +++++++++++++++++++-
1 file changed, 19 insertions(+), 1 deletion(-)
diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index 7dd64139a7c7..a7c42e134fa1 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -1417,12 +1417,15 @@ static void kmemleak_scan(void)
struct zone *zone;
int __maybe_unused i;
int new_leaks = 0;
+ int gray_list_cnt = 0;
jiffies_last_scan = jiffies;
/* prepare the kmemleak_object's */
rcu_read_lock();
list_for_each_entry_rcu(object, &object_list, object_list) {
+ bool object_pinned = false;
+
raw_spin_lock_irq(&object->lock);
#ifdef DEBUG
/*
@@ -1437,10 +1440,25 @@ static void kmemleak_scan(void)
#endif
/* reset the reference count (whiten the object) */
object->count = 0;
- if (color_gray(object) && get_object(object))
+ if (color_gray(object) && get_object(object)) {
list_add_tail(&object->gray_list, &gray_list);
+ gray_list_cnt++;
+ object_pinned = true;
+ }
raw_spin_unlock_irq(&object->lock);
+
+ /*
+ * With object pinned by a positive reference count, it
+ * won't go away and we can safely release the RCU read
+ * lock and do a cond_resched() to avoid soft lockup every
+ * 64k objects.
+ */
+ if (object_pinned && !(gray_list_cnt & 0xffff)) {
+ rcu_read_unlock();
+ cond_resched();
+ rcu_read_lock();
+ }
}
rcu_read_unlock();
--
2.31.1
