Re: [PATCH v2 11/17] platform/x86/intel/ifs: Track and report scan results on a per-CPU basis

From: Ilpo Järvinen

Date: Thu Nov 19 2026 - 07:01:18 EST


On Wed, 18 Nov 2026, Ehab Ababneh wrote:

> From: Jithu Joseph <jithu.joseph@xxxxxxxxx>
>
> IFS requires invoking the scan simultaneously within a group of CPUs, as
> indicated in the MSR_INTEGRITY_CAPABILITIES (bits 20:16). When bit 21 is
> set, it indicates that all threads in the groups need to trigger the test
> at the same time.
>
> When the tests are run simultaneously, record the test results in a
> per-CPU structure. This reduces the need to redundantly repeat the test
> for all thread in the same group.
>
> There are several benefits:
>
> - Reduced power consumption by avoiding multiple scans.
>
> - Decreased time to complete a scan by 50% or more.
>
> - These tests could take up to 200ms. Prevents taking these cores out
> of circulation just to repeat tests that have already been conducted.
>
> The cores in a group share a scan engine but each reports its own
> result, and they can differ. So when a test is restarted, restart from
> the lowest chunk any CPU in the group reached. When the driver marks a
> test as timed out or partially completed, keep any error code a CPU's
> hardware reported. When warning about an incomplete group, look at the
> results of all CPUs in the group, not only the CPU being tested.
>
> Signed-off-by: Jithu Joseph <jithu.joseph@xxxxxxxxx>
> Signed-off-by: Ehab Ababneh <ehab.ababneh@xxxxxxxxx>
> Tested-by: Yi Lai <yi1.lai@xxxxxxxxx>
> ---
> drivers/platform/x86/intel/ifs/core.c | 14 +-
> drivers/platform/x86/intel/ifs/ifs.h | 12 ++
> drivers/platform/x86/intel/ifs/runtest.c | 171 ++++++++++++++++++-----
> 3 files changed, 161 insertions(+), 36 deletions(-)
>
> diff --git a/drivers/platform/x86/intel/ifs/core.c b/drivers/platform/x86/intel/ifs/core.c
> index b9ac04228141..e019c986ac0d 100644
> --- a/drivers/platform/x86/intel/ifs/core.c
> +++ b/drivers/platform/x86/intel/ifs/core.c
> @@ -49,6 +49,8 @@ static const struct ifs_test_msrs scan_msrs = {
> .test_ctrl = MSR_SAF_CTRL,
> };
>
> +DEFINE_PER_CPU(struct ifs_test_output, ifs_scan_n);
> +
> static struct ifs_device ifs_devices[] = {
> [IFS_TYPE_SAF] = {
> .test_caps = &scan_test,
> @@ -58,6 +60,9 @@ static struct ifs_device ifs_devices[] = {
> .minor = MISC_DYNAMIC_MINOR,
> .groups = plat_ifs_groups,
> },
> + .rw_data = {
> + .result_ptr = &ifs_scan_n,
> + }

Add trailing command to all non-terminator entiries.

> },
> [IFS_TYPE_ARRAY_BIST] = {
> .test_caps = &array_test,
> @@ -86,7 +91,7 @@ static int __init ifs_init(void)
> {
> const struct x86_cpu_id *m;
> u64 msrval;
> - int i, ret;
> + int i, ret, cpu;
>
> m = x86_match_cpu(ifs_cpu_ids);
> if (!m)
> @@ -105,6 +110,13 @@ static int __init ifs_init(void)
> if (!ifs_pkg_auth)
> return -ENOMEM;
>
> + /*
> + * Clear the per-CPU results before misc_register() below makes
> + * run_test visible to user space, so no test can be running yet.
> + */
> + for_each_possible_cpu(cpu)
> + memset(per_cpu_ptr(&ifs_scan_n, cpu), 0, sizeof(struct ifs_test_output));

Put the pointer into a temporary local variable and do sizeof(*that_var).

IMO, best is to declare it right within the loop.

> +
> for (i = 0; i < IFS_NUMTESTS; i++) {
> if (!(msrval & BIT(ifs_devices[i].test_caps->integrity_cap_bit)))
> continue;
> diff --git a/drivers/platform/x86/intel/ifs/ifs.h b/drivers/platform/x86/intel/ifs/ifs.h
> index 62db0a6aa940..acf8d8a7b105 100644
> --- a/drivers/platform/x86/intel/ifs/ifs.h
> +++ b/drivers/platform/x86/intel/ifs/ifs.h
> @@ -130,6 +130,7 @@
> */
> #include <linux/device.h>
> #include <linux/miscdevice.h>
> +#include <linux/percpu-defs.h>
>
> #define MSR_ARRAY_BIST 0x00000105
> #define MSR_COPY_SCAN_HASHES 0x000002c2
> @@ -290,6 +291,7 @@ struct ifs_test_msrs {
> * @loaded: If a valid test binary has been loaded into the memory
> * @loading_error: Error occurred on another CPU while loading image
> * @valid_chunks: number of chunks which could be validated.
> + * @cpu: The CPU on which the test was triggered
> * @status: it holds simple status pass/fail/untested
> * @scan_details: opaque scan status code from h/w
> * @cur_batch: number indicating the currently loaded test file
> @@ -298,6 +300,7 @@ struct ifs_test_msrs {
> * @array_gen: test generation of array test
> * @all_lp_join: all logical processors join test
> * @tid_bit_shift: APIC-ID bits of the logical processors sharing a scan engine
> + * @result_ptr: points to percpu result
> */
> struct ifs_data {
> cpumask_t grp_cpumask;
> @@ -305,6 +308,7 @@ struct ifs_data {
> bool loaded;
> bool loading_error;
> int valid_chunks;
> + int cpu;
> int status;
> u64 scan_details;
> u32 cur_batch;
> @@ -313,6 +317,7 @@ struct ifs_data {
> u32 array_gen;
> bool all_lp_join;
> u8 tid_bit_shift;
> + struct ifs_test_output __percpu *result_ptr;
> };
>
> struct ifs_work {
> @@ -327,6 +332,13 @@ struct ifs_device {
> struct miscdevice misc;
> };
>
> +struct ifs_test_output {
> + u64 test_details;
> + int test_result;
> +};
> +
> +DECLARE_PER_CPU(struct ifs_test_output, ifs_scan_n);
> +
> static inline struct ifs_data *ifs_get_data(struct device *dev)
> {
> struct miscdevice *m = dev_get_drvdata(dev);
> diff --git a/drivers/platform/x86/intel/ifs/runtest.c b/drivers/platform/x86/intel/ifs/runtest.c
> index 783b29f234ba..b93d8de4ca06 100644
> --- a/drivers/platform/x86/intel/ifs/runtest.c
> +++ b/drivers/platform/x86/intel/ifs/runtest.c
> @@ -83,25 +83,21 @@ static void message_not_tested(struct device *dev, int cpu, union ifs_status sta
> * been corrupted. Reloading the image may fix this issue.
> */
> if (status.control_error) {
> - dev_warn(dev, "CPU(s) %*pbl: Scan controller error. Batch: %02x version: 0x%x\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)), ifsd->cur_batch, ifsd->loaded_version);
> + dev_warn(dev, "CPU %d: Scan controller error. Batch: %02x version: 0x%x\n", cpu,
> + ifsd->cur_batch, ifsd->loaded_version);
> return;
> }
>
> if (status.error_code < ARRAY_SIZE(scan_test_status)) {
> - dev_info(dev, "CPU(s) %*pbl: SCAN operation did not start. %s\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)),
> + dev_info(dev, "CPU %d: SCAN operation did not start. %s\n", cpu,
> scan_test_status[status.error_code]);
> } else if (status.error_code == IFS_SW_TIMEOUT) {
> - dev_info(dev, "CPU(s) %*pbl: software timeout during scan\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)));
> + dev_info(dev, "CPU %d: software timeout during scan\n", cpu);
> } else if (status.error_code == IFS_SW_PARTIAL_COMPLETION) {
> - dev_info(dev, "CPU(s) %*pbl: %s\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)),
> + dev_info(dev, "CPU %d: %s\n", cpu,
> "Not all scan chunks were executed. Maximum forward progress retries exceeded");
> } else {
> - dev_info(dev, "CPU(s) %*pbl: SCAN unknown status %llx\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)), status.data);
> + dev_info(dev, "CPU %d: SCAN unknown status %llx\n", cpu, status.data);
> }
> }
>
> @@ -117,8 +113,8 @@ static void message_fail(struct device *dev, int cpu, union ifs_status status)
> * the core being tested.
> */
> if (status.signature_error) {
> - dev_err(dev, "CPU(s) %*pbl: test signature incorrect. Batch: %02x version: 0x%x\n",
> - cpumask_pr_args(cpu_smt_mask(cpu)), ifsd->cur_batch, ifsd->loaded_version);
> + dev_err(dev, "CPU %d: test signature incorrect. Batch: %02x version: 0x%x\n",
> + cpu, ifsd->cur_batch, ifsd->loaded_version);
> }
> }
>
> @@ -177,12 +173,13 @@ static void wait_for_sibling_cpu(struct ifs_data *ifsd, atomic_t *t, long long t
> static int doscan(void *data)
> {
> int cpu = smp_processor_id(), start, stop;
> + struct ifs_test_output *pcpu_scan;
> struct run_params *params = data;
> union ifs_status status;
> struct ifs_data *ifsd;
> - int first;
>
> ifsd = params->ifsd;
> + pcpu_scan = this_cpu_ptr(ifsd->result_ptr);
>
> if (ifsd->generation) {
> start = params->activate->gen2.start;
> @@ -192,9 +189,6 @@ static int doscan(void *data)
> stop = params->activate->gen0.stop;
> }
>
> - /* Only the first logical CPU on a core reports result */
> - first = cpumask_first(&ifsd->grp_cpumask);
> -
> wait_for_sibling_cpu(ifsd, &scan_cpus_in, NSEC_PER_SEC);
>
> /*
> @@ -211,12 +205,103 @@ static int doscan(void *data)
> trace_ifs_status(ifsd->cur_batch, start, stop, status.data);
>
> /* Pass back the result of the scan */
> - if (cpu == first)
> + if (cpu == ifsd->cpu)
> params->status = status;
>
> + pcpu_scan->test_details = status.data;
> +
> return 0;
> }
>
> +#define get_scan_status(stat) ((union ifs_status *)(&((stat)->test_details)))

Can't this be static function which allows getting rid of most
of those parenthesis?

> +static void update_group_status(struct device *dev, int reason)
> +{
> + struct ifs_data *ifsd = ifs_get_data(dev);
> + struct ifs_test_output *pcpu_scan;
> + union ifs_status *scan_status;
> + int lcpu;
> +
> + for_each_cpu(lcpu, &ifsd->grp_cpumask) {
> + pcpu_scan = per_cpu_ptr(ifsd->result_ptr, lcpu);
> + scan_status = get_scan_status(pcpu_scan);
> + /* Don't hide an error code reported by the hardware */
> + if (scan_status->error_code == IFS_NO_ERROR)
> + scan_status->error_code = reason;
> + }
> +}
> +
> +static bool can_restart_test_group(struct device *dev)
> +{
> + struct ifs_data *ifsd = ifs_get_data(dev);
> + struct ifs_test_output *pcpu_scan;
> + union ifs_status *scan_status;
> + int lcpu;
> +
> + for_each_cpu(lcpu, &ifsd->grp_cpumask) {
> + pcpu_scan = per_cpu_ptr(ifsd->result_ptr, lcpu);
> + scan_status = get_scan_status(pcpu_scan);
> + if (!can_restart(*scan_status))
> + return false;
> + }
> + return true;
> +}
> +
> +/*
> + * The cores in a group can stop at different chunks. Return the lowest
> + * chunk reached so that no CPU skips chunks when the test is restarted.
> + */
> +static u32 group_min_chunk(struct ifs_data *ifsd)
> +{
> + struct ifs_test_output *pcpu_scan;
> + union ifs_status *scan_status;
> + u32 chunk, min_chunk = U32_MAX;
> + int lcpu;
> +
> + for_each_cpu(lcpu, &ifsd->grp_cpumask) {
> + pcpu_scan = per_cpu_ptr(ifsd->result_ptr, lcpu);
> + scan_status = get_scan_status(pcpu_scan);

These three lines seem to repeat, so consider adding some local
for_each_... macro for these iterations.

> + chunk = ifsd->generation ? scan_status->gen2.chunk_num :
> + scan_status->gen0.chunk_num;
> + min_chunk = min(min_chunk, chunk);
> + }
> +
> + return min_chunk;
> +}
> +
> +static void update_group_result(struct device *dev, int stop_chunk)
> +{
> + struct ifs_data *ifsd = ifs_get_data(dev);
> + struct ifs_test_output *pcpu_scan;
> + union ifs_status *scan_status;
> + u32 reached_chunk;
> + int lcpu;
> +
> + for_each_cpu(lcpu, &ifsd->grp_cpumask) {
> + pcpu_scan = per_cpu_ptr(ifsd->result_ptr, lcpu);
> + scan_status = get_scan_status(pcpu_scan);
> + reached_chunk = ifsd->generation ? scan_status->gen2.chunk_num :
> + scan_status->gen0.chunk_num;
> +
> + if (scan_status->signature_error) {
> + pcpu_scan->test_result = SCAN_TEST_FAIL;
> + message_fail(dev, lcpu, *scan_status);
> + } else if (scan_status->control_error || scan_status->error_code ||
> + reached_chunk <= stop_chunk) {
> + /* E.g. another CPU in the group stopped the scan */
> + if (!scan_status->control_error && !scan_status->error_code)
> + scan_status->error_code = IFS_SW_PARTIAL_COMPLETION;
> + pcpu_scan->test_result = SCAN_NOT_TESTED;
> + message_not_tested(dev, lcpu, *scan_status);
> + } else {
> + pcpu_scan->test_result = SCAN_TEST_PASS;
> + }
> +
> + if (lcpu == ifsd->cpu)
> + ifsd->status = pcpu_scan->test_result;
> + }
> +}
> +
> /*
> * Use stop_core_cpuslocked() to synchronize writing to MSR_ACTIVATE_SCAN
> * on all threads of the core to be tested. Loop if necessary to complete
> @@ -232,9 +317,14 @@ static void ifs_test_core(int cpu, struct device *dev)
> int to_start, to_stop;
> int status_chunk;
> struct run_params params;
> - int retries;
> + int retries, lcpu;
>
> ifsd = ifs_get_data(dev);
> + ifsd->cpu = cpu;
> +
> + /* Don't let results from a previous test leak into this one */
> + for_each_cpu(lcpu, &ifsd->grp_cpumask)
> + memset(per_cpu_ptr(ifsd->result_ptr, lcpu), 0, sizeof(struct ifs_test_output));

Local var similar to above.

>
> activate.gen0.rsvd = 0;
> activate.delay = IFS_THREAD_WAIT;
> @@ -258,6 +348,7 @@ static void ifs_test_core(int cpu, struct device *dev)
> while (to_start <= to_stop) {
> if (time_after(jiffies, timeout)) {
> status.error_code = IFS_SW_TIMEOUT;
> + update_group_status(dev, IFS_SW_TIMEOUT);
> break;
> }
>
> @@ -272,15 +363,16 @@ static void ifs_test_core(int cpu, struct device *dev)
> status = params.status;
>
> /* Some cases can be retried, give up for others */
> - if (!can_restart(status))
> + if (!can_restart_test_group(dev))
> break;
>
> - status_chunk = ifsd->generation ? status.gen2.chunk_num : status.gen0.chunk_num;
> + status_chunk = group_min_chunk(ifsd);
> if (status_chunk == to_start) {
> /* Check for forward progress */
> if (--retries == 0) {
> if (status.error_code == IFS_NO_ERROR)
> status.error_code = IFS_SW_PARTIAL_COMPLETION;
> + update_group_status(dev, IFS_SW_PARTIAL_COMPLETION);
> break;
> }
> } else {
> @@ -295,16 +387,7 @@ static void ifs_test_core(int cpu, struct device *dev)
>
> /* Update status for this core */
> ifsd->scan_details = status.data;
> -
> - if (status.signature_error) {
> - ifsd->status = SCAN_TEST_FAIL;
> - message_fail(dev, cpu, status);
> - } else if (status.control_error || status.error_code) {
> - ifsd->status = SCAN_NOT_TESTED;
> - message_not_tested(dev, cpu, status);
> - } else {
> - ifsd->status = SCAN_TEST_PASS;
> - }
> + update_group_result(dev, to_stop);
> }
>
> static int do_array_test(void *data)
> @@ -313,7 +396,6 @@ static int do_array_test(void *data)
> int cpu = smp_processor_id();
> union ifs_array *command;
> struct ifs_data *ifsd;
> - int first;
>
> ifsd = params->ifsd;
>
> @@ -323,9 +405,7 @@ static int do_array_test(void *data)
> /*
> * Only one logical CPU on a core needs to trigger the Array test via MSR write.
> */
> - first = cpumask_first(&ifsd->grp_cpumask);
> -
> - if (cpu == first) {
> + if (cpu == ifsd->cpu) {
> wrmsrq(MSR_ARRAY_BIST, command->data);
> /* Pass back the result of the test */
> rdmsrq(MSR_ARRAY_BIST, command->data);
> @@ -343,6 +423,7 @@ static void ifs_array_test_core(int cpu, struct device *dev)
> unsigned long timeout;
>
> ifsd = ifs_get_data(dev);
> + ifsd->cpu = cpu;
> params.ifsd = ifsd;
>
> command.array_bitmask = ~0U;
> @@ -451,6 +532,26 @@ static bool ifs_group_incomplete(int cpu, struct ifs_data *ifsd)
> return false;
> }
>
> +/*
> + * For a scan test, check the result of every CPU in the group, since the
> + * cores in a group can report different results. Array tests only have
> + * the result of the target CPU.
> + */
> +static bool ifs_test_passed(int test_num, struct ifs_data *ifsd)
> +{
> + int lcpu;
> +
> + if (test_num != IFS_TYPE_SAF)
> + return ifsd->status == SCAN_TEST_PASS;
> +
> + for_each_cpu(lcpu, &ifsd->grp_cpumask) {
> + if (per_cpu_ptr(ifsd->result_ptr, lcpu)->test_result != SCAN_TEST_PASS)
> + return false;
> + }
> +
> + return true;
> +}
> +
> /*
> * Initiate per core test. It wakes up work queue threads on the target CPU and
> * its sibling CPU. Once all sibling threads wake up, the scan test gets executed and
> @@ -491,7 +592,7 @@ int do_core_test(int cpu, struct device *dev)
> ret = -EINVAL;
> }
>
> - if (!ret && ifsd->status != SCAN_TEST_PASS && ifs_group_incomplete(cpu, ifsd))
> + if (!ret && !ifs_test_passed(test->test_num, ifsd) && ifs_group_incomplete(cpu, ifsd))
> dev_warn(dev, "CPU %d: test did not pass; not all CPUs sharing the scan engine were found (group %*pbl)\n",
> cpu, cpumask_pr_args(&ifsd->grp_cpumask));
> out:
>

--
i.