arm64/virt: Add Arm CCA measurement register support
cover arm64/virt: Add Arm CCA measurement register support
This series adds support for Arm Confidential Compute Architecture (CCA) measurement registers in the Linux kernel, enabling guest Realms to access, extend, and expose measurement values for attestation and runtime integrity tracking.
The Realm Management Monitor (RMM) defines a set of measurement registers consisting of a Realm Initial Measurement (RIM) and a number of Realm Extensible Measurements (REMs). This series introduces the necessary infrastructure to interact with these registers via the RSI interface and exposes them to userspace through the TSM measurement framework.
At a high level, the series includes:
- Helper interfaces for reading and extending measurement registers via RSI
- Definitions for Realm hash algorithms as defined by the RMM specification
- Integration with the TSM measurement subsystem and sysfs exposure for userspace visibility and interaction
After applying this series, measurement registers are exposed under:
/sys/devices/virtual/misc/arm_cca_guest/measurements/
Where:
- rim is read-only (initial measurement)
- rem[0-3] are read/write (extensible measurements)
- The hash algorithm reflects the Realm configuration
Patch summary:
1. arm64: rsi: Add helpers for Arm CCA measurement registers
- Introduces RSI helper APIs to read and extend RIM/REM registers
2. arm64: rsi: Add realm hash algorithm defines
- Adds definitions for SHA-256 and SHA-512 identifiers returned by the RMM
3. virt: arm-cca-guest: Add support for measurement registers
- Integrates with TSM measurement framework
- Implements measurement register refresh and extend operations
- Exposes registers via sysfs using a misc device
- Dynamically configures hash algorithm and digest size per Realm
This enables a consistent mechanism for attestation-related measurements in Arm CCA guests and aligns with the kernel TSM measurement abstraction.
Feedback is very welcome.
Sami Mujawar (3):
arm64: rsi: Add helpers for Arm CCA measurement register operations
arm64: rsi: Add realm hash algorithm defines
virt: arm-cca-guest: Add support for measurement registers
.../sysfs-devices-virtual-misc-arm_cca_guest | 38 +++ arch/arm64/include/asm/rsi_cmds.h | 105 ++++++- arch/arm64/include/asm/rsi_smc.h | 7 + drivers/virt/coco/arm-cca-guest/Kconfig | 1 + .../virt/coco/arm-cca-guest/arm-cca-guest.c | 296 +++++++++++++++++- 5 files changed, 442 insertions(+), 5 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-devices-virtual-misc-arm_cca_guest
Signature · 1 line
SAMI:{C3F47F37-75D8-414A-A8BA-3980EC8A46D7}PATCH 1/3 arm64: rsi: Add helpers for Arm CCA measurement register operations
Add static inline helper functions to support reading the Realm Initial Measurement (RIM) and reading/extending the Realm Extensible Measurement (REM) registers.
The indices of the Arm CCA measurement registers, as defined by the Realm Management Monitor specification, are as follows:
Index Register
0 RIM
1 - 4 REM[0 - 3]The rsi_measurement_extend() function allows extending REM[0–3] registers with a caller-provided digest (up to 64 bytes). Index 0 (RIM) is read-only and cannot be extended.
The rsi_measurement_read() function allows reading measurement values from RIM (index 0) or REM[0–3] (indices 1–4). The returned digest is expected to be 64 bytes.
--- arch/arm64/include/asm/rsi_cmds.h | 105 +++++++++++++++++++++++++++++- 1 file changed, 104 insertions(+), 1 deletion(-)
arch/arm64/include/asm/rsi_cmds.h +104 -1
@@ -1,6 +1,6 @@/* SPDX-License-Identifier: GPL-2.0-only */ /* -* Copyright (C) 2023 ARM Ltd. +* Copyright (C) 2023 - 2025 ARM Ltd. */ #ifndef __ASM_RSI_CMDS_H
@@ -15,6 +15,26 @@#define RSI_GRANULE_SHIFT 12#define RSI_GRANULE_SIZE (_AC(1, UL) << RSI_GRANULE_SHIFT) +/* +* Maximum measurement data size in bytes. +* According to the RMM Specification, the width of the RmmRealmMeasurement type +* is 512 bits. +*/ +#define RSI_MAX_MEASUREMENT_DATA_SIZE_BYTES 64 + +/* +* Indices for the Realm Initial Measurement register (RIM) and the Realm +* Extensible Measurement registers (REMs). +* According to the RMM Specification, Realm attributes of a Realm include +* an array of measurement values. The first entry in this array is a RIM. +* The remaining entries in this array are REMs. +*/ +#define RSI_INDEX_RIM 0 +#define RSI_INDEX_REM0 1 +#define RSI_INDEX_REM1 2 +#define RSI_INDEX_REM2 3 +#define RSI_INDEX_REM3 4 +enum ripas {RSI_RIPAS_EMPTY =0 ,RSI_RIPAS_RAM =1 ,
@@ -159,4 +179,87 @@ static inline unsigned long rsi_attestation_token_continue(phys_addr_t granule, return res.a0; } +/** +* rsi_measurement_extend - Extend the measurement value to the Realm Extensible +* Measurement (REM). +* +* @idx: Index of the REM register. +* Where: +* Index Register +* 1 - 4 REM[0-3] +* @digest: The digest data to be extended. +* @digest_size: Size of the digest data in bytes. +* +* Returns: +* On success, returns RSI_SUCCESS. +* Otherwise, -EINVAL +*/ +static inline unsigned long rsi_measurement_extend (u32 idx, +const u8 *digest, +unsigned long digest_size) +{ +struct arm_smccc_1_2_regs regs = {0 }; + +/* +* Index 0 is for RIM (which is Read Only), while +* REM[0-3] are indexed from 1 - 4. +* The digest size can be at the most 64 bytes. +*/ +if (!digest || idx <RSI_INDEX_REM0 || idx >RSI_INDEX_REM3 || + digest_size ==0 || digest_size >RSI_MAX_MEASUREMENT_DATA_SIZE_BYTES ) +return -EINVAL ; + + regs.a0 =SMC_RSI_MEASUREMENT_EXTEND ; + regs.a1 = idx; + regs.a2 = digest_size; +memcpy (®s.a3, digest, digest_size); +arm_smccc_1_2_smc (®s, ®s); + +if (regs.a0 !=RSI_SUCCESS ) +return -EINVAL ; + +return regs.a0; +} + +/** +* rsi_measurement_read - Read the measurement value from the Realm Initial +* Measurement (RIM) or the Realm Extensible Measurement (REM) register. +* +* @idx: Index of the RIM or REM register. +* Where: +* Index Register +* 0 RIM +* 1 - 4 REM[0-3] +* @digest: The digest data to be returned. +* @digest_size: Size of the digest data buffer in bytes. +* +* Returns: +* On success, returns RSI_SUCCESS. +* Otherwise, -EINVAL +*/ +static inline unsigned long rsi_measurement_read (u32 idx, +u8 *digest, +unsigned long digest_size) +{ +struct arm_smccc_1_2_regs regs = {0 }; + +/* +* The digest size can be at the most 64 bytes, if less then 64 bytes +* it is zero padded. +*/ +if (!digest || idx >RSI_INDEX_REM3 || + digest_size ==0 || digest_size >RSI_MAX_MEASUREMENT_DATA_SIZE_BYTES ) +return -EINVAL ; + + regs.a0 =SMC_RSI_MEASUREMENT_READ ; + regs.a1 = idx; +arm_smccc_1_2_smc (®s, ®s); + +if (regs.a0 !=RSI_SUCCESS ) +return -EINVAL ; + +memcpy (digest, ®s.a1, digest_size); +return regs.a0; +} +#endif /* __ASM_RSI_CMDS_H */
Signature · 1 line
SAMI:{C3F47F37-75D8-414A-A8BA-3980EC8A46D7}PATCH 2/3 arm64: rsi: Add realm hash algorithm defines
In reply to Sami MujawarAdd macro definitions for the hash algorithm identifiers, as specified in the Realm Management Monitor (RMM) specification.
--- arch/arm64/include/asm/rsi_smc.h | 7 +++++++ 1 file changed, 7 insertions(+)
arch/arm64/include/asm/rsi_smc.h +7 -0
@@ -144,6 +144,13 @@ struct realm_config {#endif /* __ASSEMBLER__ */ +/* +* The RSI definition of the Hash Algorithm (as specified by the Secure +* Hash Standard) returned in the realm_config data structure. +*/ +#define RSI_HASH_SHA_256 0 +#define RSI_HASH_SHA_512 1 +/* * Read configuration for the current Realm. *
Signature · 1 line
SAMI:{C3F47F37-75D8-414A-A8BA-3980EC8A46D7}PATCH 3/3 virt: arm-cca-guest: Add support for measurement registers
In reply to Sami MujawarAdd support for Arm CCA measurement registers (MRs), enabling attestation and runtime integrity tracking from guest Realms.
This implementation registers a measurement configuration with the TSM framework and exposes measurement register values via sysfs using a misc device. The supported registers include the Realm Initial Measurement (RIM) and four Runtime Extensible Measurement Registers (REM0–REM3), each using SHA-256 or SHA-512 depending on Realm configuration.
The measurement registers are located under the following sysfs node:
/sys/devices/virtual/misc/arm_cca_guest/measurements/
-rw-r--r-- 1 0 0 64 Jul 21 11:46 rem0:sha512
-rw-r--r-- 1 0 0 64 Jul 21 11:46 rem1:sha512
-rw-r--r-- 1 0 0 64 Jul 21 11:46 rem2:sha512
-rw-r--r-- 1 0 0 64 Jul 21 11:46 rem3:sha512
-r--r--r-- 1 0 0 64 Jul 21 11:46 rim:sha512As seen above the attributes for the REMs are 'rw' indicating they can be read or extended. While the attributes for RIM is 'r' indicating that it can only be read and not extended.
The sysfs node suffix for the measurement register (i.e. ':sha512') indicates the hash algorithm used is sha512. This also reflects that the Realm was launched with SHA512 as the measurement algorithm.
--- .../sysfs-devices-virtual-misc-arm_cca_guest | 38 +++ drivers/virt/coco/arm-cca-guest/Kconfig | 1 + .../virt/coco/arm-cca-guest/arm-cca-guest.c | 296 +++++++++++++++++- 3 files changed, 331 insertions(+), 4 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-devices-virtual-misc-arm_cca_guest
Documentation/ABI/testing/sysfs-devices-virtual-misc-arm_cca_guest new file +38 -0
@@ -0,0 +1,38 @@ +What: /sys/devices/virtual/misc/arm_cca_guest/measurements/MRNAME[:HASH] +Date: July, 2025 +KernelVersion: v6.16 +Contact: [email protected] +Description: + Value of a Arm CCA Realm measurement register (MR). The optional + suffix :HASH is to represent the hash algorithms associated with + the MRs. See below for a complete list of Arm CCA Realm MRs exposed + via sysfs. Refer to the Arm Realm Management Monitor (RMM) + Specification for more information on the Realm Measurement registers. + + The Arm Realm Management Monitor Specification can be found at: + https://developer.arm.com/documentation/den0137/latest/ + + See also: + https://docs.kernel.org/driver-api/coco/measurement-registers.html + +What: /sys/devices/virtual/misc/arm_cca_guest/measurements/rim:[sha256|sha512] +Date: July, 2025 +KernelVersion: v6.16 +Contact: [email protected] +Description: + (RO) RIM - [32|64]-byte immutable storage typically used to represent + the Realm Initial Measurement (RIM) which is the measurement of + the configuration and contents of a Realm at the time of activation. + +What: /sys/devices/virtual/misc/arm_cca_guest/measurements/rem[0123]:[sha256|sha512] +Date: July, 2025 +KernelVersion: v6.16 +Contact: [email protected] +Description: + (RW) REM[0123] - 4 Run-Time extendable Measurement Registers that + represent the Realm Extensible Measurement (REM) registers which + can be extended during the lifetime of a Realm. + Read from any of these returns the current value of the corresponding + REM. Write extends the written buffer to the REM. All writes must start + at offset 0 and be maximum 64 bytes in size. Attempting to write more + than 64 bytes will result in EINVAL returned by the write() syscall.
drivers/virt/coco/arm-cca-guest/Kconfig +1 -0
@@ -2,6 +2,7 @@ config ARM_CCA_GUEST tristate "Arm CCA Guest driver" depends on ARM64 select TSM_REPORTS + select TSM_MEASUREMENTS help The driver provides userspace interface to request and attestation report from the Realm Management Monitor(RMM).
drivers/virt/coco/arm-cca-guest/arm-cca-guest.c +292 -4
342 lines not on this page · raw message
Signature · 1 line
SAMI:{C3F47F37-75D8-414A-A8BA-3980EC8A46D7}Quoted 19 lines · Sami Mujawar
This series adds support for Arm Confidential Compute Architecture (CCA) measurement registers in the Linux kernel, enabling guest Realms to access, extend, and expose measurement values for attestation and runtime integrity tracking.
The Realm Management Monitor (RMM) defines a set of measurement registers consisting of a Realm Initial Measurement (RIM) and a number of Realm Extensible Measurements (REMs). This series introduces the necessary infrastructure to interact with these registers via the RSI interface and exposes them to userspace through the TSM measurement framework.
At a high level, the series includes:
- Helper interfaces for reading and extending measurement registers via RSI
- Definitions for Realm hash algorithms as defined by the RMM specification
- Integration with the TSM measurement subsystem and sysfs exposure for userspace visibility and interaction
Quoted 2 lines
After applying this series, measurement registers are exposed under:
/sys/devices/virtual/misc/arm_cca_guest/measurements/
I'm surprised we get some random sysfs files? How does some more generic userspace figure out to use this vs a TPM or some other platform's version of it?
I also think exposing PCRs as was done for TPM in sysfs was something of a mistake.. Allowing extension without logging is too low level and is very hard to build an entire attestation system around.
I really think we are missing a subsystem here, TPM has sort of been filling this role in a non-generic way, but we should have a common uAPI for platform measurement & attestation:
- Discover available measurements
- Report signed measurements, with ingesting a nonce
- Report measurement logs
- Extend measurements and udpate logs
- Report certificates used in signing
- General reporting of various kinds of attestation evidence
And it would be nice for the PCI devices and others to plug into the general framework as well instead of building a parallel TSM framework for handling evidence.
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
Jason
Hi Jason,
Quoted 20 lines · Jason Gunthorpe
Quoted 19 lines · Sami Mujawar
This series adds support for Arm Confidential Compute Architecture (CCA) measurement registers in the Linux kernel, enabling guest Realms to access, extend, and expose measurement values for attestation and runtime integrity tracking.
The Realm Management Monitor (RMM) defines a set of measurement registers consisting of a Realm Initial Measurement (RIM) and a number of Realm Extensible Measurements (REMs). This series introduces the necessary infrastructure to interact with these registers via the RSI interface and exposes them to userspace through the TSM measurement framework.
At a high level, the series includes:
- Helper interfaces for reading and extending measurement registers via RSI
- Definitions for Realm hash algorithms as defined by the RMM specification
- Integration with the TSM measurement subsystem and sysfs exposure for userspace visibility and interaction
Quoted 6 lines
Quoted 2 lines
After applying this series, measurement registers are exposed under:
/sys/devices/virtual/misc/arm_cca_guest/measurements/I'm surprised we get some random sysfs files? How does some more generic userspace figure out to use this vs a TPM or some other platform's version of it?
That is true. This is the infrastructure for exposing Runtime Measurement registers (R/W) for use by the OS, complementing the TSM_REPORTS (Read Only Platform measurements+Attestation Reports, e.g. on CCA Attestation Report from RMM). Unlike the TSM reports, this doesn't have a generic interface for userspace.
Quoted 7 lines
I also think exposing PCRs as was done for TPM in sysfs was something of a mistake.. Allowing extension without logging is too low level and is very hard to build an entire attestation system around.
I really think we are missing a subsystem here, TPM has sort of been filling this role in a non-generic way, but we should have a common uAPI for platform measurement & attestation:
Agreed, such a subsystem would solve the below.
Quoted 10 lines
- Discover available measurements
- Report signed measurements, with ingesting a nonce
- Report measurement logs
- Extend measurements and udpate logs
- Report certificates used in signing
- General reporting of various kinds of attestation evidenceAnd it would be nice for the PCI devices and others to plug into the general framework as well instead of building a parallel TSM framework for handling evidence.
That makes sense and AFAIU, there are efforts in progress to expose the Device measurements+Certificates in a different form. May be a good idea to intervene early enough to see if we can find a common ground.
Quoted 4 lines
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
As mentioned above, this series adds the support for Runtime Extendible
Measurements (REM in CCA, RTMR on TDX). The RIM+Platform Attestation is already provided via the TSM_REPORT
Kind regards
Suzuki
Quoted 2 lines
Jason
Quoted 6 lines · Suzuki K Poulose
Quoted 3 lines
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
As mentioned above, this series adds the support for Runtime Extendible Measurements (REM in CCA, RTMR on TDX). The RIM+Platform Attestation is already provided via the
TSM_REPORT
Okay, but what actual use is this?
Extendable measrements with no log
Measurement read back without signature
What is the use case? What do you imagine any userspace will do with this? Put it in the cover letter.
I don't think the raw rmm calls are sufficiently developed to be usable directly by userspace. They are less capable than TPM and even TPM has a lot of software around it to make it useful.
Jason
Quoted 11 lines · Jason Gunthorpe
Quoted 6 lines · Suzuki K Poulose
Quoted 3 lines
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
As mentioned above, this series adds the support for Runtime Extendible Measurements (REM in CCA, RTMR on TDX). The RIM+Platform Attestation is already provided via the
TSM_REPORTOkay, but what actual use is this?
Good point. This REMs are planned to be used for EFI_CC_MEASUREMENT_PROTOCOL as described below:
https://github.com/tianocore/edk2/issues/11383
At the moment they are exposed as raw, similar to the Intel TDX RTMRs. This may eventually need to be connected to IMA subsystem.
Quoted 5 lines
Extendable measrements with no log
Measurement read back without signatureWhat is the use case? What do you imagine any userspace will do with this? Put it in the cover letter.
Agreed.
Quoted 4 lines
I don't think the raw rmm calls are sufficiently developed to be usable directly by userspace. They are less capable than TPM and even TPM has a lot of software around it to make it useful.
See above.
Kind regards
Suzuki
Quoted 2 lines
Jason
Quoted 10 lines · Suzuki K Poulose
Quoted 9 lines · Jason Gunthorpe
Quoted 6 lines · Suzuki K Poulose
Quoted 3 lines
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
As mentioned above, this series adds the support for Runtime Extendible Measurements (REM in CCA, RTMR on TDX). The RIM+Platform Attestation is already provided via the
TSM_REPORT
Quoted 7 lines
Quoted 2 lines
Okay, but what actual use is this?
Good point. This REMs are planned to be used for
EFI_CC_MEASUREMENT_PROTOCOLas described below:
So this is tying it to the same FW event log that TPM uses.
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
How do you imagine getting and manipulating the EFI event log to use with this?
Jason
Hi Jason,
Quoted 21 lines · Suzuki K Poulose
Quoted 10 lines · Jason Gunthorpe
Quoted 9 lines · Suzuki K Poulose
Quoted 7 lines
Quoted 4 lines
Isn't this also sort of incomplete? Doesn't anything serious need signed measurements? Isnt't there alot more data that comes out of RMM than just a few measurement registers?
As mentioned above, this series adds the support for Runtime Extendible Measurements (REM in CCA, RTMR on TDX). The RIM+Platform Attestation is already provided via the
TSM_REPORTQuoted 7 lines
Quoted 2 lines
Okay, but what actual use is this?
Good point. This REMs are planned to be used for
EFI_CC_MEASUREMENT_PROTOCOLas described below:So this is tying it to the same FW event log that TPM uses.
Quoted 7 lines
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
How do you imagine getting and manipulating the EFI event log to use with this?
The event logs from UEFI will be handed off to the OS using CCEL ACPI table. The CCEL table spec update can be seen at https://github.com/tianocore/edk2/issues/11384
Regards,
Sami Mujawar
Quoted 2 lines
Jason
Quoted 7 lines · Sami Mujawar
Quoted 7 lines
So this is tying it to the same FW event log that TPM uses.
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
Quoted 6 lines
Quoted 2 lines
How do you imagine getting and manipulating the EFI event log to use with this?
The event logs from UEFI will be handed off to the OS using CCEL ACPI table. The CCEL table spec update can be seen at
https://github.com/tianocore/edk2/issues/11384
I ment from linux userspace. event log is well establihsed in the aCPI side for TPM and in Linux today it is only exposed to userspace through TPM.
This is not TPM, so how do you intend to give the event log to userspace?
Jason
Hi Jason,
Quoted 16 lines · Sami Mujawar
Quoted 8 lines
Quoted 8 lines
So this is tying it to the same FW event log that TPM uses.
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
Quoted 6 lines
Quoted 2 lines
How do you imagine getting and manipulating the EFI event log to use with this?
The event logs from UEFI will be handed off to the OS using CCEL ACPI table. The CCEL table spec update can be seen at
https://github.com/tianocore/edk2/issues/11384
Quoted 6 lines
I ment from linux userspace. event log is well establihsed in the aCPI side for TPM and in Linux today it is only exposed to userspace through TPM.
This is not TPM, so how do you intend to give the event log to userspace?
The event log would be exported via /sys/firmware/acpi/tables/data/CCEL with binary format just as TPM event log is also exported with binary format via binary_bios_measurements.
Instead of Sami, I'll post v2 which rebased on for-next/smccc-bus in arm64 tree.
Thanks.
Signature · 2 lines
Sincerely, Yeoreum Yun
Quoted 25 lines · Yeoreum Yun
Hi Jason,
Quoted 16 lines · Sami Mujawar
Quoted 8 lines
Quoted 8 lines
So this is tying it to the same FW event log that TPM uses.
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
Quoted 6 lines
Quoted 2 lines
How do you imagine getting and manipulating the EFI event log to use with this?
The event logs from UEFI will be handed off to the OS using CCEL ACPI table. The CCEL table spec update can be seen at
https://github.com/tianocore/edk2/issues/11384Quoted 6 lines
I ment from linux userspace. event log is well establihsed in the aCPI side for TPM and in Linux today it is only exposed to userspace through TPM.
This is not TPM, so how do you intend to give the event log to userspace?
Quoted 6 lines
The event log would be exported via
/sys/firmware/acpi/tables/data/CCELwith binary format just as TPM event log is also exported with binary format viabinary_bios_measurements.Instead of Sami, I'll post v2 which rebased on for-next/smccc-bus in arm64 tree.
Okay, Jiri is close to posting the "attestation subsystem" which this needs to plug into instead of creating a bunch more sysfs files.
The CCEL log needs to come out through that interface.
Thanks,
Jason
Quoted 30 lines · Jason Gunthorpe
Quoted 29 lines · Yeoreum Yun
Hi Jason,
Quoted 16 lines · Sami Mujawar
Quoted 8 lines
Quoted 8 lines
So this is tying it to the same FW event log that TPM uses.
I think that strengthens my point this should all be uninform. TPM drivers are directly exposing the event log today, but I guess that needs generalization if non-TPM drivers are going to present it as well.
Quoted 6 lines
Quoted 2 lines
How do you imagine getting and manipulating the EFI event log to use with this?
The event logs from UEFI will be handed off to the OS using CCEL ACPI table. The CCEL table spec update can be seen at
https://github.com/tianocore/edk2/issues/11384Quoted 6 lines
I ment from linux userspace. event log is well establihsed in the aCPI side for TPM and in Linux today it is only exposed to userspace through TPM.
This is not TPM, so how do you intend to give the event log to userspace?
The event log would be exported via
/sys/firmware/acpi/tables/data/CCELwith binary format just as TPM event log is also exported with binary format viabinary_bios_measurements.
Quoted 7 lines
Quoted 2 lines
Instead of Sami, I'll post v2 which rebased on for-next/smccc-bus in arm64 tree.
Okay, Jiri is close to posting the "attestation subsystem" which this needs to plug into instead of creating a bunch more sysfs files.
The CCEL log needs to come out through that interface.
Agree. Thanks for sharing!
Signature · 2 lines
Sincerely, Yeoreum Yun