mm/kmemleak: Simplify kmemleak_cond_resched() & fix UAF
Subsystems (2)
v2 cover mm/kmemleak: Simplify kmemleak_cond_resched() & fix UAF
It was found that a KASAN use-after-free error was reported in the kmemleak_scan() function. After further examination, it is believe that even though a reference is taken from the current object, it does not prevent the object pointed to by the next pointer from going away after a cond_resched().
To fix that, additional flags are added to make sure that the current object won't be removed from the object_list during the duration of the cond_resched() to ensure the validity of the next pointer.
While making the change, I also simplify the current usage of kmemleak_cond_resched() to make it easier to understand.
Waiman Long (2):
mm/kmemleak: Simplify kmemleak_cond_resched() usage mm/kmemleak: Fix UAF bug in kmemleak_scan()
[v2: Update patch 2 to prevent object_list removal of current object]
mm/kmemleak.c | 83 +++++++++++++++++++++++++-------------------------- 1 file changed, 41 insertions(+), 42 deletions(-)
Signature · 1 line
2.31.1
PATCH v2 1/2 mm/kmemleak: Simplify kmemleak_cond_resched() usage
The presence of a pinned argument and the 64k loop count make kmemleak_cond_resched() a bit more complex to read. The pinned argument is used only by first kmemleak_scan() loop.
Simplify the usage of kmemleak_cond_resched() by removing the pinned argument and always do a get_object()/put_object() sequence. In addition, the 64k loop is removed by using need_resched() to decide if kmemleak_cond_resched() should be called.
--- mm/kmemleak.c | 48 ++++++++++++------------------------------------ 1 file changed, 12 insertions(+), 36 deletions(-)
mm/kmemleak.c +12 -36
@@ -1463,22 +1463,17 @@ static void scan_gray_list(void)/* * Conditionally call resched() in an object iteration loop while making sure * that the given object won't go away without RCU read lock by performing a -* get_object() if !pinned. -* -* Return: false if can't do a cond_resched() due to get_object() failure -* true otherwise +* get_object() if necessaary. */ -static bool kmemleak_cond_resched (struct kmemleak_object *object,bool pinned) +static void kmemleak_cond_resched (struct kmemleak_object *object) { -if (!pinned && !get_object (object)) -return false; +if (!get_object (object)) +return ;/* Try next object */ rcu_read_unlock ();cond_resched ();rcu_read_lock (); -if (!pinned) -put_object (object); -return true; +put_object (object); }/*
@@ -1492,15 +1487,12 @@ static void kmemleak_scan(void)struct zone *zone;int __maybe_unused i;int new_leaks =0 ; -int loop_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 obj_pinned = false; -raw_spin_lock_irq (&object->lock);#ifdef DEBUG /*
@@ -1526,19 +1518,13 @@ static void kmemleak_scan(void)/* 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); - obj_pinned = true; - }raw_spin_unlock_irq (&object->lock); -/* -* Do a cond_resched() every 64k objects to avoid soft lockup. -*/ -if (!(++loop_cnt &0xffff ) && - !kmemleak_cond_resched (object, obj_pinned)) - loop_cnt--;/* Try again on next object */ +if (need_resched ()) +kmemleak_cond_resched (object); }rcu_read_unlock ();
@@ -1605,14 +1591,9 @@ static void kmemleak_scan(void)* scan and color them gray until the next scan. */ rcu_read_lock (); - loop_cnt =0 ;list_for_each_entry_rcu (object, &object_list, object_list) { -/* -* Do a cond_resched() every 64k objects to avoid soft lockup. -*/ -if (!(++loop_cnt &0xffff ) && - !kmemleak_cond_resched (object, false)) - loop_cnt--;/* Try again on next object */ +if (need_resched ()) +kmemleak_cond_resched (object);/* * This is racy but we can save the overhead of lock/unlock
@@ -1647,14 +1628,9 @@ static void kmemleak_scan(void)* Scanning result reporting. */ rcu_read_lock (); - loop_cnt =0 ;list_for_each_entry_rcu (object, &object_list, object_list) { -/* -* Do a cond_resched() every 64k objects to avoid soft lockup. -*/ -if (!(++loop_cnt &0xffff ) && - !kmemleak_cond_resched (object, false)) - loop_cnt--;/* Try again on next object */ +if (need_resched ()) +kmemleak_cond_resched (object);/* * This is racy but we can save the overhead of lock/unlock
Signature · 1 line
2.31.1
PATCH v2 2/2 mm/kmemleak: Fix UAF bug in kmemleak_scan()
In reply to Waiman LongCommit 6edda04ccc7c ("mm/kmemleak: prevent soft lockup in first object iteration loop of kmemleak_scan()") fixes soft lockup problem in kmemleak_scan() by periodically doing a cond_resched(). It does take a reference of the current object before doing it. Unfortunately, if the object has been deleted from the object_list, the next object pointed to by its next pointer may no longer be valid after coming back from cond_resched(). This can result in use-after-free and other nasty problem.
Fix this problem by adding a del_state flag into kmemleak_object structure to synchronize the object deletion process between kmemleak_cond_resched() and __remove_object() to make sure that the object remained in the object_list in the duration of the cond_resched() call.
--- mm/kmemleak.c | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-)
mm/kmemleak.c +29 -6
@@ -13,11 +13,12 @@* * The following locks and mutexes are used by kmemleak: * -* - kmemleak_lock (raw_spinlock_t): protects the object_list modifications and -* accesses to the object_tree_root (or object_phys_tree_root). The -* object_list is the main list holding the metadata (struct kmemleak_object) -* for the allocated memory blocks. The object_tree_root and object_phys_tree_root -* are red black trees used to look-up metadata based on a pointer to the +* - kmemleak_lock (raw_spinlock_t): protects the object_list as well as +* del_state modifications and accesses to the object_tree_root (or +* object_phys_tree_root). The object_list is the main list holding the +* metadata (struct kmemleak_object) for the allocated memory blocks. +* The object_tree_root and object_phys_tree_root are red +* black trees used to look-up metadata based on a pointer to the * corresponding memory block. The object_phys_tree_root is for objects * allocated with physical address. The kmemleak_object structures are * added to the object_list and object_tree_root (or object_phys_tree_root)
@@ -147,6 +148,7 @@ struct kmemleak_object {struct rcu_head rcu;/* object_list lockless traversal */ /* object usage count; object freed when use_count == 0 */ atomic_t use_count; +unsigned int del_state;/* deletion state */ unsigned long pointer;size_t size;/* pass surplus references to this pointer */
@@ -177,6 +179,11 @@ struct kmemleak_object {/* flag set for object allocated with physical address */ #define OBJECT_PHYS (1 << 4) +/* set when __remove_object() called */ +#define DELSTATE_REMOVED (1 << 0) +/* set to temporarily prevent deletion from object_list */ +#define DELSTATE_NO_DELETE (1 << 1) +#define HEX_PREFIX " "/* number of bytes to print per line; must be 16 or 32 */ #define HEX_ROW_SIZE 16
@@ -567,7 +574,9 @@ static void __remove_object(struct kmemleak_object *object)rb_erase (&object->rb_node, object->flags &OBJECT_PHYS ? &object_phys_tree_root : &object_tree_root); -list_del_rcu (&object->object_list); +if (!(object->del_state &DELSTATE_NO_DELETE )) +list_del_rcu (&object->object_list); + object->del_state |=DELSTATE_REMOVED ; }/*
@@ -633,6 +642,7 @@ static void __create_object(unsigned long ptr, size_t size, object->count =0 ;/* white color initially */ object->jiffies = jiffies; object->checksum =0 ; + object->del_state =0 ;/* task information */ if (in_hardirq ()) {
@@ -1470,9 +1480,22 @@ static void kmemleak_cond_resched(struct kmemleak_object *object)if (!get_object (object))return ;/* Try next object */ +raw_spin_lock_irq (&kmemleak_lock); +if (object->del_state &DELSTATE_REMOVED ) + goto unlock_put;/* Object removed */ + object->del_state |=DELSTATE_NO_DELETE ; +raw_spin_unlock_irq (&kmemleak_lock); +rcu_read_unlock ();cond_resched ();rcu_read_lock (); + +raw_spin_lock_irq (&kmemleak_lock); +if (object->del_state &DELSTATE_REMOVED ) +list_del_rcu (&object->object_list); + object->del_state &= ~DELSTATE_NO_DELETE ; +unlock_put: +raw_spin_unlock_irq (&kmemleak_lock);put_object (object); }
Signature · 1 line
2.31.1