* [PATCH] kallsyms: strip LTO suffixes from static functions
@ 2021-06-22 18:38 Nick Desaulniers
2021-06-22 20:18 ` Fangrui Song
0 siblings, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-22 18:38 UTC (permalink / raw)
To: Kees Cook
Cc: Nick Desaulniers, KE . LI, Nathan Chancellor, Andrew Morton,
Stephen Rothwell, Miroslav Benes, Gustavo A. R. Silva,
Stephen Boyd, Sami Tolvanen, Joe Perches, linux-kernel,
clang-built-linux
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
Full LTO uses a different mangling scheme than thin LTO; full LTO
imports all code into effectively one big translation unit. It must
rename static functions to prevent collisions. Strip off these suffixes
so that we can continue to hook such static functions.
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Tested-by: KE.LI(Lieke) <like1@oppo.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
kernel/kallsyms.c | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 4067564ec59f..14cf3a6474de 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -188,6 +188,24 @@ static inline bool cleanup_symbol_name(char *s)
return res != NULL;
}
+#elif defined(CONFIG_LTO_CLANG_FULL)
+/*
+ * LLVM mangles static functions for full LTO so that two static functions with
+ * the same identifier do not collide when all code is combined into one
+ * module. The scheme used converts references to foo into
+ * foo.llvm.974640843467629774, for example. This can break hooking of static
+ * functions with kprobes.
+ */
+static inline bool cleanup_symbol_name(char *s)
+{
+ char *res;
+
+ res = strstr(s, ".llvm.");
+ if (res)
+ *res = '\0';
+
+ return res != NULL;
+}
#else
static inline bool cleanup_symbol_name(char *s) { return false; }
#endif
--
2.32.0.288.g62a8d224e6-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH] kallsyms: strip LTO suffixes from static functions
2021-06-22 18:38 [PATCH] kallsyms: strip LTO suffixes from static functions Nick Desaulniers
@ 2021-06-22 20:18 ` Fangrui Song
2021-06-28 17:54 ` Nick Desaulniers
2021-06-28 19:05 ` [PATCH v2] " Nick Desaulniers
0 siblings, 2 replies; 32+ messages in thread
From: Fangrui Song @ 2021-06-22 20:18 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, KE . LI, Nathan Chancellor, Andrew Morton,
Stephen Rothwell, Miroslav Benes, Gustavo A. R. Silva,
Stephen Boyd, Sami Tolvanen, Joe Perches, linux-kernel,
clang-built-linux
On 2021-06-22, 'Nick Desaulniers' via Clang Built Linux wrote:
>Similar to:
>commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
>functions")
>
>It's very common for compilers to modify the symbol name for static
>functions as part of optimizing transformations. That makes hooking
>static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
>Full LTO uses a different mangling scheme than thin LTO; full LTO
>imports all code into effectively one big translation unit. It must
>rename static functions to prevent collisions. Strip off these suffixes
>so that we can continue to hook such static functions.
See below. The message needs a change.
I can comment on the LTO side thing, but a maintainer needs to check
about the kernel side logic.
Reviewed-by: Fangrui Song <maskray@google.com>
>Reported-by: KE.LI(Lieke) <like1@oppo.com>
>Tested-by: KE.LI(Lieke) <like1@oppo.com>
>Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
>---
> kernel/kallsyms.c | 18 ++++++++++++++++++
> 1 file changed, 18 insertions(+)
>
>diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
>index 4067564ec59f..14cf3a6474de 100644
>--- a/kernel/kallsyms.c
>+++ b/kernel/kallsyms.c
>@@ -188,6 +188,24 @@ static inline bool cleanup_symbol_name(char *s)
>
> return res != NULL;
> }
>+#elif defined(CONFIG_LTO_CLANG_FULL)
>+/*
>+ * LLVM mangles static functions for full LTO so that two static functions with
>+ * the same identifier do not collide when all code is combined into one
>+ * module. The scheme used converts references to foo into
>+ * foo.llvm.974640843467629774, for example. This can break hooking of static
>+ * functions with kprobes.
>+ */
The comment should say ThinLTO instead.
The .llvm.123 suffix is for global scope promotion for local linkage
symbols. The scheme is ThinLTO specific. This ensures that a local
linkage symbol, when imported into multiple translation units, then
compiled into different object files, during linking, the copies can be
deduplicated. This matters for code size and for correctness when the
function address is taken.
Regular LTO (sometimes called full LTO) uses the regular name.\d+
scheme.
>+static inline bool cleanup_symbol_name(char *s)
>+{
>+ char *res;
>+
>+ res = strstr(s, ".llvm.");
>+ if (res)
>+ *res = '\0';
>+
>+ return res != NULL;
>+}
> #else
> static inline bool cleanup_symbol_name(char *s) { return false; }
> #endif
>--
>2.32.0.288.g62a8d224e6-goog
I wonder whether it makes sense to strip all `.something` suffixes.
For example, the recent -funique-internal-linkage-name (which can
improve sample profile accuracy) uses the `.__uniq.1234` scheme.
Function specialization/clones can create arbitrary `.123` suffixes.
>--
>You received this message because you are subscribed to the Google Groups "Clang Built Linux" group.
>To unsubscribe from this group and stop receiving emails from it, send an email to clang-built-linux+unsubscribe@googlegroups.com.
>To view this discussion on the web visit https://groups.google.com/d/msgid/clang-built-linux/20210622183858.2962637-1-ndesaulniers%40google.com.
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH] kallsyms: strip LTO suffixes from static functions
2021-06-22 20:18 ` Fangrui Song
@ 2021-06-28 17:54 ` Nick Desaulniers
2021-06-28 18:20 ` Nick Desaulniers
2021-06-28 19:05 ` [PATCH v2] " Nick Desaulniers
1 sibling, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-28 17:54 UTC (permalink / raw)
To: Fangrui Song
Cc: Kees Cook, KE . LI, Nathan Chancellor, Andrew Morton,
Stephen Rothwell, Miroslav Benes, Gustavo A. R. Silva,
Stephen Boyd, Sami Tolvanen, Joe Perches, linux-kernel,
clang-built-linux
On Tue, Jun 22, 2021 at 1:18 PM Fangrui Song <maskray@google.com> wrote:
>
> On 2021-06-22, 'Nick Desaulniers' via Clang Built Linux wrote:
> >Similar to:
> >commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> >functions")
> >
> >It's very common for compilers to modify the symbol name for static
> >functions as part of optimizing transformations. That makes hooking
> >static functions (that weren't inlined or DCE'd) with kprobes difficult.
> >
> >Full LTO uses a different mangling scheme than thin LTO; full LTO
> >imports all code into effectively one big translation unit. It must
> >rename static functions to prevent collisions. Strip off these suffixes
> >so that we can continue to hook such static functions.
>
> See below. The message needs a change.
>
> I can comment on the LTO side thing, but a maintainer needs to check
> about the kernel side logic.
>
> Reviewed-by: Fangrui Song <maskray@google.com>
>
> >Reported-by: KE.LI(Lieke) <like1@oppo.com>
> >Tested-by: KE.LI(Lieke) <like1@oppo.com>
> >Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> >---
> > kernel/kallsyms.c | 18 ++++++++++++++++++
> > 1 file changed, 18 insertions(+)
> >
> >diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> >index 4067564ec59f..14cf3a6474de 100644
> >--- a/kernel/kallsyms.c
> >+++ b/kernel/kallsyms.c
> >@@ -188,6 +188,24 @@ static inline bool cleanup_symbol_name(char *s)
> >
> > return res != NULL;
> > }
> >+#elif defined(CONFIG_LTO_CLANG_FULL)
> >+/*
> >+ * LLVM mangles static functions for full LTO so that two static functions with
> >+ * the same identifier do not collide when all code is combined into one
> >+ * module. The scheme used converts references to foo into
> >+ * foo.llvm.974640843467629774, for example. This can break hooking of static
> >+ * functions with kprobes.
> >+ */
>
> The comment should say ThinLTO instead.
>
> The .llvm.123 suffix is for global scope promotion for local linkage
> symbols. The scheme is ThinLTO specific. This ensures that a local
Oh, boy. Indeed. I had identified the mangling coming from
getGlobalNameForLocal(), but looking at the call chain now I see:
FunctionImportGlobalProcessing::processGlobalForThinLTO()
-> FunctionImportGlobalProcessing::getPromotedName()
-> ModuleSummaryIndex::getGlobalNameForLocal()
I'm not sure then how I figured it was specific to full LTO.
Android recently switched from thin LTO to full LTO, which is what I
assumed was the cause of the bug report. Rereading our internal bug
report, it was tested against a prior version that did the symbol
truncation for thinLTO. I then assumed this was full LTO specific for
whatever reason, and modified the patch to only apply to full LTO. I
see via the above call chain that this patch is not correct. Let me
send my original patch as a v2. b/189560201 if you're interested.
> linkage symbol, when imported into multiple translation units, then
> compiled into different object files, during linking, the copies can be
> deduplicated. This matters for code size and for correctness when the
> function address is taken.
>
> Regular LTO (sometimes called full LTO) uses the regular name.\d+
> scheme.
>
> >+static inline bool cleanup_symbol_name(char *s)
> >+{
> >+ char *res;
> >+
> >+ res = strstr(s, ".llvm.");
> >+ if (res)
> >+ *res = '\0';
> >+
> >+ return res != NULL;
> >+}
> > #else
> > static inline bool cleanup_symbol_name(char *s) { return false; }
> > #endif
> >--
> >2.32.0.288.g62a8d224e6-goog
>
> I wonder whether it makes sense to strip all `.something` suffixes.
> For example, the recent -funique-internal-linkage-name (which can
> improve sample profile accuracy) uses the `.__uniq.1234` scheme.
>
> Function specialization/clones can create arbitrary `.123` suffixes.
I definitely don't see hooking static functions via kprobes as being
scalable. There are numerous different mangling schemes different
compilers apply to different static functions.
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH] kallsyms: strip LTO suffixes from static functions
2021-06-28 17:54 ` Nick Desaulniers
@ 2021-06-28 18:20 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-28 18:20 UTC (permalink / raw)
To: Fangrui Song
Cc: Kees Cook, KE . LI, Nathan Chancellor, Andrew Morton,
Stephen Rothwell, Miroslav Benes, Gustavo A. R. Silva,
Stephen Boyd, Sami Tolvanen, Joe Perches, linux-kernel,
clang-built-linux
On Mon, Jun 28, 2021 at 10:54 AM Nick Desaulniers
<ndesaulniers@google.com> wrote:
>
> On Tue, Jun 22, 2021 at 1:18 PM Fangrui Song <maskray@google.com> wrote:
> >
> > On 2021-06-22, 'Nick Desaulniers' via Clang Built Linux wrote:
> > >+/*
> > >+ * LLVM mangles static functions for full LTO so that two static functions with
> > >+ * the same identifier do not collide when all code is combined into one
> > >+ * module. The scheme used converts references to foo into
> > >+ * foo.llvm.974640843467629774, for example. This can break hooking of static
> > >+ * functions with kprobes.
> > >+ */
> >
> > The comment should say ThinLTO instead.
> >
> > The .llvm.123 suffix is for global scope promotion for local linkage
> > symbols. The scheme is ThinLTO specific. This ensures that a local
>
> Oh, boy. Indeed. I had identified the mangling coming from
> getGlobalNameForLocal(), but looking at the call chain now I see:
>
> FunctionImportGlobalProcessing::processGlobalForThinLTO()
> -> FunctionImportGlobalProcessing::getPromotedName()
> -> ModuleSummaryIndex::getGlobalNameForLocal()
>
> I'm not sure then how I figured it was specific to full LTO.
>
> Android recently switched from thin LTO to full LTO, which is what I
> assumed was the cause of the bug report. Rereading our internal bug
> report, it was tested against a prior version that did the symbol
> truncation for thinLTO. I then assumed this was full LTO specific for
> whatever reason, and modified the patch to only apply to full LTO. I
> see via the above call chain that this patch is not correct. Let me
> send my original patch as a v2. b/189560201 if you're interested.
I can even see the .llvm.<number> symbol names via `llvm-nm` on
vmlinux for thinLTO builds. No such symbols exist for full LTO.
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v2] kallsyms: strip LTO suffixes from static functions
2021-06-22 20:18 ` Fangrui Song
2021-06-28 17:54 ` Nick Desaulniers
@ 2021-06-28 19:05 ` Nick Desaulniers
2021-06-28 19:45 ` Nathan Chancellor
1 sibling, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-28 19:05 UTC (permalink / raw)
To: Kees Cook
Cc: Fangrui Song, Nick Desaulniers, KE . LI, Nathan Chancellor,
Andrew Morton, Stephen Rothwell, Miroslav Benes, Jessica Yu,
Joe Perches, Gustavo A. R. Silva, Sami Tolvanen, Randy Dunlap,
Stephen Boyd, linux-kernel, clang-built-linux
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO. Strip off
these suffixes so that we can continue to hook such static functions.
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 33 +++++++++++++++++++++++++++++----
1 file changed, 29 insertions(+), 4 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 4067564ec59f..fbce4a1ec700 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -171,14 +171,30 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
+#ifdef CONFIG_LTO_CLANG_THIN
+/*
+ * LLVM appends a suffix for local variables that must be promoted to global
+ * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
+ * can break hooking of static functions with kprobes.
+ */
+static bool cleanup_symbol_name_thinlto(char *s)
+{
+ char *res;
+
+ res = strstr(s, ".llvm.");
+ if (res)
+ *res = '\0';
+
+ return res != NULL;
+}
+#ifdef CONFIG_CFI_CLANG
/*
* LLVM appends a hash to static function names when ThinLTO and CFI are
* both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
* This causes confusion and potentially breaks user space tools, so we
* strip the suffix from expanded symbol names.
*/
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name_thinlto_cfi(char *s)
{
char *res;
@@ -189,8 +205,17 @@ static inline bool cleanup_symbol_name(char *s)
return res != NULL;
}
#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
+static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
+#endif /* CONFIG_CFI_CLANG */
+#else
+static bool cleanup_symbol_name_thinlto(char *s) { return false; }
+#endif /* CONFIG_LTO_CLANG_THIN */
+
+static bool cleanup_symbol_name(char *s)
+{
+ return cleanup_symbol_name_thinlto(s) &&
+ cleanup_symbol_name_thinlto_cfi(s);
+}
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
--
2.32.0.93.g670b81a890-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v2] kallsyms: strip LTO suffixes from static functions
2021-06-28 19:05 ` [PATCH v2] " Nick Desaulniers
@ 2021-06-28 19:45 ` Nathan Chancellor
2021-06-28 20:31 ` [PATCH v3] " Nick Desaulniers
0 siblings, 1 reply; 32+ messages in thread
From: Nathan Chancellor @ 2021-06-28 19:45 UTC (permalink / raw)
To: Nick Desaulniers, Kees Cook
Cc: Fangrui Song, KE . LI, Andrew Morton, Stephen Rothwell,
Miroslav Benes, Jessica Yu, Joe Perches, Gustavo A. R. Silva,
Sami Tolvanen, Randy Dunlap, Stephen Boyd, linux-kernel,
clang-built-linux
On 6/28/2021 12:05 PM, 'Nick Desaulniers' via Clang Built Linux wrote:
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO. Strip off
> these suffixes so that we can continue to hook such static functions.
>
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> ---
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
>
> kernel/kallsyms.c | 33 +++++++++++++++++++++++++++++----
> 1 file changed, 29 insertions(+), 4 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 4067564ec59f..fbce4a1ec700 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -171,14 +171,30 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> +#ifdef CONFIG_LTO_CLANG_THIN
> +/*
> + * LLVM appends a suffix for local variables that must be promoted to global
> + * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
> + * can break hooking of static functions with kprobes.
> + */
> +static bool cleanup_symbol_name_thinlto(char *s)
> +{
> + char *res;
> +
> + res = strstr(s, ".llvm.");
> + if (res)
> + *res = '\0';
> +
> + return res != NULL;
> +}
> +#ifdef CONFIG_CFI_CLANG
> /*
> * LLVM appends a hash to static function names when ThinLTO and CFI are
> * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> * This causes confusion and potentially breaks user space tools, so we
> * strip the suffix from expanded symbol names.
> */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name_thinlto_cfi(char *s)
> {
> char *res;
>
> @@ -189,8 +205,17 @@ static inline bool cleanup_symbol_name(char *s)
> return res != NULL;
> }
> #else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
> +static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
> +#endif /* CONFIG_CFI_CLANG */
> +#else
> +static bool cleanup_symbol_name_thinlto(char *s) { return false; }
> +#endif /* CONFIG_LTO_CLANG_THIN */
> +
> +static bool cleanup_symbol_name(char *s)
> +{
> + return cleanup_symbol_name_thinlto(s) &&
> + cleanup_symbol_name_thinlto_cfi(s);
Won't this be a build error when CONFIG_LTO_CLANG_THIN=n and
CONFIG_CFI_CLANG=n because cleanup_symbol_name_thinlto_cfi() will not be
defined? Should the cleanup_symbol_name_thinlto_cfi() stub be in the
last else block?
Cheers,
Nathan
> +}
>
> /* Lookup the address for this symbol. Returns 0 if not found. */
> unsigned long kallsyms_lookup_name(const char *name)
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v3] kallsyms: strip LTO suffixes from static functions
2021-06-28 19:45 ` Nathan Chancellor
@ 2021-06-28 20:31 ` Nick Desaulniers
2021-06-28 21:19 ` Nathan Chancellor
0 siblings, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-28 20:31 UTC (permalink / raw)
To: Kees Cook
Cc: Fangrui Song, Nick Desaulniers, KE . LI, Nathan Chancellor,
Andrew Morton, Stephen Rothwell, Miguel Ojeda, Joe Perches,
Gustavo A. R. Silva, Randy Dunlap, Sami Tolvanen, Stephen Boyd,
linux-kernel, clang-built-linux
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO. Strip off
these suffixes so that we can continue to hook such static functions.
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v2 -> V3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 32 +++++++++++++++++++++++++++++---
1 file changed, 29 insertions(+), 3 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 4067564ec59f..143c69e7e75d 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -171,6 +171,26 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
+#ifdef CONFIG_LTO_CLANG_THIN
+/*
+ * LLVM appends a suffix for local variables that must be promoted to global
+ * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
+ * can break hooking of static functions with kprobes.
+ */
+static bool cleanup_symbol_name_thinlto(char *s)
+{
+ char *res;
+
+ res = strstr(s, ".llvm.");
+ if (res)
+ *res = '\0';
+
+ return res != NULL;
+}
+#else
+static bool cleanup_symbol_name_thinlto(char *s) { return false; }
+#endif /* CONFIG_LTO_CLANG_THIN */
+
#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
/*
* LLVM appends a hash to static function names when ThinLTO and CFI are
@@ -178,7 +198,7 @@ static unsigned long kallsyms_sym_address(int idx)
* This causes confusion and potentially breaks user space tools, so we
* strip the suffix from expanded symbol names.
*/
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name_thinlto_cfi(char *s)
{
char *res;
@@ -189,8 +209,14 @@ static inline bool cleanup_symbol_name(char *s)
return res != NULL;
}
#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
+static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
+#endif /* CONFIG_CFI_CLANG && CONFIG_LTO_CLANG_THIN */
+
+static bool cleanup_symbol_name(char *s)
+{
+ return cleanup_symbol_name_thinlto(s) &&
+ cleanup_symbol_name_thinlto_cfi(s);
+}
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
--
2.32.0.93.g670b81a890-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v3] kallsyms: strip LTO suffixes from static functions
2021-06-28 20:31 ` [PATCH v3] " Nick Desaulniers
@ 2021-06-28 21:19 ` Nathan Chancellor
2021-06-28 22:01 ` Nick Desaulniers
0 siblings, 1 reply; 32+ messages in thread
From: Nathan Chancellor @ 2021-06-28 21:19 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, Fangrui Song, KE . LI, Andrew Morton,
Stephen Rothwell, Miguel Ojeda, Joe Perches, Gustavo A. R. Silva,
Randy Dunlap, Sami Tolvanen, Stephen Boyd, linux-kernel,
clang-built-linux
On Mon, Jun 28, 2021 at 01:31:06PM -0700, Nick Desaulniers wrote:
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO. Strip off
> these suffixes so that we can continue to hook such static functions.
>
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> ---
> Changes v2 -> V3:
> * Un-nest preprocessor checks, as per Nathan.
>
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
> kernel/kallsyms.c | 32 +++++++++++++++++++++++++++++---
> 1 file changed, 29 insertions(+), 3 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 4067564ec59f..143c69e7e75d 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -171,6 +171,26 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> +#ifdef CONFIG_LTO_CLANG_THIN
> +/*
> + * LLVM appends a suffix for local variables that must be promoted to global
> + * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
> + * can break hooking of static functions with kprobes.
> + */
> +static bool cleanup_symbol_name_thinlto(char *s)
> +{
> + char *res;
> +
> + res = strstr(s, ".llvm.");
> + if (res)
> + *res = '\0';
> +
> + return res != NULL;
> +}
> +#else
> +static bool cleanup_symbol_name_thinlto(char *s) { return false; }
> +#endif /* CONFIG_LTO_CLANG_THIN */
> +
> #if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> /*
> * LLVM appends a hash to static function names when ThinLTO and CFI are
> @@ -178,7 +198,7 @@ static unsigned long kallsyms_sym_address(int idx)
> * This causes confusion and potentially breaks user space tools, so we
> * strip the suffix from expanded symbol names.
> */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name_thinlto_cfi(char *s)
> {
> char *res;
>
> @@ -189,8 +209,14 @@ static inline bool cleanup_symbol_name(char *s)
> return res != NULL;
> }
> #else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
> +static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
> +#endif /* CONFIG_CFI_CLANG && CONFIG_LTO_CLANG_THIN */
> +
> +static bool cleanup_symbol_name(char *s)
> +{
> + return cleanup_symbol_name_thinlto(s) &&
> + cleanup_symbol_name_thinlto_cfi(s);
> +}
>
> /* Lookup the address for this symbol. Returns 0 if not found. */
> unsigned long kallsyms_lookup_name(const char *name)
> --
> 2.32.0.93.g670b81a890-goog
>
Is there any reason that we cannot eliminate the stubs and combine the
functions, or am I missing something? Completely untested diff.
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index c851ca0ed357..014b59ad68a3 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -161,26 +161,36 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static inline bool cleanup_symbol_name_thinlto(char *s)
{
char *res;
- res = strrchr(s, '$');
+ if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
+ return false;
+
+ /*
+ * LLVM appends a suffix for local variables that must be promoted to global
+ * scope as part of ThinLTO. foo() becomes foo.llvm.974640843467629774. This
+ * can break hooking of static functions with kprobes.
+ */
+ res = strstr(s, ".llvm.");
if (res)
*res = '\0';
+ /*
+ * LLVM appends a hash to static function names when ThinLTO and CFI are
+ * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
+ * This causes confusion and potentially breaks user space tools, so we
+ * strip the suffix from expanded symbol names.
+ */
+ if (IS_ENABLED(CONFIG_CFI_CLANG)) {
+ res = strrchr(s, '$');
+ if (res)
+ *res = '\0';
+ }
+
return res != NULL;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
@@ -195,7 +205,7 @@ unsigned long kallsyms_lookup_name(const char *name)
if (strcmp(namebuf, name) == 0)
return kallsyms_sym_address(i);
- if (cleanup_symbol_name(namebuf) && strcmp(namebuf, name) == 0)
+ if (cleanup_symbol_name_thinlto(namebuf) && strcmp(namebuf, name) == 0)
return kallsyms_sym_address(i);
}
return module_kallsyms_lookup_name(name);
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v3] kallsyms: strip LTO suffixes from static functions
2021-06-28 21:19 ` Nathan Chancellor
@ 2021-06-28 22:01 ` Nick Desaulniers
2021-06-28 22:16 ` Nathan Chancellor
0 siblings, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-06-28 22:01 UTC (permalink / raw)
To: Nathan Chancellor
Cc: Kees Cook, Fangrui Song, KE . LI, Andrew Morton,
Stephen Rothwell, Miguel Ojeda, Joe Perches, Gustavo A. R. Silva,
Randy Dunlap, Sami Tolvanen, Stephen Boyd, linux-kernel,
clang-built-linux
On Mon, Jun 28, 2021 at 2:20 PM Nathan Chancellor <nathan@kernel.org> wrote:
>
> On Mon, Jun 28, 2021 at 01:31:06PM -0700, Nick Desaulniers wrote:
> > Similar to:
> > commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> > functions")
> >
> > It's very common for compilers to modify the symbol name for static
> > functions as part of optimizing transformations. That makes hooking
> > static functions (that weren't inlined or DCE'd) with kprobes difficult.
> >
> > LLVM has yet another name mangling scheme used by thin LTO. Strip off
> > these suffixes so that we can continue to hook such static functions.
> >
> > Reported-by: KE.LI(Lieke) <like1@oppo.com>
> > Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> > ---
> > Changes v2 -> V3:
> > * Un-nest preprocessor checks, as per Nathan.
> >
> > Changes v1 -> v2:
> > * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> > also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> > two function calls.
> > * Drop KE.LI's tested by tag.
> > * Do not carry Fangrui's Reviewed by tag.
> > * Drop the inline keyword; it is meaningless.
> > kernel/kallsyms.c | 32 +++++++++++++++++++++++++++++---
> > 1 file changed, 29 insertions(+), 3 deletions(-)
> >
> > diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> > index 4067564ec59f..143c69e7e75d 100644
> > --- a/kernel/kallsyms.c
> > +++ b/kernel/kallsyms.c
> > @@ -171,6 +171,26 @@ static unsigned long kallsyms_sym_address(int idx)
> > return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> > }
> >
> > +#ifdef CONFIG_LTO_CLANG_THIN
> > +/*
> > + * LLVM appends a suffix for local variables that must be promoted to global
> > + * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
> > + * can break hooking of static functions with kprobes.
> > + */
> > +static bool cleanup_symbol_name_thinlto(char *s)
> > +{
> > + char *res;
> > +
> > + res = strstr(s, ".llvm.");
> > + if (res)
> > + *res = '\0';
> > +
> > + return res != NULL;
> > +}
> > +#else
> > +static bool cleanup_symbol_name_thinlto(char *s) { return false; }
> > +#endif /* CONFIG_LTO_CLANG_THIN */
> > +
> > #if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> > /*
> > * LLVM appends a hash to static function names when ThinLTO and CFI are
> > @@ -178,7 +198,7 @@ static unsigned long kallsyms_sym_address(int idx)
> > * This causes confusion and potentially breaks user space tools, so we
> > * strip the suffix from expanded symbol names.
> > */
> > -static inline bool cleanup_symbol_name(char *s)
> > +static bool cleanup_symbol_name_thinlto_cfi(char *s)
> > {
> > char *res;
> >
> > @@ -189,8 +209,14 @@ static inline bool cleanup_symbol_name(char *s)
> > return res != NULL;
> > }
> > #else
> > -static inline bool cleanup_symbol_name(char *s) { return false; }
> > -#endif
> > +static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
> > +#endif /* CONFIG_CFI_CLANG && CONFIG_LTO_CLANG_THIN */
> > +
> > +static bool cleanup_symbol_name(char *s)
> > +{
> > + return cleanup_symbol_name_thinlto(s) &&
> > + cleanup_symbol_name_thinlto_cfi(s);
> > +}
> >
> > /* Lookup the address for this symbol. Returns 0 if not found. */
> > unsigned long kallsyms_lookup_name(const char *name)
> > --
> > 2.32.0.93.g670b81a890-goog
> >
>
> Is there any reason that we cannot eliminate the stubs and combine the
> functions, or am I missing something? Completely untested diff.
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index c851ca0ed357..014b59ad68a3 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -161,26 +161,36 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> -/*
> - * LLVM appends a hash to static function names when ThinLTO and CFI are
> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> - * This causes confusion and potentially breaks user space tools, so we
> - * strip the suffix from expanded symbol names.
> - */
> -static inline bool cleanup_symbol_name(char *s)
> +static inline bool cleanup_symbol_name_thinlto(char *s)
Drop inline while touching this line.
> {
> char *res;
>
> - res = strrchr(s, '$');
> + if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
> + return false;
> +
> + /*
> + * LLVM appends a suffix for local variables that must be promoted to global
> + * scope as part of ThinLTO. foo() becomes foo.llvm.974640843467629774. This
> + * can break hooking of static functions with kprobes.
> + */
> + res = strstr(s, ".llvm.");
> if (res)
> *res = '\0';
Sure, this is nicer though within the true block we should `return
true;` early rather than additionally check the $ mangling, I suppose.
>
> + /*
> + * LLVM appends a hash to static function names when ThinLTO and CFI are
> + * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> + * This causes confusion and potentially breaks user space tools, so we
> + * strip the suffix from expanded symbol names.
> + */
> + if (IS_ENABLED(CONFIG_CFI_CLANG)) {
> + res = strrchr(s, '$');
> + if (res)
> + *res = '\0';
> + }
> +
> return res != NULL;
> }
> -#else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
>
> /* Lookup the address for this symbol. Returns 0 if not found. */
> unsigned long kallsyms_lookup_name(const char *name)
> @@ -195,7 +205,7 @@ unsigned long kallsyms_lookup_name(const char *name)
> if (strcmp(namebuf, name) == 0)
> return kallsyms_sym_address(i);
>
> - if (cleanup_symbol_name(namebuf) && strcmp(namebuf, name) == 0)
> + if (cleanup_symbol_name_thinlto(namebuf) && strcmp(namebuf, name) == 0)
> return kallsyms_sym_address(i);
> }
> return module_kallsyms_lookup_name(name);
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v3] kallsyms: strip LTO suffixes from static functions
2021-06-28 22:01 ` Nick Desaulniers
@ 2021-06-28 22:16 ` Nathan Chancellor
2021-07-07 18:18 ` [PATCH v4] " Nick Desaulniers
0 siblings, 1 reply; 32+ messages in thread
From: Nathan Chancellor @ 2021-06-28 22:16 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, Fangrui Song, KE . LI, Andrew Morton,
Stephen Rothwell, Miguel Ojeda, Joe Perches, Gustavo A. R. Silva,
Randy Dunlap, Sami Tolvanen, Stephen Boyd, linux-kernel,
clang-built-linux
On 6/28/2021 3:01 PM, Nick Desaulniers wrote:
> On Mon, Jun 28, 2021 at 2:20 PM Nathan Chancellor <nathan@kernel.org> wrote:
>>
>> On Mon, Jun 28, 2021 at 01:31:06PM -0700, Nick Desaulniers wrote:
>>> Similar to:
>>> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
>>> functions")
>>>
>>> It's very common for compilers to modify the symbol name for static
>>> functions as part of optimizing transformations. That makes hooking
>>> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>>>
>>> LLVM has yet another name mangling scheme used by thin LTO. Strip off
>>> these suffixes so that we can continue to hook such static functions.
>>>
>>> Reported-by: KE.LI(Lieke) <like1@oppo.com>
>>> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
>>> ---
>>> Changes v2 -> V3:
>>> * Un-nest preprocessor checks, as per Nathan.
>>>
>>> Changes v1 -> v2:
>>> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
>>> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
>>> two function calls.
>>> * Drop KE.LI's tested by tag.
>>> * Do not carry Fangrui's Reviewed by tag.
>>> * Drop the inline keyword; it is meaningless.
>>> kernel/kallsyms.c | 32 +++++++++++++++++++++++++++++---
>>> 1 file changed, 29 insertions(+), 3 deletions(-)
>>>
>>> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
>>> index 4067564ec59f..143c69e7e75d 100644
>>> --- a/kernel/kallsyms.c
>>> +++ b/kernel/kallsyms.c
>>> @@ -171,6 +171,26 @@ static unsigned long kallsyms_sym_address(int idx)
>>> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
>>> }
>>>
>>> +#ifdef CONFIG_LTO_CLANG_THIN
>>> +/*
>>> + * LLVM appends a suffix for local variables that must be promoted to global
>>> + * scope as part of thin LTO. foo() becomes foo.llvm.974640843467629774. This
>>> + * can break hooking of static functions with kprobes.
>>> + */
>>> +static bool cleanup_symbol_name_thinlto(char *s)
>>> +{
>>> + char *res;
>>> +
>>> + res = strstr(s, ".llvm.");
>>> + if (res)
>>> + *res = '\0';
>>> +
>>> + return res != NULL;
>>> +}
>>> +#else
>>> +static bool cleanup_symbol_name_thinlto(char *s) { return false; }
>>> +#endif /* CONFIG_LTO_CLANG_THIN */
>>> +
>>> #if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
>>> /*
>>> * LLVM appends a hash to static function names when ThinLTO and CFI are
>>> @@ -178,7 +198,7 @@ static unsigned long kallsyms_sym_address(int idx)
>>> * This causes confusion and potentially breaks user space tools, so we
>>> * strip the suffix from expanded symbol names.
>>> */
>>> -static inline bool cleanup_symbol_name(char *s)
>>> +static bool cleanup_symbol_name_thinlto_cfi(char *s)
>>> {
>>> char *res;
>>>
>>> @@ -189,8 +209,14 @@ static inline bool cleanup_symbol_name(char *s)
>>> return res != NULL;
>>> }
>>> #else
>>> -static inline bool cleanup_symbol_name(char *s) { return false; }
>>> -#endif
>>> +static bool cleanup_symbol_name_thinlto_cfi(char *s) { return false; }
>>> +#endif /* CONFIG_CFI_CLANG && CONFIG_LTO_CLANG_THIN */
>>> +
>>> +static bool cleanup_symbol_name(char *s)
>>> +{
>>> + return cleanup_symbol_name_thinlto(s) &&
>>> + cleanup_symbol_name_thinlto_cfi(s);
>>> +}
>>>
>>> /* Lookup the address for this symbol. Returns 0 if not found. */
>>> unsigned long kallsyms_lookup_name(const char *name)
>>> --
>>> 2.32.0.93.g670b81a890-goog
>>>
>>
>> Is there any reason that we cannot eliminate the stubs and combine the
>> functions, or am I missing something? Completely untested diff.
>>
>> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
>> index c851ca0ed357..014b59ad68a3 100644
>> --- a/kernel/kallsyms.c
>> +++ b/kernel/kallsyms.c
>> @@ -161,26 +161,36 @@ static unsigned long kallsyms_sym_address(int idx)
>> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
>> }
>>
>> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
>> -/*
>> - * LLVM appends a hash to static function names when ThinLTO and CFI are
>> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
>> - * This causes confusion and potentially breaks user space tools, so we
>> - * strip the suffix from expanded symbol names.
>> - */
>> -static inline bool cleanup_symbol_name(char *s)
>> +static inline bool cleanup_symbol_name_thinlto(char *s)
>
> Drop inline while touching this line.
Sure.
>> {
>> char *res;
>>
>> - res = strrchr(s, '$');
>> + if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
>> + return false;
>> +
>> + /*
>> + * LLVM appends a suffix for local variables that must be promoted to global
>> + * scope as part of ThinLTO. foo() becomes foo.llvm.974640843467629774. This
>> + * can break hooking of static functions with kprobes.
>> + */
>> + res = strstr(s, ".llvm.");
>> if (res)
>> *res = '\0';
>
> Sure, this is nicer though within the true block we should `return
> true;` early rather than additionally check the $ mangling, I suppose.
I am not sure I follow? Are you talking about moving this into an else
block in the if statement below this?
This should probably be two separate patches, with the first one
eliminating the stub, dropping the inline, and renaming the function
then the second patch do what this one does but I do not have a strong
opinion.
I do not mind if you take ownership of this diff, with or without
attribution.
>>
>> + /*
>> + * LLVM appends a hash to static function names when ThinLTO and CFI are
>> + * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
>> + * This causes confusion and potentially breaks user space tools, so we
>> + * strip the suffix from expanded symbol names.
>> + */
>> + if (IS_ENABLED(CONFIG_CFI_CLANG)) {
>> + res = strrchr(s, '$');
>> + if (res)
>> + *res = '\0';
>> + }
>> +
>> return res != NULL;
>> }
>> -#else
>> -static inline bool cleanup_symbol_name(char *s) { return false; }
>> -#endif
>>
>> /* Lookup the address for this symbol. Returns 0 if not found. */
>> unsigned long kallsyms_lookup_name(const char *name)
>> @@ -195,7 +205,7 @@ unsigned long kallsyms_lookup_name(const char *name)
>> if (strcmp(namebuf, name) == 0)
>> return kallsyms_sym_address(i);
>>
>> - if (cleanup_symbol_name(namebuf) && strcmp(namebuf, name) == 0)
>> + if (cleanup_symbol_name_thinlto(namebuf) && strcmp(namebuf, name) == 0)
>> return kallsyms_sym_address(i);
>> }
>> return module_kallsyms_lookup_name(name);
>
>
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v4] kallsyms: strip LTO suffixes from static functions
2021-06-28 22:16 ` Nathan Chancellor
@ 2021-07-07 18:18 ` Nick Desaulniers
2021-07-07 18:34 ` Nathan Chancellor
2021-08-06 16:20 ` Sami Tolvanen
0 siblings, 2 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-07-07 18:18 UTC (permalink / raw)
To: Kees Cook
Cc: Fangrui Song, Nick Desaulniers, KE . LI, Nathan Chancellor,
Stephen Rothwell, Andrew Morton, Miroslav Benes, Miguel Ojeda,
Joe Perches, Stephen Boyd, Gustavo A. R. Silva, Randy Dunlap,
Sami Tolvanen, linux-kernel, clang-built-linux
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO. Strip off
these suffixes so that we can continue to hook such static functions.
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v3 -> v4:
* Convert this function to use IS_ENABLED rather than provide multiple
definitions based on preprocessor checks.
* Add Nathan's suggested-by.
Changes v2 -> v3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 43 ++++++++++++++++++++++++++++++-------------
1 file changed, 30 insertions(+), 13 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 4067564ec59f..a10dab216f4f 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -171,26 +171,43 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name(char *s)
{
char *res;
+ /*
+ * LLVM appends a suffix for local variables that must be promoted to
+ * global scope as part of ThinLTO. foo() becomes
+ * foo.llvm.974640843467629774. This can break hooking of static
+ * functions with kprobes.
+ */
+ if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
+ return false;
+
+ res = strstr(s, ".llvm.");
+ if (res) {
+ *res = '\0';
+ return true;
+ }
+
+ /*
+ * LLVM appends a hash to static function names when ThinLTO and CFI
+ * are both enabled, i.e. foo() becomes
+ * foo$707af9a22804d33c81801f27dcfe489b. This causes confusion and
+ * potentially breaks user space tools, so we strip the suffix from
+ * expanded symbol names.
+ */
+ if (!IS_ENABLED(CONFIG_CFI_CLANG))
+ return false;
+
res = strrchr(s, '$');
- if (res)
+ if (res) {
*res = '\0';
+ return true;
+ }
- return res != NULL;
+ return false;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
--
2.32.0.93.g670b81a890-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v4] kallsyms: strip LTO suffixes from static functions
2021-07-07 18:18 ` [PATCH v4] " Nick Desaulniers
@ 2021-07-07 18:34 ` Nathan Chancellor
2021-07-07 18:59 ` Fāng-ruì Sòng
2021-08-06 16:20 ` Sami Tolvanen
1 sibling, 1 reply; 32+ messages in thread
From: Nathan Chancellor @ 2021-07-07 18:34 UTC (permalink / raw)
To: Nick Desaulniers, Kees Cook
Cc: Fangrui Song, KE . LI, Stephen Rothwell, Andrew Morton,
Miroslav Benes, Miguel Ojeda, Joe Perches, Stephen Boyd,
Gustavo A. R. Silva, Randy Dunlap, Sami Tolvanen, linux-kernel,
clang-built-linux
On 7/7/2021 11:18 AM, Nick Desaulniers wrote:
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO. Strip off
> these suffixes so that we can continue to hook such static functions.
>
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Suggested-by: Nathan Chancellor <nathan@kernel.org>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Code looks fine, small comment about a comment below.
Reviewed-by: Nathan Chancellor <nathan@kernel.org>
> ---
> Changes v3 -> v4:
> * Convert this function to use IS_ENABLED rather than provide multiple
> definitions based on preprocessor checks.
> * Add Nathan's suggested-by.
>
> Changes v2 -> v3:
> * Un-nest preprocessor checks, as per Nathan.
>
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
>
> kernel/kallsyms.c | 43 ++++++++++++++++++++++++++++++-------------
> 1 file changed, 30 insertions(+), 13 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 4067564ec59f..a10dab216f4f 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -171,26 +171,43 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> -/*
> - * LLVM appends a hash to static function names when ThinLTO and CFI are
> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> - * This causes confusion and potentially breaks user space tools, so we
> - * strip the suffix from expanded symbol names.
> - */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name(char *s)
> {
> char *res;
>
> + /*
> + * LLVM appends a suffix for local variables that must be promoted to
This says local variables but the example uses a function? Is that correct?
> + * global scope as part of ThinLTO. foo() becomes
> + * foo.llvm.974640843467629774. This can break hooking of static
> + * functions with kprobes.
> + */
> + if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
> + return false;
> +
> + res = strstr(s, ".llvm.");
> + if (res) {
> + *res = '\0';
> + return true;
> + }
> +
> + /*
> + * LLVM appends a hash to static function names when ThinLTO and CFI
> + * are both enabled, i.e. foo() becomes
> + * foo$707af9a22804d33c81801f27dcfe489b. This causes confusion and
> + * potentially breaks user space tools, so we strip the suffix from
> + * expanded symbol names.
> + */
> + if (!IS_ENABLED(CONFIG_CFI_CLANG))
> + return false;
> +
> res = strrchr(s, '$');
> - if (res)
> + if (res) {
> *res = '\0';
> + return true;
> + }
>
> - return res != NULL;
> + return false;
> }
> -#else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
>
> /* Lookup the address for this symbol. Returns 0 if not found. */
> unsigned long kallsyms_lookup_name(const char *name)
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v4] kallsyms: strip LTO suffixes from static functions
2021-07-07 18:34 ` Nathan Chancellor
@ 2021-07-07 18:59 ` Fāng-ruì Sòng
0 siblings, 0 replies; 32+ messages in thread
From: Fāng-ruì Sòng @ 2021-07-07 18:59 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, Nathan Chancellor, KE . LI, Stephen Rothwell,
Andrew Morton, Miroslav Benes, Miguel Ojeda, Joe Perches,
Stephen Boyd, Gustavo A. R. Silva, Randy Dunlap, Sami Tolvanen,
linux-kernel, clang-built-linux
On Wed, Jul 7, 2021 at 11:34 AM Nathan Chancellor <nathan@kernel.org> wrote:
>
> On 7/7/2021 11:18 AM, Nick Desaulniers wrote:
> > Similar to:
> > commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> > functions")
> >
> > It's very common for compilers to modify the symbol name for static
> > functions as part of optimizing transformations. That makes hooking
> > static functions (that weren't inlined or DCE'd) with kprobes difficult.
> >
> > LLVM has yet another name mangling scheme used by thin LTO. Strip off
> > these suffixes so that we can continue to hook such static functions.
> >
> > Reported-by: KE.LI(Lieke) <like1@oppo.com>
> > Suggested-by: Nathan Chancellor <nathan@kernel.org>
> > Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
>
> Code looks fine, small comment about a comment below.
>
> Reviewed-by: Nathan Chancellor <nathan@kernel.org>
>
> > ---
> > Changes v3 -> v4:
> > * Convert this function to use IS_ENABLED rather than provide multiple
> > definitions based on preprocessor checks.
> > * Add Nathan's suggested-by.
> >
> > Changes v2 -> v3:
> > * Un-nest preprocessor checks, as per Nathan.
> >
> > Changes v1 -> v2:
> > * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> > also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> > two function calls.
> > * Drop KE.LI's tested by tag.
> > * Do not carry Fangrui's Reviewed by tag.
> > * Drop the inline keyword; it is meaningless.
> >
> > kernel/kallsyms.c | 43 ++++++++++++++++++++++++++++++-------------
> > 1 file changed, 30 insertions(+), 13 deletions(-)
> >
> > diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> > index 4067564ec59f..a10dab216f4f 100644
> > --- a/kernel/kallsyms.c
> > +++ b/kernel/kallsyms.c
> > @@ -171,26 +171,43 @@ static unsigned long kallsyms_sym_address(int idx)
> > return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> > }
> >
> > -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> > -/*
> > - * LLVM appends a hash to static function names when ThinLTO and CFI are
> > - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> > - * This causes confusion and potentially breaks user space tools, so we
> > - * strip the suffix from expanded symbol names.
> > - */
> > -static inline bool cleanup_symbol_name(char *s)
> > +static bool cleanup_symbol_name(char *s)
> > {
> > char *res;
> >
> > + /*
> > + * LLVM appends a suffix for local variables that must be promoted to
>
> This says local variables but the example uses a function? Is that correct?
local functions/variables.
Both functions and variables can have a .llvm.[0-9]+ suffix.
Aside from this, the updated description looks good to me
Reviewed-by: Fangrui Song <maskray@google.com>
> > + * global scope as part of ThinLTO. foo() becomes
> > + * foo.llvm.974640843467629774. This can break hooking of static
> > + * functions with kprobes.
> > + */
> > + if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
> > + return false;
> > +
> > + res = strstr(s, ".llvm.");
> > + if (res) {
> > + *res = '\0';
> > + return true;
> > + }
> > +
> > + /*
> > + * LLVM appends a hash to static function names when ThinLTO and CFI
> > + * are both enabled, i.e. foo() becomes
> > + * foo$707af9a22804d33c81801f27dcfe489b. This causes confusion and
> > + * potentially breaks user space tools, so we strip the suffix from
> > + * expanded symbol names.
> > + */
> > + if (!IS_ENABLED(CONFIG_CFI_CLANG))
> > + return false;
> > +
> > res = strrchr(s, '$');
> > - if (res)
> > + if (res) {
> > *res = '\0';
> > + return true;
> > + }
> >
> > - return res != NULL;
> > + return false;
> > }
> > -#else
> > -static inline bool cleanup_symbol_name(char *s) { return false; }
> > -#endif
> >
> > /* Lookup the address for this symbol. Returns 0 if not found. */
> > unsigned long kallsyms_lookup_name(const char *name)
> >
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v4] kallsyms: strip LTO suffixes from static functions
2021-07-07 18:18 ` [PATCH v4] " Nick Desaulniers
2021-07-07 18:34 ` Nathan Chancellor
@ 2021-08-06 16:20 ` Sami Tolvanen
2021-10-01 19:58 ` Nick Desaulniers
1 sibling, 1 reply; 32+ messages in thread
From: Sami Tolvanen @ 2021-08-06 16:20 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, Fangrui Song, KE . LI, Nathan Chancellor,
Stephen Rothwell, Andrew Morton, Miroslav Benes, Miguel Ojeda,
Joe Perches, Stephen Boyd, Gustavo A. R. Silva, Randy Dunlap,
linux-kernel, clang-built-linux
On Wed, Jul 7, 2021 at 11:18 AM Nick Desaulniers
<ndesaulniers@google.com> wrote:
>
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO. Strip off
> these suffixes so that we can continue to hook such static functions.
>
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Suggested-by: Nathan Chancellor <nathan@kernel.org>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> ---
> Changes v3 -> v4:
> * Convert this function to use IS_ENABLED rather than provide multiple
> definitions based on preprocessor checks.
> * Add Nathan's suggested-by.
>
> Changes v2 -> v3:
> * Un-nest preprocessor checks, as per Nathan.
>
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
>
> kernel/kallsyms.c | 43 ++++++++++++++++++++++++++++++-------------
> 1 file changed, 30 insertions(+), 13 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 4067564ec59f..a10dab216f4f 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -171,26 +171,43 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> -/*
> - * LLVM appends a hash to static function names when ThinLTO and CFI are
> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> - * This causes confusion and potentially breaks user space tools, so we
> - * strip the suffix from expanded symbol names.
> - */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name(char *s)
> {
> char *res;
>
> + /*
> + * LLVM appends a suffix for local variables that must be promoted to
> + * global scope as part of ThinLTO. foo() becomes
> + * foo.llvm.974640843467629774. This can break hooking of static
> + * functions with kprobes.
> + */
> + if (!IS_ENABLED(CONFIG_LTO_CLANG_THIN))
> + return false;
> +
> + res = strstr(s, ".llvm.");
> + if (res) {
> + *res = '\0';
> + return true;
> + }
> +
> + /*
> + * LLVM appends a hash to static function names when ThinLTO and CFI
> + * are both enabled, i.e. foo() becomes
> + * foo$707af9a22804d33c81801f27dcfe489b. This causes confusion and
> + * potentially breaks user space tools, so we strip the suffix from
> + * expanded symbol names.
> + */
> + if (!IS_ENABLED(CONFIG_CFI_CLANG))
> + return false;
> +
> res = strrchr(s, '$');
> - if (res)
> + if (res) {
> *res = '\0';
> + return true;
> + }
Note that starting with https://reviews.llvm.org/D97484, the hash
separator is '.' instead of '$'. It looks like this change will be in
Clang 13.
Sami
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v5] kallsyms: strip LTO suffixes from static functions
2021-08-06 16:20 ` Sami Tolvanen
@ 2021-10-01 19:58 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-01 19:58 UTC (permalink / raw)
To: Kees Cook
Cc: Nick Desaulniers, KE . LI, Fangrui Song, Nathan Chancellor,
Padmanabha Srinivasaiah, Sami Tolvanen, Miroslav Benes,
Jessica Yu, Miguel Ojeda, Stephen Boyd, Joe Perches,
linux-kernel, llvm
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO.
Combine handling of the various schemes by truncating after the first
'.'. Strip off these suffixes so that we can continue to hook such
static functions. Clang releases prior to clang-13 would use '$'
instead of '.'
Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Suggested-by: Fangrui Song <maskray@google.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
Suggested-by: Sami Tolvanen <samitolvanen@google.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v4 -> v5:
* Absorb Padmanabha Srinivasaiah's patch from
https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
* Add Padmanabha's Suggested-by tag.
* Rewrite the patch to truncate after first '.', as per Sami's comment
from
https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
* Add Sami's Suggested-by tag.
* Verify that the '$' delimiter only appears for
thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
* Update comments as per Nathan + Fangrui, add their Suggested-by tags.
* While Nathan + Fangrui did review v4, v5 is too different IMO to carry
those tags forward.
Changes v3 -> v4:
* Convert this function to use IS_ENABLED rather than provide multiple
definitions based on preprocessor checks.
* Add Nathan's suggested-by.
Changes v2 -> v3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 45 ++++++++++++++++++++++++++++++++-------------
1 file changed, 32 insertions(+), 13 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 0ba87982d017..3e4766204b07 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -164,26 +164,45 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name(char *s)
{
char *res;
+ if (!IS_ENABLED(CONFIG_LTO_CLANG))
+ return false;
+
+ /*
+ * LLVM appends various suffixes for local functions and variables that must
+ * be promoted to global scope as part of LTO. This can break hooking of
+ * static functions with kprobes. '.' is not a valid character in an
+ * identifier in C. Suffixes observed:
+ * - foo.llvm.[0-9a-f]+
+ * - foo.[0-9a-f]+
+ * - foo.[0-9a-f]+.cfi_jt
+ */
+ res = strchr(s, '.');
+ if (res) {
+ *res = '\0';
+ return true;
+ }
+
+ if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
+ __clang_major__ >= 13)
+ return false;
+
+ /*
+ * Prior to LLVM 13, the following suffixes were observed when thinLTO
+ * and CFI are both enabled:
+ * - foo$[0-9]+
+ */
res = strrchr(s, '$');
- if (res)
+ if (res) {
*res = '\0';
+ return true;
+ }
- return res != NULL;
+ return false;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
base-commit: 4de593fb965fc2bd11a0b767e0c65ff43540a6e4
--
2.33.0.800.g4c38ced690-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [PATCH v5] kallsyms: strip LTO suffixes from static functions
@ 2021-10-01 19:58 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-01 19:58 UTC (permalink / raw)
To: Kees Cook
Cc: Nick Desaulniers, KE . LI, Fangrui Song, Nathan Chancellor,
Padmanabha Srinivasaiah, Sami Tolvanen, Miroslav Benes,
Jessica Yu, Miguel Ojeda, Stephen Boyd, Joe Perches,
linux-kernel, llvm
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO.
Combine handling of the various schemes by truncating after the first
'.'. Strip off these suffixes so that we can continue to hook such
static functions. Clang releases prior to clang-13 would use '$'
instead of '.'
Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Suggested-by: Fangrui Song <maskray@google.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
Suggested-by: Sami Tolvanen <samitolvanen@google.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v4 -> v5:
* Absorb Padmanabha Srinivasaiah's patch from
https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
* Add Padmanabha's Suggested-by tag.
* Rewrite the patch to truncate after first '.', as per Sami's comment
from
https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
* Add Sami's Suggested-by tag.
* Verify that the '$' delimiter only appears for
thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
* Update comments as per Nathan + Fangrui, add their Suggested-by tags.
* While Nathan + Fangrui did review v4, v5 is too different IMO to carry
those tags forward.
Changes v3 -> v4:
* Convert this function to use IS_ENABLED rather than provide multiple
definitions based on preprocessor checks.
* Add Nathan's suggested-by.
Changes v2 -> v3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 45 ++++++++++++++++++++++++++++++++-------------
1 file changed, 32 insertions(+), 13 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 0ba87982d017..3e4766204b07 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -164,26 +164,45 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name(char *s)
{
char *res;
+ if (!IS_ENABLED(CONFIG_LTO_CLANG))
+ return false;
+
+ /*
+ * LLVM appends various suffixes for local functions and variables that must
+ * be promoted to global scope as part of LTO. This can break hooking of
+ * static functions with kprobes. '.' is not a valid character in an
+ * identifier in C. Suffixes observed:
+ * - foo.llvm.[0-9a-f]+
+ * - foo.[0-9a-f]+
+ * - foo.[0-9a-f]+.cfi_jt
+ */
+ res = strchr(s, '.');
+ if (res) {
+ *res = '\0';
+ return true;
+ }
+
+ if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
+ __clang_major__ >= 13)
+ return false;
+
+ /*
+ * Prior to LLVM 13, the following suffixes were observed when thinLTO
+ * and CFI are both enabled:
+ * - foo$[0-9]+
+ */
res = strrchr(s, '$');
- if (res)
+ if (res) {
*res = '\0';
+ return true;
+ }
- return res != NULL;
+ return false;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
base-commit: 4de593fb965fc2bd11a0b767e0c65ff43540a6e4
--
2.33.0.800.g4c38ced690-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v5] kallsyms: strip LTO suffixes from static functions
2021-10-01 19:58 ` Nick Desaulniers
@ 2021-10-01 20:05 ` Sami Tolvanen
-1 siblings, 0 replies; 32+ messages in thread
From: Sami Tolvanen @ 2021-10-01 20:05 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, KE . LI, Fangrui Song, Nathan Chancellor,
Padmanabha Srinivasaiah, Miroslav Benes, Jessica Yu,
Miguel Ojeda, Stephen Boyd, Joe Perches, LKML, llvm
On Fri, Oct 1, 2021 at 12:58 PM Nick Desaulniers
<ndesaulniers@google.com> wrote:
>
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO.
>
> Combine handling of the various schemes by truncating after the first
> '.'. Strip off these suffixes so that we can continue to hook such
> static functions. Clang releases prior to clang-13 would use '$'
> instead of '.'
>
> Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Suggested-by: Fangrui Song <maskray@google.com>
> Suggested-by: Nathan Chancellor <nathan@kernel.org>
> Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
> Suggested-by: Sami Tolvanen <samitolvanen@google.com>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> ---
> Changes v4 -> v5:
> * Absorb Padmanabha Srinivasaiah's patch from
> https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
> * Add Padmanabha's Suggested-by tag.
> * Rewrite the patch to truncate after first '.', as per Sami's comment
> from
> https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
> * Add Sami's Suggested-by tag.
> * Verify that the '$' delimiter only appears for
> thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
> * Update comments as per Nathan + Fangrui, add their Suggested-by tags.
> * While Nathan + Fangrui did review v4, v5 is too different IMO to carry
> those tags forward.
>
> Changes v3 -> v4:
> * Convert this function to use IS_ENABLED rather than provide multiple
> definitions based on preprocessor checks.
> * Add Nathan's suggested-by.
>
> Changes v2 -> v3:
> * Un-nest preprocessor checks, as per Nathan.
>
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
>
> kernel/kallsyms.c | 45 ++++++++++++++++++++++++++++++++-------------
> 1 file changed, 32 insertions(+), 13 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 0ba87982d017..3e4766204b07 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -164,26 +164,45 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> -/*
> - * LLVM appends a hash to static function names when ThinLTO and CFI are
> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> - * This causes confusion and potentially breaks user space tools, so we
> - * strip the suffix from expanded symbol names.
> - */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name(char *s)
> {
> char *res;
>
> + if (!IS_ENABLED(CONFIG_LTO_CLANG))
> + return false;
> +
> + /*
> + * LLVM appends various suffixes for local functions and variables that must
> + * be promoted to global scope as part of LTO. This can break hooking of
> + * static functions with kprobes. '.' is not a valid character in an
> + * identifier in C. Suffixes observed:
> + * - foo.llvm.[0-9a-f]+
> + * - foo.[0-9a-f]+
> + * - foo.[0-9a-f]+.cfi_jt
> + */
> + res = strchr(s, '.');
> + if (res) {
> + *res = '\0';
> + return true;
> + }
> +
> + if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
> + __clang_major__ >= 13)
> + return false;
> +
> + /*
> + * Prior to LLVM 13, the following suffixes were observed when thinLTO
> + * and CFI are both enabled:
> + * - foo$[0-9]+
> + */
> res = strrchr(s, '$');
> - if (res)
> + if (res) {
> *res = '\0';
> + return true;
> + }
>
> - return res != NULL;
> + return false;
> }
> -#else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
Thanks for sending the patch, Nick. This looks correct to me.
Reviewed-by: Sami Tolvanen <samitolvanen@google.com>
Sami
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v5] kallsyms: strip LTO suffixes from static functions
@ 2021-10-01 20:05 ` Sami Tolvanen
0 siblings, 0 replies; 32+ messages in thread
From: Sami Tolvanen @ 2021-10-01 20:05 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, KE . LI, Fangrui Song, Nathan Chancellor,
Padmanabha Srinivasaiah, Miroslav Benes, Jessica Yu,
Miguel Ojeda, Stephen Boyd, Joe Perches, LKML, llvm
On Fri, Oct 1, 2021 at 12:58 PM Nick Desaulniers
<ndesaulniers@google.com> wrote:
>
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> LLVM has yet another name mangling scheme used by thin LTO.
>
> Combine handling of the various schemes by truncating after the first
> '.'. Strip off these suffixes so that we can continue to hook such
> static functions. Clang releases prior to clang-13 would use '$'
> instead of '.'
>
> Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
> Reported-by: KE.LI(Lieke) <like1@oppo.com>
> Suggested-by: Fangrui Song <maskray@google.com>
> Suggested-by: Nathan Chancellor <nathan@kernel.org>
> Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
> Suggested-by: Sami Tolvanen <samitolvanen@google.com>
> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> ---
> Changes v4 -> v5:
> * Absorb Padmanabha Srinivasaiah's patch from
> https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
> * Add Padmanabha's Suggested-by tag.
> * Rewrite the patch to truncate after first '.', as per Sami's comment
> from
> https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
> * Add Sami's Suggested-by tag.
> * Verify that the '$' delimiter only appears for
> thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
> * Update comments as per Nathan + Fangrui, add their Suggested-by tags.
> * While Nathan + Fangrui did review v4, v5 is too different IMO to carry
> those tags forward.
>
> Changes v3 -> v4:
> * Convert this function to use IS_ENABLED rather than provide multiple
> definitions based on preprocessor checks.
> * Add Nathan's suggested-by.
>
> Changes v2 -> v3:
> * Un-nest preprocessor checks, as per Nathan.
>
> Changes v1 -> v2:
> * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> two function calls.
> * Drop KE.LI's tested by tag.
> * Do not carry Fangrui's Reviewed by tag.
> * Drop the inline keyword; it is meaningless.
>
> kernel/kallsyms.c | 45 ++++++++++++++++++++++++++++++++-------------
> 1 file changed, 32 insertions(+), 13 deletions(-)
>
> diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> index 0ba87982d017..3e4766204b07 100644
> --- a/kernel/kallsyms.c
> +++ b/kernel/kallsyms.c
> @@ -164,26 +164,45 @@ static unsigned long kallsyms_sym_address(int idx)
> return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> }
>
> -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> -/*
> - * LLVM appends a hash to static function names when ThinLTO and CFI are
> - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> - * This causes confusion and potentially breaks user space tools, so we
> - * strip the suffix from expanded symbol names.
> - */
> -static inline bool cleanup_symbol_name(char *s)
> +static bool cleanup_symbol_name(char *s)
> {
> char *res;
>
> + if (!IS_ENABLED(CONFIG_LTO_CLANG))
> + return false;
> +
> + /*
> + * LLVM appends various suffixes for local functions and variables that must
> + * be promoted to global scope as part of LTO. This can break hooking of
> + * static functions with kprobes. '.' is not a valid character in an
> + * identifier in C. Suffixes observed:
> + * - foo.llvm.[0-9a-f]+
> + * - foo.[0-9a-f]+
> + * - foo.[0-9a-f]+.cfi_jt
> + */
> + res = strchr(s, '.');
> + if (res) {
> + *res = '\0';
> + return true;
> + }
> +
> + if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
> + __clang_major__ >= 13)
> + return false;
> +
> + /*
> + * Prior to LLVM 13, the following suffixes were observed when thinLTO
> + * and CFI are both enabled:
> + * - foo$[0-9]+
> + */
> res = strrchr(s, '$');
> - if (res)
> + if (res) {
> *res = '\0';
> + return true;
> + }
>
> - return res != NULL;
> + return false;
> }
> -#else
> -static inline bool cleanup_symbol_name(char *s) { return false; }
> -#endif
Thanks for sending the patch, Nick. This looks correct to me.
Reviewed-by: Sami Tolvanen <samitolvanen@google.com>
Sami
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v5] kallsyms: strip LTO suffixes from static functions
2021-10-01 19:58 ` Nick Desaulniers
(?)
(?)
@ 2021-10-01 21:47 ` kernel test robot
2021-10-04 16:29 ` Nick Desaulniers
-1 siblings, 1 reply; 32+ messages in thread
From: kernel test robot @ 2021-10-01 21:47 UTC (permalink / raw)
To: kbuild-all
[-- Attachment #1: Type: text/plain, Size: 3062 bytes --]
Hi Nick,
I love your patch! Yet something to improve:
[auto build test ERROR on 4de593fb965fc2bd11a0b767e0c65ff43540a6e4]
url: https://github.com/0day-ci/linux/commits/Nick-Desaulniers/kallsyms-strip-LTO-suffixes-from-static-functions/20211002-035956
base: 4de593fb965fc2bd11a0b767e0c65ff43540a6e4
config: i386-randconfig-m021-20211002 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
# https://github.com/0day-ci/linux/commit/b73f738c48b304c633f9ff079fd8de572ffc6eb0
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Nick-Desaulniers/kallsyms-strip-LTO-suffixes-from-static-functions/20211002-035956
git checkout b73f738c48b304c633f9ff079fd8de572ffc6eb0
# save the attached .config to linux build tree
mkdir build_dir
make W=1 O=build_dir ARCH=i386 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
kernel/kallsyms.c: In function 'cleanup_symbol_name':
>> kernel/kallsyms.c:190:6: error: '__clang_major__' undeclared (first use in this function)
190 | __clang_major__ >= 13)
| ^~~~~~~~~~~~~~~
kernel/kallsyms.c:190:6: note: each undeclared identifier is reported only once for each function it appears in
kernel/kallsyms.c: At top level:
kernel/kallsyms.c:585:12: warning: no previous prototype for 'arch_get_kallsym' [-Wmissing-prototypes]
585 | int __weak arch_get_kallsym(unsigned int symnum, unsigned long *value,
| ^~~~~~~~~~~~~~~~
vim +/__clang_major__ +190 kernel/kallsyms.c
166
167 static bool cleanup_symbol_name(char *s)
168 {
169 char *res;
170
171 if (!IS_ENABLED(CONFIG_LTO_CLANG))
172 return false;
173
174 /*
175 * LLVM appends various suffixes for local functions and variables that must
176 * be promoted to global scope as part of LTO. This can break hooking of
177 * static functions with kprobes. '.' is not a valid character in an
178 * identifier in C. Suffixes observed:
179 * - foo.llvm.[0-9a-f]+
180 * - foo.[0-9a-f]+
181 * - foo.[0-9a-f]+.cfi_jt
182 */
183 res = strchr(s, '.');
184 if (res) {
185 *res = '\0';
186 return true;
187 }
188
189 if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
> 190 __clang_major__ >= 13)
191 return false;
192
193 /*
194 * Prior to LLVM 13, the following suffixes were observed when thinLTO
195 * and CFI are both enabled:
196 * - foo$[0-9]+
197 */
198 res = strrchr(s, '$');
199 if (res) {
200 *res = '\0';
201 return true;
202 }
203
204 return false;
205 }
206
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 33323 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v5] kallsyms: strip LTO suffixes from static functions
2021-10-01 20:05 ` Sami Tolvanen
(?)
@ 2021-10-04 10:46 ` Padmanabha Srinivasaiah
-1 siblings, 0 replies; 32+ messages in thread
From: Padmanabha Srinivasaiah @ 2021-10-04 10:46 UTC (permalink / raw)
To: ndesaulniers, Sami Tolvanen
Cc: Nick Desaulniers, Kees Cook, KE . LI, Fangrui Song,
Nathan Chancellor, Miroslav Benes, Jessica Yu, Miguel Ojeda,
Stephen Boyd, Joe Perches, LKML, llvm
On Fri, Oct 01, 2021 at 01:05:44PM -0700, Sami Tolvanen wrote:
> On Fri, Oct 1, 2021 at 12:58 PM Nick Desaulniers
> <ndesaulniers@google.com> wrote:
> >
> > Similar to:
> > commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> > functions")
> >
> > It's very common for compilers to modify the symbol name for static
> > functions as part of optimizing transformations. That makes hooking
> > static functions (that weren't inlined or DCE'd) with kprobes difficult.
> >
> > LLVM has yet another name mangling scheme used by thin LTO.
> >
> > Combine handling of the various schemes by truncating after the first
> > '.'. Strip off these suffixes so that we can continue to hook such
> > static functions. Clang releases prior to clang-13 would use '$'
> > instead of '.'
> >
> > Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
> > Reported-by: KE.LI(Lieke) <like1@oppo.com>
> > Suggested-by: Fangrui Song <maskray@google.com>
> > Suggested-by: Nathan Chancellor <nathan@kernel.org>
> > Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
> > Suggested-by: Sami Tolvanen <samitolvanen@google.com>
> > Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
> > ---
> > Changes v4 -> v5:
> > * Absorb Padmanabha Srinivasaiah's patch from
> > https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
> > * Add Padmanabha's Suggested-by tag.
> > * Rewrite the patch to truncate after first '.', as per Sami's comment
> > from
> > https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
> > * Add Sami's Suggested-by tag.
> > * Verify that the '$' delimiter only appears for
> > thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
> > * Update comments as per Nathan + Fangrui, add their Suggested-by tags.
> > * While Nathan + Fangrui did review v4, v5 is too different IMO to carry
> > those tags forward.
> >
> > Changes v3 -> v4:
> > * Convert this function to use IS_ENABLED rather than provide multiple
> > definitions based on preprocessor checks.
> > * Add Nathan's suggested-by.
> >
> > Changes v2 -> v3:
> > * Un-nest preprocessor checks, as per Nathan.
> >
> > Changes v1 -> v2:
> > * Both mangling schemes can occur for thinLTO + CFI, this new scheme can
> > also occur for thinLTO without CFI. Split cleanup_symbol_name() into
> > two function calls.
> > * Drop KE.LI's tested by tag.
> > * Do not carry Fangrui's Reviewed by tag.
> > * Drop the inline keyword; it is meaningless.
> >
> > kernel/kallsyms.c | 45 ++++++++++++++++++++++++++++++++-------------
> > 1 file changed, 32 insertions(+), 13 deletions(-)
> >
> > diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
> > index 0ba87982d017..3e4766204b07 100644
> > --- a/kernel/kallsyms.c
> > +++ b/kernel/kallsyms.c
> > @@ -164,26 +164,45 @@ static unsigned long kallsyms_sym_address(int idx)
> > return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
> > }
> >
> > -#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
> > -/*
> > - * LLVM appends a hash to static function names when ThinLTO and CFI are
> > - * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
> > - * This causes confusion and potentially breaks user space tools, so we
> > - * strip the suffix from expanded symbol names.
> > - */
> > -static inline bool cleanup_symbol_name(char *s)
> > +static bool cleanup_symbol_name(char *s)
> > {
> > char *res;
> >
> > + if (!IS_ENABLED(CONFIG_LTO_CLANG))
> > + return false;
> > +
> > + /*
> > + * LLVM appends various suffixes for local functions and variables that must
> > + * be promoted to global scope as part of LTO. This can break hooking of
> > + * static functions with kprobes. '.' is not a valid character in an
> > + * identifier in C. Suffixes observed:
> > + * - foo.llvm.[0-9a-f]+
> > + * - foo.[0-9a-f]+
> > + * - foo.[0-9a-f]+.cfi_jt
> > + */
> > + res = strchr(s, '.');
> > + if (res) {
> > + *res = '\0';
> > + return true;
> > + }
> > +
> > + if (!IS_ENABLED(CONFIG_CFI_CLANG) || !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
> > + __clang_major__ >= 13)
> > + return false;
> > +
> > + /*
> > + * Prior to LLVM 13, the following suffixes were observed when thinLTO
> > + * and CFI are both enabled:
> > + * - foo$[0-9]+
> > + */
> > res = strrchr(s, '$');
> > - if (res)
> > + if (res) {
> > *res = '\0';
> > + return true;
> > + }
> >
> > - return res != NULL;
> > + return false;
> > }
> > -#else
> > -static inline bool cleanup_symbol_name(char *s) { return false; }
> > -#endif
>
> Thanks for sending the patch, Nick. This looks correct to me.
>
> Reviewed-by: Sami Tolvanen <samitolvanen@google.com>
>
> Sami
Nick, Thanks for absorbing the patch and sharing same.
Sami, Thanks for reviewing and yours inputs
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-01 21:47 ` kernel test robot
@ 2021-10-04 16:29 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 16:29 UTC (permalink / raw)
To: Kees Cook
Cc: Nick Desaulniers, KE . LI, Nathan Chancellor,
Padmanabha Srinivasaiah, Sami Tolvanen, Fangrui Song, Jessica Yu,
Miroslav Benes, Joe Perches, Stephen Boyd, linux-kernel, llvm
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO.
Combine handling of the various schemes by truncating after the first
'.'. Strip off these suffixes so that we can continue to hook such
static functions. Clang releases prior to clang-13 would use '$'
instead of '.'
Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
Suggested-by: Sami Tolvanen <samitolvanen@google.com>
Reviewed-by: Nathan Chancellor <nathan@kernel.org>
Reviewed-by: Fangrui Song <maskray@google.com>
Reviewed-by: Sami Tolvanen <samitolvanen@google.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v5 -> v6:
* Replace __clang_major__ with CONFIG_CLANG_VERSION. The former is not
defined for CC=gcc while the latter is.
* Reflow comment that wasn't wrapper properly. gq in vim behaves
differently based on whether tabstop=8 was set.
* Pick up Sami's RB tag.
Changes v4 -> v5:
* Absorb Padmanabha Srinivasaiah's patch from
https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
* Add Padmanabha's Suggested-by tag.
* Rewrite the patch to truncate after first '.', as per Sami's comment
from
https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
* Add Sami's Suggested-by tag.
* Verify that the '$' delimiter only appears for
thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
* Update comments as per Nathan + Fangrui, add their Suggested-by tags.
* While Nathan + Fangrui did review v4, v5 is too different IMO to carry
those tags forward.
Changes v3 -> v4:
* Convert this function to use IS_ENABLED rather than provide multiple
definitions based on preprocessor checks.
* Add Nathan's suggested-by.
Changes v2 -> v3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 46 +++++++++++++++++++++++++++++++++-------------
1 file changed, 33 insertions(+), 13 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 0ba87982d017..3011bc33a5ba 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -164,26 +164,46 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name(char *s)
{
char *res;
+ if (!IS_ENABLED(CONFIG_LTO_CLANG))
+ return false;
+
+ /*
+ * LLVM appends various suffixes for local functions and variables that
+ * must be promoted to global scope as part of LTO. This can break
+ * hooking of static functions with kprobes. '.' is not a valid
+ * character in an identifier in C. Suffixes observed:
+ * - foo.llvm.[0-9a-f]+
+ * - foo.[0-9a-f]+
+ * - foo.[0-9a-f]+.cfi_jt
+ */
+ res = strchr(s, '.');
+ if (res) {
+ *res = '\0';
+ return true;
+ }
+
+ if (!IS_ENABLED(CONFIG_CFI_CLANG) ||
+ !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
+ CONFIG_CLANG_VERSION >= 130000)
+ return false;
+
+ /*
+ * Prior to LLVM 13, the following suffixes were observed when thinLTO
+ * and CFI are both enabled:
+ * - foo$[0-9]+
+ */
res = strrchr(s, '$');
- if (res)
+ if (res) {
*res = '\0';
+ return true;
+ }
- return res != NULL;
+ return false;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
base-commit: 4de593fb965fc2bd11a0b767e0c65ff43540a6e4
--
2.33.0.800.g4c38ced690-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [PATCH v6] kallsyms: strip LTO suffixes from static functions
@ 2021-10-04 16:29 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 16:29 UTC (permalink / raw)
To: Kees Cook
Cc: Nick Desaulniers, KE . LI, Nathan Chancellor,
Padmanabha Srinivasaiah, Sami Tolvanen, Fangrui Song, Jessica Yu,
Miroslav Benes, Joe Perches, Stephen Boyd, linux-kernel, llvm
Similar to:
commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
functions")
It's very common for compilers to modify the symbol name for static
functions as part of optimizing transformations. That makes hooking
static functions (that weren't inlined or DCE'd) with kprobes difficult.
LLVM has yet another name mangling scheme used by thin LTO.
Combine handling of the various schemes by truncating after the first
'.'. Strip off these suffixes so that we can continue to hook such
static functions. Clang releases prior to clang-13 would use '$'
instead of '.'
Link: https://reviews.llvm.org/rGc6e5c4654bd5045fe22a1a52779e48e2038a404c
Reported-by: KE.LI(Lieke) <like1@oppo.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Suggested-by: Padmanabha Srinivasaiah <treasure4paddy@gmail.com>
Suggested-by: Sami Tolvanen <samitolvanen@google.com>
Reviewed-by: Nathan Chancellor <nathan@kernel.org>
Reviewed-by: Fangrui Song <maskray@google.com>
Reviewed-by: Sami Tolvanen <samitolvanen@google.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
---
Changes v5 -> v6:
* Replace __clang_major__ with CONFIG_CLANG_VERSION. The former is not
defined for CC=gcc while the latter is.
* Reflow comment that wasn't wrapper properly. gq in vim behaves
differently based on whether tabstop=8 was set.
* Pick up Sami's RB tag.
Changes v4 -> v5:
* Absorb Padmanabha Srinivasaiah's patch from
https://lore.kernel.org/lkml/20210814124224.8551-1-treasure4paddy@gmail.com/.
* Add Padmanabha's Suggested-by tag.
* Rewrite the patch to truncate after first '.', as per Sami's comment
from
https://lore.kernel.org/lkml/CABCJKue5Ay6_+8sibzh5wRh3gPzV1g72gJ9m2ot4E1ezj8bpHA@mail.gmail.com/.
* Add Sami's Suggested-by tag.
* Verify that the '$' delimiter only appears for
thin LTO + CFI + clang <= 12, use __clang_minor__ to check.
* Update comments as per Nathan + Fangrui, add their Suggested-by tags.
* While Nathan + Fangrui did review v4, v5 is too different IMO to carry
those tags forward.
Changes v3 -> v4:
* Convert this function to use IS_ENABLED rather than provide multiple
definitions based on preprocessor checks.
* Add Nathan's suggested-by.
Changes v2 -> v3:
* Un-nest preprocessor checks, as per Nathan.
Changes v1 -> v2:
* Both mangling schemes can occur for thinLTO + CFI, this new scheme can
also occur for thinLTO without CFI. Split cleanup_symbol_name() into
two function calls.
* Drop KE.LI's tested by tag.
* Do not carry Fangrui's Reviewed by tag.
* Drop the inline keyword; it is meaningless.
kernel/kallsyms.c | 46 +++++++++++++++++++++++++++++++++-------------
1 file changed, 33 insertions(+), 13 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 0ba87982d017..3011bc33a5ba 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -164,26 +164,46 @@ static unsigned long kallsyms_sym_address(int idx)
return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
}
-#if defined(CONFIG_CFI_CLANG) && defined(CONFIG_LTO_CLANG_THIN)
-/*
- * LLVM appends a hash to static function names when ThinLTO and CFI are
- * both enabled, i.e. foo() becomes foo$707af9a22804d33c81801f27dcfe489b.
- * This causes confusion and potentially breaks user space tools, so we
- * strip the suffix from expanded symbol names.
- */
-static inline bool cleanup_symbol_name(char *s)
+static bool cleanup_symbol_name(char *s)
{
char *res;
+ if (!IS_ENABLED(CONFIG_LTO_CLANG))
+ return false;
+
+ /*
+ * LLVM appends various suffixes for local functions and variables that
+ * must be promoted to global scope as part of LTO. This can break
+ * hooking of static functions with kprobes. '.' is not a valid
+ * character in an identifier in C. Suffixes observed:
+ * - foo.llvm.[0-9a-f]+
+ * - foo.[0-9a-f]+
+ * - foo.[0-9a-f]+.cfi_jt
+ */
+ res = strchr(s, '.');
+ if (res) {
+ *res = '\0';
+ return true;
+ }
+
+ if (!IS_ENABLED(CONFIG_CFI_CLANG) ||
+ !IS_ENABLED(CONFIG_LTO_CLANG_THIN) ||
+ CONFIG_CLANG_VERSION >= 130000)
+ return false;
+
+ /*
+ * Prior to LLVM 13, the following suffixes were observed when thinLTO
+ * and CFI are both enabled:
+ * - foo$[0-9]+
+ */
res = strrchr(s, '$');
- if (res)
+ if (res) {
*res = '\0';
+ return true;
+ }
- return res != NULL;
+ return false;
}
-#else
-static inline bool cleanup_symbol_name(char *s) { return false; }
-#endif
/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name)
base-commit: 4de593fb965fc2bd11a0b767e0c65ff43540a6e4
--
2.33.0.800.g4c38ced690-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 16:29 ` Nick Desaulniers
(?)
@ 2021-10-04 18:00 ` Kees Cook
2021-10-04 18:32 ` Nick Desaulniers
-1 siblings, 1 reply; 32+ messages in thread
From: Kees Cook @ 2021-10-04 18:00 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, linux-kernel, KE . LI, Stephen Boyd, Fangrui Song,
Miroslav Benes, Padmanabha Srinivasaiah, Nathan Chancellor,
Joe Perches, Jessica Yu, Sami Tolvanen, llvm
On Mon, 4 Oct 2021 09:29:33 -0700, Nick Desaulniers wrote:
> Similar to:
> commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> functions")
>
> It's very common for compilers to modify the symbol name for static
> functions as part of optimizing transformations. That makes hooking
> static functions (that weren't inlined or DCE'd) with kprobes difficult.
>
> [...]
Applied to for-next/hardening, thanks!
[1/1] kallsyms: strip LTO suffixes from static functions
https://git.kernel.org/kees/c/6eb4bd92c1ce
Also,if you get a moment, can you set up patatt (or b4) to sign your
outgoing patches? DKIM is nice, but I'd like to see more folks signing
their emailed patches: https://github.com/mricon/patatt
tl;dr:
add to ~/.gitconfig:
[patatt]
signingkey = openpgp:FINGERPRINT-HERE
# install git sendemail hook (assuming you send with git)
$ patatt install-hook
# or do it manually before sending:
$ patatt sign $file-with-email
Thanks!
--
Kees Cook
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:00 ` Kees Cook
@ 2021-10-04 18:32 ` Nick Desaulniers
2021-10-04 18:38 ` Konstantin Ryabitsev
0 siblings, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 18:32 UTC (permalink / raw)
To: Kees Cook, Konstantin Ryabitsev
Cc: linux-kernel, KE . LI, Stephen Boyd, Fangrui Song,
Miroslav Benes, Padmanabha Srinivasaiah, Nathan Chancellor,
Joe Perches, Jessica Yu, Sami Tolvanen, llvm
On Mon, Oct 4, 2021 at 11:05 AM Kees Cook <keescook@chromium.org> wrote:
>
> On Mon, 4 Oct 2021 09:29:33 -0700, Nick Desaulniers wrote:
> > Similar to:
> > commit 8b8e6b5d3b01 ("kallsyms: strip ThinLTO hashes from static
> > functions")
> >
> > It's very common for compilers to modify the symbol name for static
> > functions as part of optimizing transformations. That makes hooking
> > static functions (that weren't inlined or DCE'd) with kprobes difficult.
> >
> > [...]
>
> Applied to for-next/hardening, thanks!
>
> [1/1] kallsyms: strip LTO suffixes from static functions
> https://git.kernel.org/kees/c/6eb4bd92c1ce
>
> Also,if you get a moment, can you set up patatt (or b4) to sign your
> outgoing patches? DKIM is nice, but I'd like to see more folks signing
> their emailed patches: https://github.com/mricon/patatt
>
> tl;dr:
>
> add to ~/.gitconfig:
> [patatt]
> signingkey = openpgp:FINGERPRINT-HERE
>
> # install git sendemail hook (assuming you send with git)
> $ patatt install-hook
>
> # or do it manually before sending:
> $ patatt sign $file-with-email
>
Sure thing, trying this out, the commit hook seems broken:
$ git format-patch HEAD~
0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
$ git send-email --suppress-cc=body --to keescook@chromium.org
0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
patatt: E: -: Not a valid RFC2822 message
fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
rejected by sendemail-validate hook
fatal: command 'git hook run sendemail-validate -- <patch>' died with
exit code 1
warning: no patches were sent
`patatt sign 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch`
seems to work.
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:32 ` Nick Desaulniers
@ 2021-10-04 18:38 ` Konstantin Ryabitsev
2021-10-04 18:41 ` Nick Desaulniers
0 siblings, 1 reply; 32+ messages in thread
From: Konstantin Ryabitsev @ 2021-10-04 18:38 UTC (permalink / raw)
To: Nick Desaulniers
Cc: Kees Cook, linux-kernel, KE . LI, Stephen Boyd, Fangrui Song,
Miroslav Benes, Padmanabha Srinivasaiah, Nathan Chancellor,
Joe Perches, Jessica Yu, Sami Tolvanen, llvm
On Mon, Oct 04, 2021 at 11:32:43AM -0700, Nick Desaulniers wrote:
> $ git format-patch HEAD~
> 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> $ git send-email --suppress-cc=body --to keescook@chromium.org
> 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> patatt: E: -: Not a valid RFC2822 message
> fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
> rejected by sendemail-validate hook
> fatal: command 'git hook run sendemail-validate -- <patch>' died with
> exit code 1
> warning: no patches were sent
Woah. What git version is this?
-K
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:38 ` Konstantin Ryabitsev
@ 2021-10-04 18:41 ` Nick Desaulniers
2021-10-04 18:47 ` Konstantin Ryabitsev
2021-10-04 19:45 ` Konstantin Ryabitsev
0 siblings, 2 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 18:41 UTC (permalink / raw)
To: Konstantin Ryabitsev; +Cc: Kees Cook, linux-kernel
On Mon, Oct 4, 2021 at 11:38 AM Konstantin Ryabitsev
<konstantin@linuxfoundation.org> wrote:
>
> On Mon, Oct 04, 2021 at 11:32:43AM -0700, Nick Desaulniers wrote:
> > $ git format-patch HEAD~
> > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > $ git send-email --suppress-cc=body --to keescook@chromium.org
> > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > patatt: E: -: Not a valid RFC2822 message
> > fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
> > rejected by sendemail-validate hook
> > fatal: command 'git hook run sendemail-validate -- <patch>' died with
> > exit code 1
> > warning: no patches were sent
>
> Woah. What git version is this?
$ git --version
git version 2.33.0.800.g4c38ced690-goog
Looks like some corporate version...anything else I can to do to help
debug? (Moving explicit CC's to BCC).
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:41 ` Nick Desaulniers
@ 2021-10-04 18:47 ` Konstantin Ryabitsev
2021-10-04 18:52 ` Nick Desaulniers
2021-10-04 19:45 ` Konstantin Ryabitsev
1 sibling, 1 reply; 32+ messages in thread
From: Konstantin Ryabitsev @ 2021-10-04 18:47 UTC (permalink / raw)
To: Nick Desaulniers; +Cc: Kees Cook, linux-kernel
On Mon, Oct 04, 2021 at 11:41:29AM -0700, Nick Desaulniers wrote:
> On Mon, Oct 4, 2021 at 11:38 AM Konstantin Ryabitsev
> <konstantin@linuxfoundation.org> wrote:
> >
> > On Mon, Oct 04, 2021 at 11:32:43AM -0700, Nick Desaulniers wrote:
> > > $ git format-patch HEAD~
> > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > $ git send-email --suppress-cc=body --to keescook@chromium.org
> > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > patatt: E: -: Not a valid RFC2822 message
> > > fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
> > > rejected by sendemail-validate hook
> > > fatal: command 'git hook run sendemail-validate -- <patch>' died with
> > > exit code 1
> > > warning: no patches were sent
> >
> > Woah. What git version is this?
>
> $ git --version
> git version 2.33.0.800.g4c38ced690-goog
>
> Looks like some corporate version...anything else I can to do to help
> debug? (Moving explicit CC's to BCC).
Yeah, can you please send me
0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch as an attachment?
Also, the output of running "locale" -- it's got to be something to do with
passing stdin as opposed ot loading from file.
-K
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:47 ` Konstantin Ryabitsev
@ 2021-10-04 18:52 ` Nick Desaulniers
0 siblings, 0 replies; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 18:52 UTC (permalink / raw)
To: Konstantin Ryabitsev; +Cc: Kees Cook, linux-kernel
[-- Attachment #1: Type: text/plain, Size: 1860 bytes --]
On Mon, Oct 4, 2021 at 11:47 AM Konstantin Ryabitsev
<konstantin@linuxfoundation.org> wrote:
>
> On Mon, Oct 04, 2021 at 11:41:29AM -0700, Nick Desaulniers wrote:
> > On Mon, Oct 4, 2021 at 11:38 AM Konstantin Ryabitsev
> > <konstantin@linuxfoundation.org> wrote:
> > >
> > > On Mon, Oct 04, 2021 at 11:32:43AM -0700, Nick Desaulniers wrote:
> > > > $ git format-patch HEAD~
> > > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > > $ git send-email --suppress-cc=body --to keescook@chromium.org
> > > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > > patatt: E: -: Not a valid RFC2822 message
> > > > fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
> > > > rejected by sendemail-validate hook
> > > > fatal: command 'git hook run sendemail-validate -- <patch>' died with
> > > > exit code 1
> > > > warning: no patches were sent
> > >
> > > Woah. What git version is this?
> >
> > $ git --version
> > git version 2.33.0.800.g4c38ced690-goog
> >
> > Looks like some corporate version...anything else I can to do to help
> > debug? (Moving explicit CC's to BCC).
>
> Yeah, can you please send me
> 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch as an attachment?
Sure, attached via gmail web client.
> Also, the output of running "locale" -- it's got to be something to do with
> passing stdin as opposed ot loading from file.
$ locale
LANG=en_US.UTF-8
LANGUAGE=
LC_CTYPE="en_US.UTF-8"
LC_NUMERIC="en_US.UTF-8"
LC_TIME="en_US.UTF-8"
LC_COLLATE="en_US.UTF-8"
LC_MONETARY="en_US.UTF-8"
LC_MESSAGES="en_US.UTF-8"
LC_PAPER="en_US.UTF-8"
LC_NAME="en_US.UTF-8"
LC_ADDRESS="en_US.UTF-8"
LC_TELEPHONE="en_US.UTF-8"
LC_MEASUREMENT="en_US.UTF-8"
LC_IDENTIFICATION="en_US.UTF-8"
LC_ALL=
As a heads up, I sent a PR, too: https://github.com/mricon/patatt/pull/1.
--
Thanks,
~Nick Desaulniers
[-- Attachment #2: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch --]
[-- Type: application/octet-stream, Size: 1597 bytes --]
From e8241cfda4da7db55a87f61200731de18cd7222a Mon Sep 17 00:00:00 2001
From: Nick Desaulniers <ndesaulniers@google.com>
Date: Wed, 29 Sep 2021 12:20:24 -0700
Subject: [PATCH] ARM: mm: proc-macros: ensure *_tlb_fns are 4B aligned
A kernel built with CONFIG_THUMB2_KERNEL=y and using clang as the
assembler could generate non-naturally-aligned v7wbi_tlb_fns which
results in a boot failure. The original commit adding the macro missed
the .align directive on this data.
Fixes: 66a625a88174 ("ARM: mm: proc-macros: Add generic proc/cache/tlb struct definition macros")
Link: https://github.com/ClangBuiltLinux/linux/issues/1447
Link: https://lore.kernel.org/all/0699da7b-354f-aecc-a62f-e25693209af4@linaro.org/
Debugged-by: Ard Biesheuvel <ardb@kernel.org>
Debugged-by: Nathan Chancellor <nathan@kernel.org>
Debugged-by: Richard Henderson <richard.henderson@linaro.org>
Suggested-by: Ard Biesheuvel <ardb@kernel.org>
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Tested-by: Nathan Chancellor <nathan@kernel.org>
---
arch/arm/mm/proc-macros.S | 1 +
1 file changed, 1 insertion(+)
diff --git a/arch/arm/mm/proc-macros.S b/arch/arm/mm/proc-macros.S
index e2c743aa2eb2..d9f7dfe2a7ed 100644
--- a/arch/arm/mm/proc-macros.S
+++ b/arch/arm/mm/proc-macros.S
@@ -340,6 +340,7 @@ ENTRY(\name\()_cache_fns)
.macro define_tlb_functions name:req, flags_up:req, flags_smp
.type \name\()_tlb_fns, #object
+ .align 2
ENTRY(\name\()_tlb_fns)
.long \name\()_flush_user_tlb_range
.long \name\()_flush_kern_tlb_range
--
2.33.0.800.g4c38ced690-goog
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 18:41 ` Nick Desaulniers
2021-10-04 18:47 ` Konstantin Ryabitsev
@ 2021-10-04 19:45 ` Konstantin Ryabitsev
2021-10-04 20:37 ` Konstantin Ryabitsev
1 sibling, 1 reply; 32+ messages in thread
From: Konstantin Ryabitsev @ 2021-10-04 19:45 UTC (permalink / raw)
To: Nick Desaulniers; +Cc: Kees Cook, linux-kernel
On Mon, Oct 04, 2021 at 11:41:29AM -0700, Nick Desaulniers wrote:
> On Mon, Oct 4, 2021 at 11:38 AM Konstantin Ryabitsev
> <konstantin@linuxfoundation.org> wrote:
> >
> > On Mon, Oct 04, 2021 at 11:32:43AM -0700, Nick Desaulniers wrote:
> > > $ git format-patch HEAD~
> > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > $ git send-email --suppress-cc=body --to keescook@chromium.org
> > > 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch
> > > patatt: E: -: Not a valid RFC2822 message
> > > fatal: 0001-ARM-mm-proc-macros-ensure-_tlb_fns-are-4B-aligned.patch:
> > > rejected by sendemail-validate hook
> > > fatal: command 'git hook run sendemail-validate -- <patch>' died with
> > > exit code 1
> > > warning: no patches were sent
> >
> > Woah. What git version is this?
>
> $ git --version
> git version 2.33.0.800.g4c38ced690-goog
>
> Looks like some corporate version...anything else I can to do to help
> debug? (Moving explicit CC's to BCC).
So, this line:
> fatal: command 'git hook run sendemail-validate -- <patch>' died with exit code 1
Suggests to me that your git version is patched to carry the
new-and-not-yet-accepted "git hook" changes. It seems that it both opens a
stdin and passes the file as the parameter. When we find a stdin, we always
grab that instead of the passed parameter, but that's only a problem with this
change to git.
I'll add a fix that will always disregard stdin when we're running with
--hook.
-K
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 19:45 ` Konstantin Ryabitsev
@ 2021-10-04 20:37 ` Konstantin Ryabitsev
2021-10-04 23:22 ` Nick Desaulniers
0 siblings, 1 reply; 32+ messages in thread
From: Konstantin Ryabitsev @ 2021-10-04 20:37 UTC (permalink / raw)
To: Nick Desaulniers; +Cc: Kees Cook, linux-kernel
On Mon, Oct 04, 2021 at 03:45:21PM -0400, Konstantin Ryabitsev wrote:
> So, this line:
>
> > fatal: command 'git hook run sendemail-validate -- <patch>' died with exit code 1
>
> Suggests to me that your git version is patched to carry the
> new-and-not-yet-accepted "git hook" changes. It seems that it both opens a
> stdin and passes the file as the parameter. When we find a stdin, we always
> grab that instead of the passed parameter, but that's only a problem with this
> change to git.
Patatt version 0.4.9 is out and should fix this problem. Glad we caught it
before the fancy new git-hook patches are in upstream git. :)
-K
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 20:37 ` Konstantin Ryabitsev
@ 2021-10-04 23:22 ` Nick Desaulniers
2021-10-05 13:02 ` Konstantin Ryabitsev
0 siblings, 1 reply; 32+ messages in thread
From: Nick Desaulniers @ 2021-10-04 23:22 UTC (permalink / raw)
To: Konstantin Ryabitsev; +Cc: Kees Cook, linux-kernel
On Mon, Oct 4, 2021 at 1:37 PM Konstantin Ryabitsev
<konstantin@linuxfoundation.org> wrote:
>
> On Mon, Oct 04, 2021 at 03:45:21PM -0400, Konstantin Ryabitsev wrote:
> > So, this line:
> >
> > > fatal: command 'git hook run sendemail-validate -- <patch>' died with exit code 1
> >
> > Suggests to me that your git version is patched to carry the
> > new-and-not-yet-accepted "git hook" changes. It seems that it both opens a
> > stdin and passes the file as the parameter. When we find a stdin, we always
> > grab that instead of the passed parameter, but that's only a problem with this
> > change to git.
>
> Patatt version 0.4.9 is out and should fix this problem. Glad we caught it
> before the fancy new git-hook patches are in upstream git. :)
$ pip install --user patatt --upgrade
$ git send-email ...
$ echo $?
0
:) LGTM, thanks Konstantin. Did I mention that b4 has significantly
improved my workflow contributing to the Linux kernel?
--
Thanks,
~Nick Desaulniers
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v6] kallsyms: strip LTO suffixes from static functions
2021-10-04 23:22 ` Nick Desaulniers
@ 2021-10-05 13:02 ` Konstantin Ryabitsev
0 siblings, 0 replies; 32+ messages in thread
From: Konstantin Ryabitsev @ 2021-10-05 13:02 UTC (permalink / raw)
To: Nick Desaulniers; +Cc: Kees Cook, linux-kernel
On Mon, Oct 04, 2021 at 04:22:47PM -0700, Nick Desaulniers wrote:
> :) LGTM, thanks Konstantin. Did I mention that b4 has significantly
> improved my workflow contributing to the Linux kernel?
Great to hear that, thanks! :)
-K
^ permalink raw reply [flat|nested] 32+ messages in thread
end of thread, other threads:[~2021-10-05 13:02 UTC | newest]
Thread overview: 32+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-06-22 18:38 [PATCH] kallsyms: strip LTO suffixes from static functions Nick Desaulniers
2021-06-22 20:18 ` Fangrui Song
2021-06-28 17:54 ` Nick Desaulniers
2021-06-28 18:20 ` Nick Desaulniers
2021-06-28 19:05 ` [PATCH v2] " Nick Desaulniers
2021-06-28 19:45 ` Nathan Chancellor
2021-06-28 20:31 ` [PATCH v3] " Nick Desaulniers
2021-06-28 21:19 ` Nathan Chancellor
2021-06-28 22:01 ` Nick Desaulniers
2021-06-28 22:16 ` Nathan Chancellor
2021-07-07 18:18 ` [PATCH v4] " Nick Desaulniers
2021-07-07 18:34 ` Nathan Chancellor
2021-07-07 18:59 ` Fāng-ruì Sòng
2021-08-06 16:20 ` Sami Tolvanen
2021-10-01 19:58 ` [PATCH v5] " Nick Desaulniers
2021-10-01 19:58 ` Nick Desaulniers
2021-10-01 20:05 ` Sami Tolvanen
2021-10-01 20:05 ` Sami Tolvanen
2021-10-04 10:46 ` Padmanabha Srinivasaiah
2021-10-01 21:47 ` kernel test robot
2021-10-04 16:29 ` [PATCH v6] " Nick Desaulniers
2021-10-04 16:29 ` Nick Desaulniers
2021-10-04 18:00 ` Kees Cook
2021-10-04 18:32 ` Nick Desaulniers
2021-10-04 18:38 ` Konstantin Ryabitsev
2021-10-04 18:41 ` Nick Desaulniers
2021-10-04 18:47 ` Konstantin Ryabitsev
2021-10-04 18:52 ` Nick Desaulniers
2021-10-04 19:45 ` Konstantin Ryabitsev
2021-10-04 20:37 ` Konstantin Ryabitsev
2021-10-04 23:22 ` Nick Desaulniers
2021-10-05 13:02 ` Konstantin Ryabitsev
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.