efi: tpm: Avoid READ_ONCE() for accessing the event log
Subsystems (3)
Ard Biesheuvel
maintainerPATCH 1/1 efi: tpm: Avoid READ_ONCE() for accessing the event log
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.
Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using READ_ONCE() to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.
--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
include/linux/tpm_eventlog.h +4 -2
@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count; + event_type = event->event_type; + +barrier ();/* Verify that it's the log header */ if (event_header->pcr_idx != 0 ||
Signature · 7 lines
2.39.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 5 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.
Interesting, that's a funny change in behaviour. READ_ONCE() of an unaligned address is pretty sketchy, but if this ends up tripping lots of folks up then I suppose we could use a plain load and a DMB LD as an alternative. It's likely to be more expensive in the LDAPR case, though.
Quoted 25 lines
Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +0
-0
include/linux/tpm_eventlog.h static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev · line 204
Quoted 9 lines
include/linux/tpm_eventlog.h +4
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count; + event_type = event->event_type; + +barrier ();
It would be handy to have a comment here, but when I started thinking about what that would say, it occurred to me that the unmap operation should already have a barrier inside it due to the TLB invalidation, so I'm not sure why this is needed at all.
Will
Ard Biesheuvel
maintainerQuoted 8 lines · Will Deacon
Quoted 5 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.
Quoted 5 lines
Interesting, that's a funny change in behaviour.
READ_ONCE()of an unaligned address is pretty sketchy, but if this ends up tripping lots of folks up then I suppose we could use a plain load and a DMB LD as an alternative. It's likely to be more expensive in the LDAPR case, though.
Yeah, I am not suggesting that we change READ_ONCE(), but this case was definitely not taken into account at the time.
Quoted 31 lines
Quoted 31 lines
Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +1
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count;
Quoted 9 lines
include/linux/tpm_eventlog.h static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev · line 204
Quoted 3 lines
include/linux/tpm_eventlog.h +3
-0+ event_type = event->event_type; + +barrier ();It would be handy to have a comment here, but when I started thinking about what that would say, it occurred to me that the unmap operation should already have a barrier inside it due to the TLB invalidation, so I'm not sure why this is needed at all.
This is purely to prevent the compiler from accessing count or event_type by reloading it from the event pointer, in case it runs out of registers.
Perhaps this is unlikely to occur, given that the kernel uses -fno-strict-aliasing, and so any store occurring after this READ_ONCE() could potentially affect the result of accessing event->count or event->event_type.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 9 lines · Ard Biesheuvel
Quoted 8 lines · Will Deacon
Quoted 5 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.
Quoted 8 lines
Quoted 5 lines
Interesting, that's a funny change in behaviour.
READ_ONCE()of an unaligned address is pretty sketchy, but if this ends up tripping lots of folks up then I suppose we could use a plain load and a DMB LD as an alternative. It's likely to be more expensive in the LDAPR case, though.Yeah, I am not suggesting that we change
READ_ONCE(), but this case was definitely not taken into account at the time.
Indeed, and it looks like the architecture added SCTLR_ELx.nAA to toggle this behaviour, although it was only added in 8.4 with FEAT_LSE2.
Quoted 41 lines
Quoted 31 lines
Quoted 31 lines
Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +1
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count;Quoted 9 lines
include/linux/tpm_eventlog.h static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev · line 204
Quoted 3 lines
include/linux/tpm_eventlog.h +3
-0+ event_type = event->event_type; + +barrier ();It would be handy to have a comment here, but when I started thinking about what that would say, it occurred to me that the unmap operation should already have a barrier inside it due to the TLB invalidation, so I'm not sure why this is needed at all.
Quoted 3 lines
This is purely to prevent the compiler from accessing count or
event_typeby reloading it from the event pointer, in case it runs out of registers.
But that reload would only be a problem if the event has been unmapped, no? Given that the unmapping code has a barrier() and the unmapped page is not explicitly referenced, then I don't see the issue.
Will
Ard Biesheuvel
maintainerQuoted 64 lines · Will Deacon
Quoted 9 lines · Ard Biesheuvel
Quoted 8 lines · Will Deacon
Quoted 5 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.Quoted 8 lines
Quoted 5 lines
Interesting, that's a funny change in behaviour.
READ_ONCE()of an unaligned address is pretty sketchy, but if this ends up tripping lots of folks up then I suppose we could use a plain load and a DMB LD as an alternative. It's likely to be more expensive in the LDAPR case, though.Yeah, I am not suggesting that we change
READ_ONCE(), but this case was definitely not taken into account at the time.Indeed, and it looks like the architecture added SCTLR_ELx.nAA to toggle this behaviour, although it was only added in 8.4 with
FEAT_LSE2.Quoted 41 lines
Quoted 40 lines
Quoted 25 lines
Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +0
-0include/linux/tpm_eventlog.h static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev · line 204
Quoted 9 lines
include/linux/tpm_eventlog.h +4
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count; + event_type = event->event_type; + +barrier ();It would be handy to have a comment here, but when I started thinking about what that would say, it occurred to me that the unmap operation should already have a barrier inside it due to the TLB invalidation, so I'm not sure why this is needed at all.
Quoted 8 lines
Quoted 3 lines
This is purely to prevent the compiler from accessing count or
event_typeby reloading it from the event pointer, in case it runs out of registers.But that reload would only be a problem if the event has been unmapped, no? Given that the unmapping code has a
barrier()and the unmapped page is not explicitly referenced, then I don't see the issue.
Fair point. Looking at the history, it was I who suggested the READ_ONCE() here in addition to the changes to lift the explicit event dereferences out of the loop, but it indeed seems unlikely that there is any way the compiler could decide that it can dereference event again to grab these quantities.
https://lore.kernel.org/all/[email protected]/T/#u
So i'll drop the barrier() from this patch.
Thanks,
Ard.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 15 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.
Quoted 7 lines
Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>
Based on the thread, I tested this patch without barrier() and my machine boots up just fine now with an LTO kernel. Thanks a lot for the analysis and fix!
Quoted 24 lines
--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +4
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count; + event_type = event->event_type; + +barrier ();/* Verify that it's the log header */ if (event_header->pcr_idx != 0 ||Signature · 1 line
2.39.0
Ard Biesheuvel
maintainerQuoted 25 lines · Nathan Chancellor
Quoted 15 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Quoted 7 lines
Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>
Quoted 6 lines
Based on the thread, I tested this patch without
barrier()and my machine boots up just fine now with an LTO kernel. Thanks a lot for the analysis and fix!Tested-by Nathan Chancellor <[email protected]>
Thanks. I've queued this up as a EFI fix.
Quoted 46 lines · Ard Biesheuvel
Nathan reports that recent kernels built with LTO will crash when doing EFI boot using Fedora's GRUB and SHIM. The culprit turns out to be a misaligned load from the TPM event log, which is annotated with
READ_ONCE(), and under LTO, this gets translated into a LDAR instruction which does not tolerate misaligned accesses.Interestingly, this does not happen when booting the same kernel straight from the UEFI shell, and so the fact that the event log may appear misaligned in memory may be caused by a bug in GRUB or SHIM.
However, using
READ_ONCE()to access firmware tables is slightly unusual in any case, and here, we only need to ensure that 'event' is not dereferenced again after it gets unmapped, so a compiler barrier should be sufficient, and works around the reported issue.Cc <[email protected]>Cc Peter Jones <[email protected]>Cc Jarkko Sakkinen <[email protected]>Cc Matthew Garrett <[email protected]>Reported-by Nathan Chancellor <[email protected]>Signed-off-by Ard Biesheuvel <[email protected]>--- include/linux/tpm_eventlog.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)include/linux/tpm_eventlog.h +4
-2@@ -198,8 +198,10 @@ static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *ev* The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ - count =READ_ONCE (event->count); - event_type =READ_ONCE (event->event_type); + count = event->count; + event_type = event->event_type; + +barrier ();/* Verify that it's the log header */ if (event_header->pcr_idx != 0 ||Signature · 1 line
2.39.0
BR, Jarkko