unify the keyrings of arm64 and s390 with x86 to verify kexec'ed kernel signature
Subsystems (10)
v9 cover unify the keyrings of arm64 and s390 with x86 to verify kexec'ed kernel signature
Currently when loading a kernel image via the kexec_file_load() system call, x86 can make use of three keyrings i.e. the .builtin_trusted_keys, .secondary_trusted_keys and .platform keyrings to verify a signature. However, arm64 and s390 can only use the .builtin_trusted_keys and .platform keyring respectively. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown:
kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".
This patch set enables arm64 and s390 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.
The recently introduced .machine keyring impacts the roots of trust by linking the .machine keyring to the .secondary keyring. The roots of trust for different keyrings are described as follows,
.builtin_trusted_keys:
Keys may be built into the kernel during build or inserted into memory reserved for keys post build. The root of trust is based on verification of the kernel image signature. For example, on a physical system in a secure boot environment, this trust is rooted in hardware.
.machine:
If the end-users choose to trust the keys provided by first-stage UEFI bootloader shim i.e. Machine Owner Keys (MOK keys), the keys will be added to this keyring which is linked to the .secondary_trusted_keys keyring as the same as the .builtin_trusted_keys keyring. Shim has built-in keys from a Linux distribution or the end-users-enrolled keys. So the root of trust of this keyring is either a Linux distribution vendor or the end-users.
.secondary_trusted_keys:
Certificates signed by keys on the .builtin_trusted_keys, .machine, or existing keys on the .secondary_trusted_keys keryings may be loaded onto the .secondary_trusted_keys keyring. This establishes a signature chain of trust based on keys loaded on either the .builtin_trusted_keys or .machine keyrings, if configured and enabled.
.platform:
The .platform keyring consist of UEFI db and MOK keys which are used by shim to verify the first boot kernel's image signature. If end-users choose to trust MOK keys and the kernel has the .machine keyring enabled, the .platform keyring only consists of UEFI db keys since the MOK keys are added to the .machine keyring instead. Because the end-users could also enroll their own MOK keys, the root of trust could be hardware and the end-users.
The 3rd arm64 patch depends on the first two patches. The 4th s390 patch can be applied independently.
I've tested the patch set on 5.19.0-rc2 and it works as expected.
For arm64, the tests were done as follows,
1. build 5.19.0-rc2
2. generate keys and add them to .secondary_trusted_keys, MOK, UEFI
db;
3. sign different kernel images with different keys including keys from .builtin_trusted_key, .secondary_trusted_keys keyring, a UEFI db key and MOK key
4. Without lockdown, all kernel images can be kexec'ed; with lockdown enabled, only the kernel image signed by the key from the .builtin_trusted_key keyring can be kexec'ed
For 390, I commented out the code that skips signature verification when secure boot is not enabled since the testing machine doesn't supports secure boot and can confirm before applying the patch, kernel images signed by keys from .builtin_trusted_key, .secondary_trusted_keys couldn't be kexec'ed when lockdown is enabled; after applying the patch, those kernel images could be kexec'ed.
v9:
- improve cover letter, subject line and commit messages, expecially regarding the root of trust of different keyrings and the .machine keyring [Mimi]
- fix two code format issues [Mimi]
- add test results [Mimi]
v8:
- drop "Cc: [email protected]" for the first two prerequisite patches [Baoquan]
v7:
- drop the Fixes tag for the 2nd patch and add patch prerequisites [Baoquan]
- improve cover letter
v6:
- integrate the first three patches of "[PATCH 0/4] Unifrom keyring support across architectures and functions" from Michal [1]
- improve commit message [Baoquan, Michal]
- directly assign kexec_kernel_verify_pe_sig to kexec_file_ops->verify_sig [Michal]
v5:
- improve commit message [Baoquan]
v4:
- fix commit reference format issue and other checkpatch.pl warnings [Baoquan]
v3:
- s/arch_kexec_kernel_verify_pe_sig/kexec_kernel_verify_pe_sig [Eric]
- clean up arch_kexec_kernel_verify_sig [Eric]
v2:
- only x86_64 and arm64 need to enable PE file signature check [Dave]
[1] https://lore.kernel.org/lkml/[email protected]/
Coiby Xu (3):
kexec: clean up arch_kexec_kernel_verify_sig
kexec, KEYS: make the code in bzImage64_verify_sig generic
arm64: kexec_file: use more system keyrings to verify kernel image
signature
Michal Suchanek (1):
kexec, KEYS, s390: Make use of built-in and secondary keyring for
signature verification
arch/arm64/kernel/kexec_image.c | 11 +----- arch/s390/kernel/machine_kexec_file.c | 18 +++++++--- arch/x86/kernel/kexec-bzimage64.c | 20 +---------- include/linux/kexec.h | 6 ++-- kernel/kexec_file.c | 51 ++++++++++++++++----------- 5 files changed, 49 insertions(+), 57 deletions(-)
Signature · 1 line
2.35.3
PATCH v9 1/4 kexec: clean up arch_kexec_kernel_verify_sig
Currently there is no arch-specific implementation of arch_kexec_kernel_verify_sig. Even if we want to add an implementation for an architecture in the future, we can simply use "(struct kexec_file_ops*)->verify_sig". So clean it up.
Note this patch is dependent by later patches so it should backported to the stable tree as well.
--- include/linux/kexec.h | 4 ---- kernel/kexec_file.c | 34 +++++++++++++--------------------- 2 files changed, 13 insertions(+), 25 deletions(-)
include/linux/kexec.h +0 -4
@@ -194,10 +194,6 @@ int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len);void *arch_kexec_kernel_image_load (struct kimage *image);int arch_kimage_file_post_load_cleanup (struct kimage *image); -#ifdef CONFIG_KEXEC_SIG -int arch_kexec_kernel_verify_sig (struct kimage *image,void *buf, -unsigned long buf_len); -#endif int arch_kexec_locate_mem_hole (struct kexec_buf *kbuf);extern int kexec_add_buffer (struct kexec_buf *kbuf);
kernel/kexec_file.c +13 -21
@@ -89,25 +89,6 @@ int __weak arch_kimage_file_post_load_cleanup(struct kimage *image)return kexec_image_post_load_cleanup_default (image); } -#ifdef CONFIG_KEXEC_SIG -static int kexec_image_verify_sig_default (struct kimage *image,void *buf, -unsigned long buf_len) -{ -if (!image->fops || !image->fops->verify_sig) { -pr_debug ("kernel loader does not support signature verification.\n" ); -return -EKEYREJECTED ; - } - -return image->fops->verify_sig (buf, buf_len); -} - -int __weak arch_kexec_kernel_verify_sig (struct kimage *image,void *buf, -unsigned long buf_len) -{ -return kexec_image_verify_sig_default (image, buf, buf_len); -} -#endif -/* * Free up memory used by kernel, initrd, and command line. This is temporary * memory allocation which is not needed any more after these buffers have
@@ -150,13 +131,24 @@ void kimage_file_post_load_cleanup(struct kimage *image) }#ifdef CONFIG_KEXEC_SIG +static int kexec_image_verify_sig (struct kimage *image,void *buf, +unsigned long buf_len) +{ +if (!image->fops || !image->fops->verify_sig) { +pr_debug ("kernel loader does not support signature verification.\n" ); +return -EKEYREJECTED ; + } + +return image->fops->verify_sig (buf, buf_len); +} +static int kimage_validate_signature (struct kimage *image) {int ret; - ret =arch_kexec_kernel_verify_sig (image, image->kernel_buf, - image->kernel_buf_len); + ret =kexec_image_verify_sig (image, image->kernel_buf, + image->kernel_buf_len);if (ret) {if (IS_ENABLED (CONFIG_KEXEC_SIG_FORCE )) {
Signature · 1 line
2.35.3
PATCH v9 2/4 kexec, KEYS: make the code in bzImage64_verify_sig generic
In reply to Coiby Xucommit 278311e417be ("kexec, KEYS: Make use of platform keyring for signature verify") adds platform keyring support on x86 kexec but not arm64.
The code in bzImage64_verify_sig uses the keys on the .builtin_trusted_keys, .machine, if configured and enabled, .secondary_trusted_keys, also if configured, and .platform keyrings to verify the signed kernel image as PE file.
--- arch/x86/kernel/kexec-bzimage64.c | 20 +------------------- include/linux/kexec.h | 6 ++++++ kernel/kexec_file.c | 17 +++++++++++++++++ 3 files changed, 24 insertions(+), 19 deletions(-)
arch/x86/kernel/kexec-bzimage64.c +1 -19
@@ -17,7 +17,6 @@#include <linux/kernel.h> #include <linux/mm.h> #include <linux/efi.h> -#include <linux/verification.h> #include <asm/bootparam.h> #include <asm/setup.h>
@@ -528,28 +527,11 @@ static int bzImage64_cleanup(void *loader_data)return 0 ; } -#ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG -static int bzImage64_verify_sig (const char *kernel,unsigned long kernel_len) -{ -int ret; - - ret =verify_pefile_signature (kernel, kernel_len, -VERIFY_USE_SECONDARY_KEYRING , -VERIFYING_KEXEC_PE_SIGNATURE ); -if (ret == -ENOKEY &&IS_ENABLED (CONFIG_INTEGRITY_PLATFORM_KEYRING )) { - ret =verify_pefile_signature (kernel, kernel_len, -VERIFY_USE_PLATFORM_KEYRING , -VERIFYING_KEXEC_PE_SIGNATURE ); - } -return ret; -} -#endif -const struct kexec_file_ops kexec_bzImage64_ops = { .probe = bzImage64_probe, .load = bzImage64_load, .cleanup = bzImage64_cleanup, #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG - .verify_sig = bzImage64_verify_sig, + .verify_sig = kexec_kernel_verify_pe_sig, #endif };
include/linux/kexec.h +6 -0
@@ -19,6 +19,7 @@#include <asm/io.h> #include <uapi/linux/kexec.h> +#include <linux/verification.h> /* Location of a reserved region to hold the crash kernel. */
@@ -194,6 +195,11 @@ int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len);void *arch_kexec_kernel_image_load (struct kimage *image);int arch_kimage_file_post_load_cleanup (struct kimage *image); +#ifdef CONFIG_KEXEC_SIG +#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION +int kexec_kernel_verify_pe_sig (const char *kernel,unsigned long kernel_len); +#endif +#endif int arch_kexec_locate_mem_hole (struct kexec_buf *kbuf);extern int kexec_add_buffer (struct kexec_buf *kbuf);
kernel/kexec_file.c +17 -0
@@ -131,6 +131,23 @@ void kimage_file_post_load_cleanup(struct kimage *image) }#ifdef CONFIG_KEXEC_SIG +#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION +int kexec_kernel_verify_pe_sig (const char *kernel,unsigned long kernel_len) +{ +int ret; + + ret =verify_pefile_signature (kernel, kernel_len, +VERIFY_USE_SECONDARY_KEYRING , +VERIFYING_KEXEC_PE_SIGNATURE ); +if (ret == -ENOKEY &&IS_ENABLED (CONFIG_INTEGRITY_PLATFORM_KEYRING )) { + ret =verify_pefile_signature (kernel, kernel_len, +VERIFY_USE_PLATFORM_KEYRING , +VERIFYING_KEXEC_PE_SIGNATURE ); + } +return ret; +} +#endif +static int kexec_image_verify_sig (struct kimage *image,void *buf,unsigned long buf_len) {
Signature · 1 line
2.35.3
PATCH v9 3/4 arm64: kexec_file: use more system keyrings to verify kernel image signature
In reply to Coiby XuCurrently, when loading a kernel image via the kexec_file_load() system call, arm64 can only use the .builtin_trusted_keys keyring to verify a signature whereas x86 can use three more keyrings i.e. .secondary_trusted_keys, .machine and .platform keyrings. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown: kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".
This patch set enables arm64 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.
--- arch/arm64/kernel/kexec_image.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/arm64/kernel/kexec_image.c +1 -10
@@ -14,7 +14,6 @@#include <linux/kexec.h> #include <linux/pe.h> #include <linux/string.h> -#include <linux/verification.h> #include <asm/byteorder.h> #include <asm/cpufeature.h> #include <asm/image.h>
@@ -130,18 +129,10 @@ static void *image_load(struct kimage *image,return NULL ; } -#ifdef CONFIG_KEXEC_IMAGE_VERIFY_SIG -static int image_verify_sig (const char *kernel,unsigned long kernel_len) -{ -return verify_pefile_signature (kernel, kernel_len,NULL , -VERIFYING_KEXEC_PE_SIGNATURE ); -} -#endif -const struct kexec_file_ops kexec_image_ops = { .probe = image_probe, .load = image_load, #ifdef CONFIG_KEXEC_IMAGE_VERIFY_SIG - .verify_sig = image_verify_sig, + .verify_sig = kexec_kernel_verify_pe_sig, #endif };
Signature · 1 line
2.35.3
PATCH v9 4/4 kexec, KEYS, s390: Make use of built-in and secondary keyring for signature verification
In reply to Coiby XuFrom: Michal Suchanek <[email protected]>
commit e23a8020ce4e ("s390/kexec_file: Signature verification prototype") adds support for KEXEC_SIG verification with keys from platform keyring but the built-in keys and secondary keyring are not used.
Add support for the built-in keys and secondary keyring as x86 does.
--- arch/s390/kernel/machine_kexec_file.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-)
arch/s390/kernel/machine_kexec_file.c +13 -5
@@ -31,6 +31,7 @@ int s390_verify_sig(const char *kernel, unsigned long kernel_len)const unsigned long marker_len =sizeof (MODULE_SIG_STRING ) -1 ;struct module_signature *ms;unsigned long sig_len; +int ret;/* Skip signature verification when not secure IPLed. */ if (!ipl_secure_flag)
@@ -65,11 +66,18 @@ int s390_verify_sig(const char *kernel, unsigned long kernel_len) return -EBADMSG; } -return verify_pkcs7_signature (kernel, kernel_len, - kernel + kernel_len, sig_len, -VERIFY_USE_PLATFORM_KEYRING , -VERIFYING_MODULE_SIGNATURE , -NULL ,NULL ); + ret =verify_pkcs7_signature (kernel, kernel_len, + kernel + kernel_len, sig_len, +VERIFY_USE_SECONDARY_KEYRING , +VERIFYING_MODULE_SIGNATURE , +NULL ,NULL ); +if (ret == -ENOKEY &&IS_ENABLED (CONFIG_INTEGRITY_PLATFORM_KEYRING )) + ret =verify_pkcs7_signature (kernel, kernel_len, + kernel + kernel_len, sig_len, +VERIFY_USE_PLATFORM_KEYRING , +VERIFYING_MODULE_SIGNATURE , +NULL ,NULL ); +return ret; }#endif /* CONFIG_KEXEC_SIG */
Signature · 1 line
2.35.3
Mimi Zohar
maintainerQuoted 59 lines · Coiby Xu
Currently when loading a kernel image via the
kexec_file_load()system call, x86 can make use of three keyrings i.e. the .builtin_trusted_keys, .secondary_trusted_keys and .platform keyrings to verify a signature. However, arm64 and s390 can only use the .builtin_trusted_keys and .platform keyring respectively. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown:
kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".This patch set enables arm64 and s390 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.
The recently introduced .machine keyring impacts the roots of trust by linking the .machine keyring to the .secondary keyring. The roots of trust for different keyrings are described as follows,
.builtin_trusted_keys:
Keys may be built into the kernel during build or inserted into memory reserved for keys post build. The root of trust is based on verification of the kernel image signature. For example, on a physical system in a secure boot environment, this trust is rooted in hardware.
.machine:
If the end-users choose to trust the keys provided by first-stage UEFI bootloader shim i.e. Machine Owner Keys (MOK keys), the keys will be added to this keyring which is linked to the .secondary_trusted_keys keyring as the same as the .builtin_trusted_keys keyring. Shim has built-in keys from a Linux distribution or the end-users-enrolled keys. So the root of trust of this keyring is either a Linux distribution vendor or the end-users.
.secondary_trusted_keys:
Certificates signed by keys on the .builtin_trusted_keys, .machine, or existing keys on the .secondary_trusted_keys keryings may be loaded onto the .secondary_trusted_keys keyring. This establishes a signature chain of trust based on keys loaded on either the .builtin_trusted_keys or .machine keyrings, if configured and enabled.
.platform:
The .platform keyring consist of UEFI db and MOK keys which are used by shim to verify the first boot kernel's image signature. If end-users choose to trust MOK keys and the kernel has the .machine keyring enabled, the .platform keyring only consists of UEFI db keys since the MOK keys are added to the .machine keyring instead. Because the end-users could also enroll their own MOK keys, the root of trust could be hardware and the end-users.
The 3rd arm64 patch depends on the first two patches. The 4th s390 patch can be applied independently.
I've tested the patch set on 5.19.0-rc2 and it works as expected.
For arm64, the tests were done as follows,
1. build 5.19.0-rc2
2. generate keys and add them to .secondary_trusted_keys, MOK, UEFI
Quoted 7 lines
db;3. sign different kernel images with different keys including keys from .builtin_trusted_key, .secondary_trusted_keys keyring, a UEFI db key and MOK key
4. Without lockdown, all kernel images can be kexec'ed; with lockdown enabled, only the kernel image signed by the key from the .builtin_trusted_key keyring can be kexec'ed
Just confirming, for arm64, this patch set allows verifying the kexec'ed kernel image signature using keys on either the .platform or .secondary_trusted_keys keyrings.
thanks,
Mimi
Quoted 7 lines
For 390, I commented out the code that skips signature verification when secure boot is not enabled since the testing machine doesn't supports secure boot and can confirm before applying the patch, kernel images signed by keys from .builtin_trusted_key, .secondary_trusted_keys couldn't be kexec'ed when lockdown is enabled; after applying the patch, those kernel images could be kexec'ed.
Will Deacon
maintainerQuoted 12 lines · Mimi Zohar
Quoted 11 lines · Coiby Xu
Currently when loading a kernel image via the
kexec_file_load()system call, x86 can make use of three keyrings i.e. the .builtin_trusted_keys, .secondary_trusted_keys and .platform keyrings to verify a signature. However, arm64 and s390 can only use the .builtin_trusted_keys and .platform keyring respectively. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown:
kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".This patch set enables arm64 and s390 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.
[...]
Quoted 11 lines
Quoted 10 lines
For arm64, the tests were done as follows,
1. build 5.19.0-rc2
2. generate keys and add them to .secondary_trusted_keys, MOK, UEFIdb;3. sign different kernel images with different keys including keys from .builtin_trusted_key, .secondary_trusted_keys keyring, a UEFI db key and MOK key
4. Without lockdown, all kernel images can be kexec'ed; with lockdown enabled, only the kernel image signed by the key from the .builtin_trusted_key keyring can be kexec'ed
Quoted 3 lines
Just confirming, for arm64, this patch set allows verifying the kexec'ed kernel image signature using keys on either the .platform or .secondary_trusted_keys keyrings.
It looks like this series is ready to go, but it's not clear who should pick it up. Eric -- would you be the best person? Otherwise, I'm happy to take it via the arm64 tree (on its own branch) if that would be helpful.
Thanks,
Will
Mimi Zohar
maintainerQuoted 27 lines · Will Deacon
Quoted 12 lines · Mimi Zohar
Quoted 11 lines · Coiby Xu
Currently when loading a kernel image via the
kexec_file_load()system call, x86 can make use of three keyrings i.e. the .builtin_trusted_keys, .secondary_trusted_keys and .platform keyrings to verify a signature. However, arm64 and s390 can only use the .builtin_trusted_keys and .platform keyring respectively. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown:
kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".This patch set enables arm64 and s390 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.
[...]
Quoted 11 lines
Quoted 10 lines
For arm64, the tests were done as follows,
1. build 5.19.0-rc2
2. generate keys and add them to .secondary_trusted_keys, MOK, UEFIdb;3. sign different kernel images with different keys including keys from .builtin_trusted_key, .secondary_trusted_keys keyring, a UEFI db key and MOK key
4. Without lockdown, all kernel images can be kexec'ed; with lockdown enabled, only the kernel image signed by the key from the .builtin_trusted_key keyring can be kexec'ed
Quoted 7 lines
Quoted 3 lines
Just confirming, for arm64, this patch set allows verifying the kexec'ed kernel image signature using keys on either the .platform or .secondary_trusted_keys keyrings.
It looks like this series is ready to go, but it's not clear who should pick it up. Eric -- would you be the best person? Otherwise, I'm happy to take it via the arm64 tree (on its own branch) if that would be helpful.
Unless Eric is interested, I was asked to pick this patch set up.
thanks,
Mimi
Hi Mimi,
Quoted 1 line · Mimi Zohar
On Wed, 2022-07-06 at 12:48 +0100, Will Deacon wrote:
[..]
Quoted 5 lines
Quoted 3 lines
It looks like this series is ready to go, but it's not clear who should pick it up. Eric -- would you be the best person? Otherwise, I'm happy to take it via the arm64 tree (on its own branch) if that would be helpful.
Unless Eric is interested, I was asked to pick this patch set up.
Thanks! FYI, Andrew has queued up Naveen's patch set "[PATCH 0/2] kexec:
Drop __weak attributes from functions" though:
https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git/log/?h=mm-nonmm-unstable
With Naveen's patch set, "[PATCH v9 1/4] kexec: clean up arch_kexec_kernel_verify_sig"" can be dropped. If you need me to send a new version, please let me know.
Quoted 5 lines
thanks,
Mimi
Signature · 2 lines
Best regards, Coiby
Mimi Zohar
maintainerQuoted 11 lines · Coiby Xu
Hi Mimi,
Quoted 1 line · Mimi Zohar
On Wed, 2022-07-06 at 12:48 +0100, Will Deacon wrote:
[..]
Quoted 5 lines
Quoted 3 lines
It looks like this series is ready to go, but it's not clear who should pick it up. Eric -- would you be the best person? Otherwise, I'm happy to take it via the arm64 tree (on its own branch) if that would be helpful.
Unless Eric is interested, I was asked to pick this patch set up.
Quoted 7 lines
Thanks! FYI, Andrew has queued up Naveen's patch set "[PATCH 0/2] kexec:
Drop__weakattributes from functions" though:
https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git/log/?h=mm-nonmm-unstableWith Naveen's patch set, "[PATCH v9 1/4] kexec: clean up
arch_kexec_kernel_verify_sig"" can be dropped. If you need me to send a new version, please let me know.
I'm not quite sure how to handle the prerequisite patches being in Andrew's tree, without his creating a branch with just the two commits.
thanks,
Mimi
Quoted 16 lines · Mimi Zohar
Quoted 15 lines · Coiby Xu
Hi Mimi,
Quoted 1 line · Mimi Zohar
On Wed, 2022-07-06 at 12:48 +0100, Will Deacon wrote:
[..]
Quoted 5 lines
Quoted 3 lines
It looks like this series is ready to go, but it's not clear who should pick it up. Eric -- would you be the best person? Otherwise, I'm happy to take it via the arm64 tree (on its own branch) if that would be helpful.
Unless Eric is interested, I was asked to pick this patch set up.
Thanks! FYI, Andrew has queued up Naveen's patch set "[PATCH 0/2] kexec:
Drop__weakattributes from functions" though:
https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git/log/?h=mm-nonmm-unstable
Quoted 6 lines
Quoted 3 lines
With Naveen's patch set, "[PATCH v9 1/4] kexec: clean up
arch_kexec_kernel_verify_sig"" can be dropped. If you need me to send a new version, please let me know.I'm not quite sure how to handle the prerequisite patches being in Andrew's tree, without his creating a branch with just the two commits.
FYI, I just sent v10 based on Naveen's patch set and it targets next-integrity since Mimi is going to pick it up.
Quoted 5 lines
thanks,
Mimi
Signature · 8 lines
Best regards, Coiby _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec