kmemleak: Do not enable KMEMCHECK_PARTIAL_OK if DEBUG_KMEMLEAK
Subsystems (5)
Catalin Marinas
maintainerPATCH 1/1 kmemleak: Do not enable KMEMCHECK_PARTIAL_OK if DEBUG_KMEMLEAK
This is a fix for bug #14845 (bugzilla.kernel.org). The update_checksum() function in mm/kmemleak.c calls kmemcheck_is_obj_initialised() before scanning an object. When KMEMCHECK_PARTIAL_OK is enabled, this function returns true. However, the crc32_le() reads smaller intervals (32-bit) for which kmemleak_is_obj_initialised() is may be false leading to a kmemcheck warning.
--- lib/Kconfig.kmemcheck | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
lib/Kconfig.kmemcheck +1 -1
@@ -75,7 +75,7 @@ config KMEMCHECK_SHADOW_COPY_SHIFT config KMEMCHECK_PARTIAL_OK bool "kmemcheck: allow partially uninitialized memory" depends on KMEMCHECK - default y + default y if !DEBUG_KMEMLEAK help This option works around certain GCC optimizations that produce 32-bit reads from 16-bit variables where the upper 16 bits are
Hi Catalin,
Catalin Marinas kirjoitti:
Quoted 22 lines
This is a fix for bug #14845 (bugzilla.kernel.org). The
update_checksum()function inmm/kmemleak.ccallskmemcheck_is_obj_initialised()before scanning an object. WhenKMEMCHECK_PARTIAL_OKis enabled, this function returns true. However, thecrc32_le()reads smaller intervals (32-bit) for whichkmemleak_is_obj_initialised()is may be false leading to a kmemcheck warning.Signed-off-by Catalin Marinas <[email protected]>Cc Andrew Morton <[email protected]>Cc Christian Casteyde <[email protected]>Cc Pekka Enberg <[email protected]>--- lib/Kconfig.kmemcheck | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)lib/Kconfig.kmemcheck +0
-0
lib/Kconfig.kmemcheck config KMEMCHECK_SHADOW_COPY_SHIFT · line 81
Quoted 8 lines
lib/Kconfig.kmemcheck +1
-1@@ -75,7 +75,7 @@ config KMEMCHECK_SHADOW_COPY_SHIFT config KMEMCHECK_PARTIAL_OK bool "kmemcheck: allow partially uninitialized memory" depends on KMEMCHECK - default y + default y if !DEBUG_KMEMLEAK help This option works around certain GCC optimizations that produce 32-bit reads from 16-bit variables where the upper 16 bits are
Disabling KMEMCHECK_PARTIAL_OK can cause other false positives so maybe we should add a new function to kmemcheck for kmemleak that only reads full intervals?
Catalin Marinas
maintainerHi Pekka,
Quoted 11 lines · Pekka Enberg
Catalin Marinas kirjoitti:
Quoted 10 lines
lib/Kconfig.kmemcheck +1
-1@@ -75,7 +75,7 @@ config KMEMCHECK_SHADOW_COPY_SHIFT config KMEMCHECK_PARTIAL_OK bool "kmemcheck: allow partially uninitialized memory" depends on KMEMCHECK - default y + default y if !DEBUG_KMEMLEAK
Quoted 8 lines
lib/Kconfig.kmemcheck config KMEMCHECK_SHADOW_COPY_SHIFT · line 81
Quoted 4 lines
lib/Kconfig.kmemcheck +0
-0help This option works around certain GCC optimizations that produce 32-bit reads from 16-bit variables where the upper 16 bits areDisabling
KMEMCHECK_PARTIAL_OKcan cause other false positives so maybe we should add a new function to kmemcheck for kmemleak that only reads full intervals?
There are two uses of kmemcheck_is_obj_initialized() in kmemleak: (1) before reading a value to check for valid pointer (sizeof long) and (2) before computing a CRC sum.
(1) is fine since it only does this for sizeof(long) before reading the same size. (2) has an issues since kmemleak checks the size of an allocated memory block while crc32 reads individual u32's.
Is there a way in kmemcheck to mark a false positive?
The alternative, assuming that CRC_LE_BITS is 8 (that's what it seems to be defined to), the crc32 computation uses u32 values and something like below should work, though slower (not yet tested):
mm/kmemleak.c +20 -0
@@ -948,6 +948,25 @@ EXPORT_SYMBOL(kmemleak_no_scan);/* * Update an object's checksum and return true if it was modified. */ +#ifdef CONFIG_KMEMCHECK_PARTIAL_OK +static bool update_checksum (struct kmemleak_object *object) +{ +u32 crc =0 ; +unsigned long ptr; + +for (ptr =ALIGN (object->pointer,4 ); + ptr < ((object->pointer + object->size) & ~3 ); ptr +=4 ) { +if (!kmemcheck_is_obj_initialized (ptr,4 )) +continue ; + crc =crc32 (crc, (void *)ptr,4 ); + } + +if (object->checksum == crc) +return false; + object->checksum = crc; +return true; +} +#else /* !CONFIG_KMEMCHECK_PARTIAL_OK */ static bool update_checksum (struct kmemleak_object *object) {u32 old_csum = object->checksum;
@@ -958,6 +977,7 @@ static bool update_checksum(struct kmemleak_object *object) object->checksum =crc32 (0 , (void *)object->pointer, object->size); return object->checksum != old_csum; } +#endif /* CONFIG_KMEMCHECK_PARTIAL_OK */ /* * Memory scanning is a long process and it needs to be interruptable. This
Signature · 1 line
Catalin
Quoted 26 lines · Catalin Marinas
Hi Pekka,
Quoted 10 lines · Pekka Enberg
Catalin Marinas kirjoitti:
Quoted 9 lines
lib/Kconfig.kmemcheck +0
-1@@ -75,7 +75,7 @@ config KMEMCHECK_SHADOW_COPY_SHIFT config KMEMCHECK_PARTIAL_OK bool "kmemcheck: allow partially uninitialized memory" depends on KMEMCHECK - default yQuoted 8 lines
lib/Kconfig.kmemcheck config KMEMCHECK_SHADOW_COPY_SHIFT · line 81
Quoted 5 lines
lib/Kconfig.kmemcheck +1
-0+ default y if !DEBUG_KMEMLEAK help This option works around certain GCC optimizations that produce 32-bit reads from 16-bit variables where the upper 16 bits areDisabling
KMEMCHECK_PARTIAL_OKcan cause other false positives so maybe we should add a new function to kmemcheck for kmemleak that only reads full intervals?There are two uses of
kmemcheck_is_obj_initialized()in kmemleak: (1) before reading a value to check for valid pointer (sizeof long) and (2) before computing a CRC sum.
Quoted 5 lines
(1) is fine since it only does this for sizeof(long) before reading the same size. (2) has an issues since kmemleak checks the size of an allocated memory block while crc32 reads individual u32's.
Is there a way in kmemcheck to mark a false positive?
IIRC, no. The false positives come from the code generated by GCC so we'd need to sprinkle annotations here and there.
Quoted 20 lines
The alternative, assuming that
CRC_LE_BITSis 8 (that's what it seems to be defined to), the crc32 computation uses u32 values and something like below should work, though slower (not yet tested):mm/kmemleak.c +7
-0@@ -948,6 +948,25 @@ EXPORT_SYMBOL(kmemleak_no_scan);/* * Update an object's checksum and return true if it was modified. */ +#ifdef CONFIG_KMEMCHECK_PARTIAL_OK +static bool update_checksum (struct kmemleak_object *object) +{ +u32 crc =0 ; +unsigned long ptr; + + for (ptr = ALIGN(object->pointer, 4);
mm/kmemleak.c EXPORT_SYMBOL(kmemleak_no_scan); · line 967
Quoted 10 lines
mm/kmemleak.c +10
-0+ ptr < ((object->pointer + object->size) & ~3); ptr += 4) { +if (!kmemcheck_is_obj_initialized (ptr,4 )) +continue ; + crc =crc32 (crc, (void *)ptr,4 ); + } + +if (object->checksum == crc) +return false; + object->checksum = crc; +return true;
I think it would be better to add a function to _kmemcheck_ that checks the full object regardless of CONFIG_KMEMCHECK_PARTIAL_OK and use it here.
Quoted 15 lines
mm/kmemleak.c +3
-0+} +#else /* !CONFIG_KMEMCHECK_PARTIAL_OK */ static bool update_checksum (struct kmemleak_object *object) {u32 old_csum = object->checksum;@@ -958,6 +977,7 @@ static bool update_checksum(struct kmemleak_object *object) object->checksum =crc32 (0 , (void *)object->pointer, object->size); return object->checksum != old_csum; } +#endif /* CONFIG_KMEMCHECK_PARTIAL_OK */ /* * Memory scanning is a long process and it needs to be interruptable. This
Catalin Marinas
maintainerQuoted 21 lines · Pekka Enberg
Quoted 20 lines · Catalin Marinas
mm/kmemleak.c +12
-0@@ -948,6 +948,25 @@ EXPORT_SYMBOL(kmemleak_no_scan);/* * Update an object's checksum and return true if it was modified. */ +#ifdef CONFIG_KMEMCHECK_PARTIAL_OK +static bool update_checksum (struct kmemleak_object *object) +{ +u32 crc =0 ; +unsigned long ptr; + +for (ptr =ALIGN (object->pointer,4 ); + ptr < ((object->pointer + object->size) & ~3 ); ptr +=4 ) { +if (!kmemcheck_is_obj_initialized (ptr,4 )) +continue ; + crc =crc32 (crc, (void *)ptr,4 ); + }
Quoted 8 lines
mm/kmemleak.c EXPORT_SYMBOL(kmemleak_no_scan); · line 967
Quoted 5 lines
mm/kmemleak.c +5
-0+ +if (object->checksum == crc) +return false; + object->checksum = crc; +return true;I think it would be better to add a function to _kmemcheck_ that checks the full object regardless of
CONFIG_KMEMCHECK_PARTIAL_OKand use it here.
IIRC, it's only kmemleak using kmemcheck_is_obj_initialized(), we could convert this to check the full object. Something like below (again, not tested yet but if you are ok with the idea I'll test it a bit more and add a commit log):
arch/x86/mm/kmemcheck/kmemcheck.c +1 -1
@@ -337,7 +337,7 @@ bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size)if (!shadow)return true; - status =kmemcheck_shadow_test (shadow, size); + status =kmemcheck_shadow_test_all (shadow, size);return status ==KMEMCHECK_SHADOW_INITIALIZED ; }
arch/x86/mm/kmemcheck/shadow.c +13 -1
@@ -139,13 +139,25 @@ enum kmemcheck_shadow kmemcheck_shadow_test(void *shadow, unsigned int size)if (x[i] ==KMEMCHECK_SHADOW_INITIALIZED ) return x[i]; } + +return x[0 ];#else +return kmemcheck_shadow_test_all (shadow, size); +#endif +} + +enum kmemcheck_shadow kmemcheck_shadow_test_all (void *shadow,unsigned int size) +{ +uint8_t *x; +unsigned int i; + + x = shadow; +/* All bytes must be initialized. */ for (i =0 ; i < size; ++i) {if (x[i] !=KMEMCHECK_SHADOW_INITIALIZED )return x[i]; } -#endif return x[0 ]; }
arch/x86/mm/kmemcheck/shadow.h +2 -0
@@ -11,6 +11,8 @@ enum kmemcheck_shadow {void *kmemcheck_shadow_lookup (unsigned long address);enum kmemcheck_shadow kmemcheck_shadow_test (void *shadow,unsigned int size); +enum kmemcheck_shadow kmemcheck_shadow_test_all (void *shadow, +unsigned int size);void kmemcheck_shadow_set (void *shadow,unsigned int size);#endif
Signature · 1 line
Catalin
Quoted 30 lines · Catalin Marinas
Quoted 20 lines · Pekka Enberg
Quoted 19 lines · Catalin Marinas
mm/kmemleak.c +11
-0@@ -948,6 +948,25 @@ EXPORT_SYMBOL(kmemleak_no_scan);/* * Update an object's checksum and return true if it was modified. */ +#ifdef CONFIG_KMEMCHECK_PARTIAL_OK +static bool update_checksum (struct kmemleak_object *object) +{ +u32 crc =0 ; +unsigned long ptr; + +for (ptr =ALIGN (object->pointer,4 ); + ptr < ((object->pointer + object->size) & ~3 ); ptr +=4 ) { +if (!kmemcheck_is_obj_initialized (ptr,4 )) +continue ; + crc =crc32 (crc, (void *)ptr,4 );Quoted 8 lines
mm/kmemleak.c EXPORT_SYMBOL(kmemleak_no_scan); · line 967
Quoted 6 lines
mm/kmemleak.c +6
-0+ } + +if (object->checksum == crc) +return false; + object->checksum = crc; +return true;I think it would be better to add a function to _kmemcheck_ that checks the full object regardless of
CONFIG_KMEMCHECK_PARTIAL_OKand use it here.
Quoted 4 lines
IIRC, it's only kmemleak using
kmemcheck_is_obj_initialized(), we could convert this to check the full object. Something like below (again, not tested yet but if you are ok with the idea I'll test it a bit more and add a commit log):
Looks good to me!
Quoted 60 lines
arch/x86/mm/kmemcheck/kmemcheck.c +1
-1@@ -337,7 +337,7 @@ bool kmemcheck_is_obj_initialized(unsigned long addr, size_t size)if (!shadow)return true; - status =kmemcheck_shadow_test (shadow, size); + status =kmemcheck_shadow_test_all (shadow, size);return status ==KMEMCHECK_SHADOW_INITIALIZED ; }arch/x86/mm/kmemcheck/shadow.c +13
-1@@ -139,13 +139,25 @@ enum kmemcheck_shadow kmemcheck_shadow_test(void *shadow, unsigned int size)if (x[i] ==KMEMCHECK_SHADOW_INITIALIZED ) return x[i]; } + +return x[0 ];#else +return kmemcheck_shadow_test_all (shadow, size); +#endif +} + +enum kmemcheck_shadow kmemcheck_shadow_test_all (void *shadow,unsigned int size) +{ +uint8_t *x; +unsigned int i; + + x = shadow; +/* All bytes must be initialized. */ for (i =0 ; i < size; ++i) {if (x[i] !=KMEMCHECK_SHADOW_INITIALIZED )return x[i]; } -#endif return x[0 ]; }arch/x86/mm/kmemcheck/shadow.h +2
-0@@ -11,6 +11,8 @@ enum kmemcheck_shadow {void *kmemcheck_shadow_lookup (unsigned long address);enum kmemcheck_shadow kmemcheck_shadow_test (void *shadow,unsigned int size); +enum kmemcheck_shadow kmemcheck_shadow_test_all (void *shadow, +unsigned int size);void kmemcheck_shadow_set (void *shadow,unsigned int size);#endif