Skip to contentSkip to conversation

kasan: unpoison use memset to init unaligned object size

PATCH In review [email protected] 3 participants 4 messages Jun 21, 2021 – Jun 23, 2021

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 kasan: unpoison use memset to init unaligned object size

From: Yee Lee <[email protected]>

This patch adds a memset to initialize object of unaligned size. Duing to the MTE granulrity, the integrated initialization using hwtag instruction will force clearing out bytes in granular size, which may cause undesired effect, such as overwriting to the redzone of SLUB debug. In this patch, for the unaligned object size, function uses memset to initailize context instead of the hwtag instruction.

---
 mm/kasan/kasan.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/kasan/kasan.h +4 -1
index 8f450bc28045..d8faa64614b7 100644
@@ -387,8 +387,11 @@ static inline void kasan_unpoison(const void *addr, size_t size, bool init)
 
 	if (WARN_ON((unsigned long)addr & KASAN_GRANULE_MASK))
 		return;
+	if (init && ((unsigned long)size & KASAN_GRANULE_MASK)) {
+		init = false;
+		memset((void *)addr, 0, size);
+	}
 	size = round_up(size, KASAN_GRANULE_SIZE);
-
 	hw_set_mem_tag_range((void *)addr, size, tag, init);
 }
 
Signature · 1 line
2.18.0
#1 lore raw
Quoted 4 lines · On Mon, 21 Jun 2021 at 17:45, <[email protected]> wrote:

From: Yee Lee <[email protected]>

This patch adds a memset to initialize object of unaligned size.

s/This patch adds/Add/

Quoted 1 line

Duing to the MTE granulrity, the integrated initialization using

s/Duing/Doing/
s/granulrity/granularity/

Quoted 3 lines

hwtag instruction will force clearing out bytes in granular size, which may cause undesired effect, such as overwriting to the redzone of SLUB debug. In this patch, for the unaligned object size, function

Did you encounter a crash due to this? Was it only SLUB debug that caused the problem?

Do you have data on what the percentage of allocations are that would now be treated differently? E.g. what's the percentage of such odd-sized allocations during a normal boot with SLUB debug off?

We need to know if this change would pessimize a non-debug kernel, and if so, we'd have to make the below behave differently.

Quoted 1 line

uses memset to initailize context instead of the hwtag instruction.

s/initailize/initialize/

Quoted 10 lines
---
 mm/kasan/kasan.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/kasan/kasan.h +0 -0
index 8f450bc28045..d8faa64614b7 100644

mm/kasan/kasan.h static inline void kasan_unpoison(const void *addr, size_t size, bool init) · line 392

Quoted 6 lines
mm/kasan/kasan.h +3 -0
@@ -387,8 +387,11 @@ static inline void kasan_unpoison(const void *addr, size_t size, bool init)
 
        if (WARN_ON((unsigned long)addr & KASAN_GRANULE_MASK))
                return;
+       if (init && ((unsigned long)size & KASAN_GRANULE_MASK)) {
+               init = false;
+               memset((void *)addr, 0, size);

Should use memzero_explicit().

mm/kasan/kasan.h static inline void kasan_unpoison(const void *addr, size_t size, bool init) · line 391

Quoted 3 lines
mm/kasan/kasan.h +1 -1
+       }
        size = round_up(size, KASAN_GRANULE_SIZE);
-

Remove whitespace change.

mm/kasan/kasan.h static inline void kasan_unpoison(const void *addr, size_t size, bool init) · line 396

Quoted 2 lines
mm/kasan/kasan.h +0 -0
        hw_set_mem_tag_range((void *)addr, size, tag, init);
 }

Thanks,
-- Marco

#2 lore raw
In reply to [email protected]
Quoted 20 lines · On Mon, Jun 21, 2021 at 6:45 PM <[email protected]> wrote:

From: Yee Lee <[email protected]>

This patch adds a memset to initialize object of unaligned size. Duing to the MTE granulrity, the integrated initialization using hwtag instruction will force clearing out bytes in granular size, which may cause undesired effect, such as overwriting to the redzone of SLUB debug. In this patch, for the unaligned object size, function uses memset to initailize context instead of the hwtag instruction.

---
 mm/kasan/kasan.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/kasan/kasan.h +0 -0
index 8f450bc28045..d8faa64614b7 100644

mm/kasan/kasan.h static inline void kasan_unpoison(const void *addr, size_t size, bool init) · line 393

Quoted 7 lines
mm/kasan/kasan.h +4 -0
@@ -387,8 +387,11 @@ static inline void kasan_unpoison(const void *addr, size_t size, bool init)
 
        if (WARN_ON((unsigned long)addr & KASAN_GRANULE_MASK))
                return;
+       if (init && ((unsigned long)size & KASAN_GRANULE_MASK)) {
+               init = false;
+               memset((void *)addr, 0, size);
+       }

With this implementation, we loose the benefit of setting tags and initializing memory with the same instructions.

Perhaps a better implementation would be to call hw_set_mem_tag_range() with the size rounded down, and then separately deal with the leftover memory.

Quoted 8 lines
mm/kasan/kasan.h +0 -2
        size = round_up(size, KASAN_GRANULE_SIZE);
-
        hw_set_mem_tag_range((void *)addr, size, tag, init);
 }
 
--

2.18.0

author
#3 lore raw
Quoted 35 lines · Andrey Konovalov
Quoted 22 lines · On Mon, Jun 21, 2021 at 6:45 PM <[email protected]> wrote:

From: Yee Lee <[email protected]>

This patch adds a memset to initialize object of unaligned size. Duing to the MTE granulrity, the integrated initialization using hwtag instruction will force clearing out bytes in granular size, which may cause undesired effect, such as overwriting to the redzone
of SLUB debug. In this patch, for the unaligned object size, function
uses memset to initailize context instead of the hwtag instruction.

---
 mm/kasan/kasan.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/kasan/kasan.h +0 -0
index 8f450bc28045..d8faa64614b7 100644

mm/kasan/kasan.h static inline void kasan_unpoison(const void · line 394

Quoted 8 lines
mm/kasan/kasan.h +4 -0
@@ -387,8 +387,11 @@ static inline void kasan_unpoison(const void
 *addr, size_t size, bool init)
 
        if (WARN_ON((unsigned long)addr & KASAN_GRANULE_MASK))
                return;
+       if (init && ((unsigned long)size & KASAN_GRANULE_MASK)) {
+               init = false;
+               memset((void *)addr, 0, size);
+       }

With this implementation, we loose the benefit of setting tags and initializing memory with the same instructions.

Quoted 4 lines

Perhaps a better implementation would be to call hw_set_mem_tag_range() with the size rounded down, and then separately
deal with the leftover memory.

Yes, this fully takes the advantage of hw instruction. However, the leftover memory needs one more hw_set_mem_tag_range() for protection as well.

If the extra path is only executed as CONFIG_SLUB_DEBUG, the performance lost would be less concerned.

Quoted 9 lines
Quoted 9 lines
mm/kasan/kasan.h +0 -2
        size = round_up(size, KASAN_GRANULE_SIZE);
-
        hw_set_mem_tag_range((void *)addr, size, tag, init);
 }
 
--

2.18.0