[PATCH v4 0/1] Introduce support for PSF control.

From: Ramakrishna Saripalli
Date: Fri Apr 30 2021 - 09:17:52 EST

From: Ramakrishna Saripalli <rk.saripalli@xxxxxxx>

Predictive Store Forwarding:
AMD Zen3 processors feature a new technology called
Predictive Store Forwarding (PSF).


PSF is a hardware-based micro-architectural optimization designed
to improve the performance of code execution by predicting address
dependencies between loads and stores.

How PSF works:

It is very common for a CPU to execute a load instruction to an address
that was recently written by a store. Modern CPUs implement a technique
known as Store-To-Load-Forwarding (STLF) to improve performance in such
cases. With STLF, data from the store is forwarded directly to the load
without having to wait for it to be written to memory. In a typical CPU,
STLF occurs after the address of both the load and store are calculated
and determined to match.

PSF expands on this by speculating on the relationship between loads and
stores without waiting for the address calculation to complete. With PSF,
the CPU learns over time the relationship between loads and stores.
If STLF typically occurs between a particular store and load, the CPU will
remember this.

In typical code, PSF provides a performance benefit by speculating on
the load result and allowing later instructions to begin execution
sooner than they otherwise would be able to.

Causes of Incorrect PSF:

Incorrect PSF predictions can occur due to two reasons.

First, it is possible that the store/load pair had a dependency for a
while but later stops having a dependency. This can occur if the address
of either the store or load changes during the execution of the program.

The second source of incorrect PSF predictions can occur if there is an
alias in the PSF predictor structure. The PSF predictor tracks
store-load pairs based on portions of their RIP. It is possible that a
store-load pair which does have a dependency may alias in the predictor
with another store-load pair which does not.

This can result in incorrect speculation when the second store/load pair
is executed.

Security Analysis:

Previous research has shown that when CPUs speculate on non-architectural
paths it can lead to the potential of side channel attacks.
In particular, programs that implement isolation, also known as
‘sandboxing’, entirely in software may need to be concerned with incorrect
CPU speculation as they can occur due to bad PSF predictions.

Because PSF speculation is limited to the current program context,
the impact of bad PSF speculation is very similar to that of
Speculative Store Bypass (Spectre v4)

Predictive Store Forwarding controls:
There are two hardware control bits which influence the PSF feature:
- MSR 48h bit 2 – Speculative Store Bypass (SSBD)
- MSR 48h bit 7 – Predictive Store Forwarding Disable (PSFD)

The PSF feature is disabled if either of these bits are set. These bits
are controllable on a per-thread basis in an SMT system. By default, both
SSBD and PSFD are 0 meaning that the speculation features are enabled.

While the SSBD bit disables PSF and speculative store bypass, PSFD only
disables PSF.

PSFD may be desirable for software which is concerned with the
speculative behavior of PSF but desires a smaller performance impact than
setting SSBD.

Support for PSFD is indicated in CPUID Fn8000_0008 EBX[28].
All processors that support PSF will also support PSFD.

Testing notes:
- Tested on Milan processor with the following kernel parameters
- [spec_control_bypass_disable = {off,on}] with
and verified SPEC_CTRL_MSR value (0x48) on all CPUs is the same
and reflects the kernel parameters

Modified kernel to not set STIBP unconditionally (Bit 1) and
verified the SPEC_CTRL_MSR with the same kernel parameters

Disabled all features that write to MSR_IA32_SPEC_CTRL and toggled
predict_store_fwd. Verified MSR_IA32_SPEC_CTRL and x86_spec_ctrl_base
are set properly

- Tested on Rome systems (PSF feature is not supported)
Verified SPEC_CTRL_MSR MSR value on all logical CPUs.

Write to MSR_IA32_SPEC_CTRL properly
Read MSR, modify PSFD bit based on kernel parameter and
write back to MSR.

Changes made in psf_cmdline() and check_bugs().
Set the X86_FEATURE_SPEC_CTRL_MSR cap in boot cpu caps.
Fix kernel documentation for the kernel parameter.
Rename PSF to a control instead of mitigation.

- Smashed multiple commits into one commit.
- Rename PSF to a control instead of mitigation.

- Initial patchset.
- Kernel parameter controls enable and disable of PSF.

Ramakrishna Saripalli (1):
x86/cpufeatures: Implement Predictive Store Forwarding control.

.../admin-guide/kernel-parameters.txt | 5 ++++
arch/x86/include/asm/cpufeatures.h | 1 +
arch/x86/include/asm/msr-index.h | 2 ++
arch/x86/kernel/cpu/amd.c | 23 +++++++++++++++++++
arch/x86/kernel/cpu/bugs.c | 6 ++++-
5 files changed, 36 insertions(+), 1 deletion(-)

base-commit: 0e16f466004d7f04296b9676a712a32a12367d1f