diff --git a/project-lakitu/sys-kernel/dump-capture-kernel/dump-capture-kernel-4.19-r1.ebuild b/project-lakitu/sys-kernel/dump-capture-kernel/dump-capture-kernel-4.19-r2.ebuild
similarity index 100%
rename from project-lakitu/sys-kernel/dump-capture-kernel/dump-capture-kernel-4.19-r1.ebuild
rename to project-lakitu/sys-kernel/dump-capture-kernel/dump-capture-kernel-4.19-r2.ebuild
diff --git a/project-lakitu/sys-kernel/dump-capture-kernel/files/0001-FROMLIST-lib-string.c-implement-stpcpy.patch b/project-lakitu/sys-kernel/dump-capture-kernel/files/0001-FROMLIST-lib-string.c-implement-stpcpy.patch
new file mode 100644
index 0000000..2e7d927
--- /dev/null
+++ b/project-lakitu/sys-kernel/dump-capture-kernel/files/0001-FROMLIST-lib-string.c-implement-stpcpy.patch
@@ -0,0 +1,135 @@
+From 5f4ef1af278d832d9d0d49d56a57b998919c56b9 Mon Sep 17 00:00:00 2001
+From: Manoj Gupta <manojgupta@google.com>
+Date: Fri, 11 Sep 2020 17:10:38 -0700
+Subject: [PATCH] FROMLIST: lib/string.c: implement stpcpy
+
+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 H.  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.
+
+Link: https://lkml.kernel.org/r/20200825140001.2941001-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: Nick Desaulniers <ndesaulniers@google.com>
+Reported-by: Sami Tolvanen <samitolvanen@google.com>
+Tested-by: Nathan Chancellor <natechancellor@gmail.com>
+Suggested-by: Andy Lavr <andy.lavr@gmail.com>
+Suggested-by: Arvind Sankar <nivedita@alum.mit.edu>
+Suggested-by: Joe Perches <joe@perches.com>
+Suggested-by: Masahiro Yamada <masahiroy@kernel.org>
+Suggested-by: Rasmus Villemoes <linux@rasmusvillemoes.dk>
+Acked-by: Kees Cook <keescook@chromium.org>
+Tested-by: Sedat Dilek <sedat.dilek@gmail.com>
+Cc: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+Cc: Alexandru Ardelean <alexandru.ardelean@analog.com>
+Cc: Yury Norov <yury.norov@gmail.com>
+Cc: <stable@vger.kernel.org>
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+(am from https://lore.kernel.org/patchwork/patch/1295112/)
+
+BUG=chromium:1125877
+TEST=CQ
+
+Change-Id: Ieeea470bb7dc2ab46a66d20a4d37fe74e2d5c065
+Signed-off-by: Manoj Gupta <manojgupta@google.com>
+Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/kernel/+/2407003
+Tested-by: Manoj Gupta <manojgupta@chromium.org>
+Reviewed-by: Sean Paul <seanpaul@chromium.org>
+Reviewed-by: Caroline Tice <cmtice@chromium.org>
+Commit-Queue: Manoj Gupta <manojgupta@chromium.org>
+---
+ lib/string.c | 24 ++++++++++++++++++++++++
+ 1 file changed, 24 insertions(+)
+
+diff --git a/lib/string.c b/lib/string.c
+index 72125fd5b4a6..2622a7b7f6ef 100644
+--- a/lib/string.c
++++ b/lib/string.c
+@@ -236,6 +236,30 @@ ssize_t strscpy(char *dest, const char *src, size_t count)
+ 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 the new
++ * %NUL-terminated character. (for strcpy, the return value is a pointer to
++ * src. 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
+-- 
+2.29.2.454.gaff20da3a2-goog
+