From: "Ilpo Järvinen" <ilpo.jarvinen@linux.intel.com>
To: Ehab Ababneh <ehab.ababneh@intel.com>
Cc: Hans de Goede <hansg@kernel.org>,
tony.luck@intel.com, ashok.raj.linux@gmail.com,
platform-driver-x86@vger.kernel.org,
LKML <linux-kernel@vger.kernel.org>,
tglx@kernel.org, mingo@redhat.com, bp@alien8.de,
dave.hansen@linux.intel.com, x86@kernel.org, hpa@zytor.com,
rostedt@goodmis.org, mhiramat@kernel.org,
mathieu.desnoyers@efficios.com,
linux-trace-kernel@vger.kernel.org, peterz@infradead.org,
sathyanarayanan.kuppuswamy@linux.intel.com,
pengfei.xu@intel.com, ravi.v.shankar@intel.com
Subject: Re: [PATCH v2 11/17] platform/x86/intel/ifs: Track and report scan results on a per-CPU basis
Date: Thu, 19 Nov 2026 14:00:52 +0200 (EET) [thread overview]
Message-ID: <7c9226eb-24d0-6756-1f0a-66cfada6d743@linux.intel.com> (raw)
In-Reply-To: <20261118193259.519568-12-ehab.ababneh@intel.com>
On Wed, 18 Nov 2026, Ehab Ababneh wrote:
> From: Jithu Joseph <jithu.joseph@intel.com>
>
> 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@intel.com>
> Signed-off-by: Ehab Ababneh <ehab.ababneh@intel.com>
> Tested-by: Yi Lai <yi1.lai@intel.com>
> ---
> 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.
next prev parent reply other threads:[~2026-11-19 12:01 UTC|newest]
Thread overview: 26+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 19:32 [PATCH v2 00/17] platform/x86/intel/ifs: Support group-based In-Field Scan and Diamond Rapids Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 01/17] platform/x86/intel/ifs: Revert SBAF feature Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 02/17] platform/x86/intel/ifs: Fix IFS sysfs interfaces in the comments Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 03/17] platform/x86/intel/ifs: Clarify In-Field Scan MSR bit macro definitions Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 04/17] platform/x86/intel/ifs: Use u64 to define the bits of IFS MSR registers Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 05/17] platform/x86/intel/ifs: Early return on the IFS image hash/chunk error Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 06/17] platform/x86/intel/ifs: Refactor Array BIST function interface Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 07/17] stop_machine: Add stop_cluster_cpuslocked() for per-cluster operations Ehab Ababneh
2026-11-19 11:28 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 08/17] platform/x86/intel/ifs: Enumerate the bit to determine if CPUs need to join for IFS tests Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 09/17] platform/x86/intel/ifs: Select CPUs from topology_cluster_cpumask() for simultaneous " Ehab Ababneh
2026-11-19 11:38 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 10/17] platform/x86/intel/ifs: Warn if a group test fails with CPUs missing Ehab Ababneh
2026-11-19 11:42 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 11/17] platform/x86/intel/ifs: Track and report scan results on a per-CPU basis Ehab Ababneh
2026-11-19 12:00 ` Ilpo Järvinen [this message]
2026-11-18 19:32 ` [PATCH v2 12/17] platform/x86/intel/ifs: Add new sysfs interfaces {status, details, cpus_ran}_list Ehab Ababneh
2026-11-19 12:06 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 13/17] platform/x86/intel/ifs: Add additional details sysfs interface Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 14/17] platform/x86/intel/ifs: Add Intel Diamond Rapids server support Ehab Ababneh
2026-11-18 19:32 ` [PATCH v2 15/17] platform/x86/intel/ifs: Remove limit on number of batch files Ehab Ababneh
2026-11-19 12:09 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 16/17] platform/x86/intel/ifs: Update IFS documentation Ehab Ababneh
2026-11-19 12:12 ` Ilpo Järvinen
2026-11-18 19:32 ` [PATCH v2 17/17] Documentation/ABI: Update IFS ABI doc Ehab Ababneh
2026-11-19 12:13 ` Ilpo Järvinen
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=7c9226eb-24d0-6756-1f0a-66cfada6d743@linux.intel.com \
--to=ilpo.jarvinen@linux.intel.com \
--cc=ashok.raj.linux@gmail.com \
--cc=bp@alien8.de \
--cc=dave.hansen@linux.intel.com \
--cc=ehab.ababneh@intel.com \
--cc=hansg@kernel.org \
--cc=hpa@zytor.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-trace-kernel@vger.kernel.org \
--cc=mathieu.desnoyers@efficios.com \
--cc=mhiramat@kernel.org \
--cc=mingo@redhat.com \
--cc=pengfei.xu@intel.com \
--cc=peterz@infradead.org \
--cc=platform-driver-x86@vger.kernel.org \
--cc=ravi.v.shankar@intel.com \
--cc=rostedt@goodmis.org \
--cc=sathyanarayanan.kuppuswamy@linux.intel.com \
--cc=tglx@kernel.org \
--cc=tony.luck@intel.com \
--cc=x86@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®