From: Greg Kroah-Hartman Date: Tue, 29 Sep 2020 06:54:25 +0000 (+0200) Subject: 4.4-stable patches X-Git-Tag: v4.4.238~17 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=9cd75705e00f82619465d4b220c877cfa1fd3345;p=thirdparty%2Fkernel%2Fstable-queue.git 4.4-stable patches added patches: lib-string.c-implement-stpcpy.patch --- diff --git a/queue-4.4/lib-string.c-implement-stpcpy.patch b/queue-4.4/lib-string.c-implement-stpcpy.patch new file mode 100644 index 00000000000..8c273be0f81 --- /dev/null +++ b/queue-4.4/lib-string.c-implement-stpcpy.patch @@ -0,0 +1,123 @@ +From 1e1b6d63d6340764e00356873e5794225a2a03ea Mon Sep 17 00:00:00 2001 +From: Nick Desaulniers +Date: Fri, 25 Sep 2020 21:19:18 -0700 +Subject: lib/string.c: implement stpcpy + +From: Nick Desaulniers + +commit 1e1b6d63d6340764e00356873e5794225a2a03ea upstream. + +LLVM implemented a recent "libcall optimization" that lowers calls to +`sprintf(dest, "%s", str)` where the return value is used to +`stpcpy(dest, str) - dest`. + +This generally avoids the machinery involved in parsing format strings. +`stpcpy` is just like `strcpy` except it returns the pointer to the new +tail of `dest`. This optimization was introduced into clang-12. + +Implement this so that we don't observe linkage failures due to missing +symbol definitions for `stpcpy`. + +Similar to last year's fire drill with: commit 5f074f3e192f +("lib/string.c: implement a basic bcmp") + +The kernel is somewhere between a "freestanding" environment (no full +libc) and "hosted" environment (many symbols from libc exist with the +same type, function signature, and semantics). + +As Peter Anvin notes, there's not really a great way to inform the +compiler that you're targeting a freestanding environment but would like +to opt-in to some libcall optimizations (see pr/47280 below), rather +than opt-out. + +Arvind notes, -fno-builtin-* behaves slightly differently between GCC +and Clang, and Clang is missing many __builtin_* definitions, which I +consider a bug in Clang and am working on fixing. + +Masahiro summarizes the subtle distinction between compilers justly: + To prevent transformation from foo() into bar(), there are two ways in + Clang to do that; -fno-builtin-foo, and -fno-builtin-bar. There is + only one in GCC; -fno-buitin-foo. + +(Any difference in that behavior in Clang is likely a bug from a missing +__builtin_* definition.) + +Masahiro also notes: + We want to disable optimization from foo() to bar(), + but we may still benefit from the optimization from + foo() into something else. If GCC implements the same transform, we + would run into a problem because it is not -fno-builtin-bar, but + -fno-builtin-foo that disables that optimization. + + In this regard, -fno-builtin-foo would be more future-proof than + -fno-built-bar, but -fno-builtin-foo is still potentially overkill. We + may want to prevent calls from foo() being optimized into calls to + bar(), but we still may want other optimization on calls to foo(). + +It seems that compilers today don't quite provide the fine grain control +over which libcall optimizations pseudo-freestanding environments would +prefer. + +Finally, Kees notes that this interface is unsafe, so we should not +encourage its use. As such, I've removed the declaration from any +header, but it still needs to be exported to avoid linkage errors in +modules. + +Reported-by: Sami Tolvanen +Suggested-by: Andy Lavr +Suggested-by: Arvind Sankar +Suggested-by: Joe Perches +Suggested-by: Kees Cook +Suggested-by: Masahiro Yamada +Suggested-by: Rasmus Villemoes +Signed-off-by: Nick Desaulniers +Signed-off-by: Andrew Morton +Tested-by: Nathan Chancellor +Cc: +Link: https://lkml.kernel.org/r/20200914161643.938408-1-ndesaulniers@google.com +Link: https://bugs.llvm.org/show_bug.cgi?id=47162 +Link: https://bugs.llvm.org/show_bug.cgi?id=47280 +Link: https://github.com/ClangBuiltLinux/linux/issues/1126 +Link: https://man7.org/linux/man-pages/man3/stpcpy.3.html +Link: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stpcpy.html +Link: https://reviews.llvm.org/D85963 +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman + +--- + lib/string.c | 24 ++++++++++++++++++++++++ + 1 file changed, 24 insertions(+) + +--- a/lib/string.c ++++ b/lib/string.c +@@ -235,6 +235,30 @@ ssize_t strscpy(char *dest, const char * + EXPORT_SYMBOL(strscpy); + #endif + ++/** ++ * stpcpy - copy a string from src to dest returning a pointer to the new end ++ * of dest, including src's %NUL-terminator. May overrun dest. ++ * @dest: pointer to end of string being copied into. Must be large enough ++ * to receive copy. ++ * @src: pointer to the beginning of string being copied from. Must not overlap ++ * dest. ++ * ++ * stpcpy differs from strcpy in a key way: the return value is a pointer ++ * to the new %NUL-terminating character in @dest. (For strcpy, the return ++ * value is a pointer to the start of @dest). This interface is considered ++ * unsafe as it doesn't perform bounds checking of the inputs. As such it's ++ * not recommended for usage. Instead, its definition is provided in case ++ * the compiler lowers other libcalls to stpcpy. ++ */ ++char *stpcpy(char *__restrict__ dest, const char *__restrict__ src); ++char *stpcpy(char *__restrict__ dest, const char *__restrict__ src) ++{ ++ while ((*dest++ = *src++) != '\0') ++ /* nothing */; ++ return --dest; ++} ++EXPORT_SYMBOL(stpcpy); ++ + #ifndef __HAVE_ARCH_STRCAT + /** + * strcat - Append one %NUL-terminated string to another diff --git a/queue-4.4/series b/queue-4.4/series index f1716e24530..f0e66926cb6 100644 --- a/queue-4.4/series +++ b/queue-4.4/series @@ -79,3 +79,4 @@ alsa-asihpi-fix-iounmap-in-error-handler.patch mips-add-the-missing-cpu_1074k-into-__get_cpu_type.patch tty-vt-consw-con_scrolldelta-cleanup.patch kprobes-fix-to-check-probe-enabled-before-disarm_kprobe_ftrace.patch +lib-string.c-implement-stpcpy.patch