| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20200504150235.12171-6-alexandre.chartre@oracle.com>
Date: Mon, 4 May 2020 17:02:26 +0200
From: Alexandre Chartre <alexandre.chartre@...cle.com>
To: tglx@...utronix.de, mingo@...hat.com, bp@...en8.de, hpa@...or.com,
dave.hansen@...ux.intel.com, luto@...nel.org, peterz@...radead.org,
x86@...nel.org, linux-mm@...ck.org, linux-kernel@...r.kernel.org
Cc: pbonzini@...hat.com, konrad.wilk@...cle.com,
jan.setjeeilers@...cle.com, liran.alon@...cle.com,
junaids@...gle.com, graf@...zon.de, rppt@...ux.vnet.ibm.com,
kuzuno@...il.com, mgross@...ux.intel.com,
alexandre.chartre@...cle.com
Subject: [RFC v4][PATCH part-3 05/14] asidrv: Sequence to test interrupt on ASI
Add a sequence to test if an ASI remains active after receiving
an interrupt.
Signed-off-by: Alexandre Chartre <alexandre.chartre@...cle.com>
---
drivers/staging/asi/asidrv.c | 144 +++++++++++++++++++++++++++++++++--
drivers/staging/asi/asidrv.h | 5 ++
2 files changed, 144 insertions(+), 5 deletions(-)
diff --git a/drivers/staging/asi/asidrv.c b/drivers/staging/asi/asidrv.c
index 4231b56db167..a3c7da2bf16e 100644
--- a/drivers/staging/asi/asidrv.c
+++ b/drivers/staging/asi/asidrv.c
@@ -7,6 +7,7 @@
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/slab.h>
+#include <linux/workqueue.h>
#include <asm/asi.h>
#include <asm/dpt.h>
@@ -19,6 +20,12 @@
/* Number of read for mem/memmap test sequence */
#define ASIDRV_MEM_READ_COUNT 1000
+/* Timeout for target to be ready to receive an interrupt */
+#define ASIDRV_TIMEOUT_TARGET_READY 1
+
+/* Timeout for receiving an interrupt */
+#define ASIDRV_TIMEOUT_INTERRUPT 5
+
enum asidrv_state {
ASIDRV_STATE_NONE,
ASIDRV_STATE_INTR_WAITING,
@@ -29,6 +36,13 @@ struct asidrv_test {
struct asi *asi; /* ASI for testing */
struct dpt *dpt; /* ASI decorated page-table */
char *buffer; /* buffer for testing */
+
+ /* runtime */
+ atomic_t state; /* runtime state */
+ int cpu; /* cpu the test is running on */
+ struct work_struct work; /* work for other cpu */
+ bool work_set;
+ enum asidrv_run_error run_error;
};
struct asidrv_sequence {
@@ -160,6 +174,107 @@ static int asidrv_asi_is_active(struct asi *asi)
return false;
}
+/*
+ * Wait for an atomic value to be set or the timeout to expire.
+ * Return 0 if the value is set, or -1 if the timeout expires.
+ */
+static enum asidrv_run_error asidrv_wait(struct asidrv_test *test,
+ int value, unsigned int timeout)
+{
+ cycles_t start = get_cycles();
+ cycles_t stop = start + timeout * tsc_khz * 1000;
+
+ while (get_cycles() < stop) {
+ if (atomic_read(&test->state) == value ||
+ test->run_error != ASIDRV_RUN_ERR_NONE)
+ return test->run_error;
+ cpu_relax();
+ }
+
+ /* timeout reached */
+ return ASIDRV_RUN_ERR_TIMEOUT;
+}
+
+/*
+ * Wait for an atomic value to transition from the initial value (set
+ * on entry) to the final value, or to timeout. Return 0 if the transition
+ * was done, or -1 if the timeout expires.
+ */
+static enum asidrv_run_error asidrv_wait_transition(struct asidrv_test *test,
+ int initial, int final,
+ unsigned int timeout)
+{
+ /* set the initial state value */
+ atomic_set(&test->state, initial);
+
+ /* do an active wait for the state changes */
+ return asidrv_wait(test, final, timeout);
+}
+
+/*
+ * Interrupt Test Sequence
+ */
+
+static void asidrv_intr_handler(void *info)
+{
+ struct asidrv_test *test = info;
+
+ /* ASI should be interrupted by the interrupt */
+ if (asidrv_asi_is_active(test->asi)) {
+ test->run_error = ASIDRV_RUN_ERR_INTR_ASI_ACTIVE;
+ atomic_set(&test->state, ASIDRV_STATE_INTR_RECEIVED);
+ return;
+ }
+
+ pr_debug("Received interrupt\n");
+ atomic_set(&test->state, ASIDRV_STATE_INTR_RECEIVED);
+}
+
+static void asidrv_intr_send(struct work_struct *work)
+{
+ struct asidrv_test *test = container_of(work, struct asidrv_test, work);
+ enum asidrv_run_error err;
+
+ /* wait for cpu target to be ready, then send an interrupt */
+ err = asidrv_wait(test,
+ ASIDRV_STATE_INTR_WAITING,
+ ASIDRV_TIMEOUT_TARGET_READY);
+ if (err) {
+ pr_debug("Target cpu %d not ready, interrupt not sent: error %d\n",
+ test->cpu, err);
+ return;
+ }
+
+ pr_debug("Sending interrupt to cpu %d\n", test->cpu);
+ smp_call_function_single(test->cpu, asidrv_intr_handler,
+ test, false);
+}
+
+static enum asidrv_run_error asidrv_intr_setup(struct asidrv_test *test)
+{
+ /* set work to have another cpu to send us an interrupt */
+ INIT_WORK(&test->work, asidrv_intr_send);
+ test->work_set = true;
+ return ASIDRV_RUN_ERR_NONE;
+}
+
+static enum asidrv_run_error asidrv_intr_run(struct asidrv_test *test)
+{
+ enum asidrv_run_error err;
+
+ /* wait for state changes indicating that an interrupt was received */
+ err = asidrv_wait_transition(test,
+ ASIDRV_STATE_INTR_WAITING,
+ ASIDRV_STATE_INTR_RECEIVED,
+ ASIDRV_TIMEOUT_INTERRUPT);
+ if (err == ASIDRV_RUN_ERR_TIMEOUT) {
+ pr_debug("Interrupt wait timeout\n");
+ err = ASIDRV_RUN_ERR_INTR;
+ }
+
+ return err;
+}
+
/*
* Memory Buffer Access Test Sequences
*/
@@ -231,12 +346,18 @@ struct asidrv_sequence asidrv_sequences[] = {
"memmap",
asidrv_memmap_setup, asidrv_mem_run, asidrv_memmap_cleanup,
},
+ [ASIDRV_SEQ_INTERRUPT] = {
+ "interrupt",
+ asidrv_intr_setup, asidrv_intr_run, NULL,
+ },
};
static enum asidrv_run_error asidrv_run_init(struct asidrv_test *test)
{
int err;
+ test->run_error = ASIDRV_RUN_ERR_NONE;
+
/*
* Map the current stack, we need it to enter ASI.
*/
@@ -272,18 +393,31 @@ static void asidrv_run_fini(struct asidrv_test *test)
static enum asidrv_run_error asidrv_run_setup(struct asidrv_test *test,
struct asidrv_sequence *sequence)
{
- int run_err = ASIDRV_RUN_ERR_NONE;
+ unsigned int other_cpu;
+ int run_err;
+
+ test->work_set = false;
if (sequence->setup) {
run_err = sequence->setup(test);
if (run_err)
- goto failed;
+ return run_err;
}
- return ASIDRV_RUN_ERR_NONE;
+ if (test->work_set) {
+ other_cpu = cpumask_any_but(cpu_online_mask, test->cpu);
+ if (other_cpu == test->cpu) {
+ pr_debug("Sequence %s requires an extra online cpu\n",
+ sequence->name);
+ asidrv_run_cleanup(test, sequence);
+ return ASIDRV_RUN_ERR_NCPUS;
+ }
-failed:
- return run_err;
+ atomic_set(&test->state, ASIDRV_STATE_NONE);
+ schedule_work_on(other_cpu, &test->work);
+ }
+
+ return ASIDRV_RUN_ERR_NONE;
}
static void asidrv_run_cleanup(struct asidrv_test *test,
diff --git a/drivers/staging/asi/asidrv.h b/drivers/staging/asi/asidrv.h
index 1e820cc64f13..8055d96a0058 100644
--- a/drivers/staging/asi/asidrv.h
+++ b/drivers/staging/asi/asidrv.h
@@ -10,6 +10,7 @@ enum asidrv_seqnum {
ASIDRV_SEQ_PRINTK, /* printk sequence */
ASIDRV_SEQ_MEM, /* access unmapped memory */
ASIDRV_SEQ_MEMMAP, /* access mapped memory */
+ ASIDRV_SEQ_INTERRUPT, /* interrupt sequence */
};
enum asidrv_run_error {
@@ -20,6 +21,10 @@ enum asidrv_run_error {
ASIDRV_RUN_ERR_ENTER, /* failed to enter ASI */
ASIDRV_RUN_ERR_ACTIVE, /* ASI is not active after entering ASI */
ASIDRV_RUN_ERR_MAP_BUFFER, /* failed to map buffer */
+ ASIDRV_RUN_ERR_NCPUS, /* not enough active cpus */
+ ASIDRV_RUN_ERR_INTR, /* no interrupt received */
+ ASIDRV_RUN_ERR_INTR_ASI_ACTIVE, /* ASI active in interrupt handler */
+ ASIDRV_RUN_ERR_TIMEOUT,
};
#define ASIDRV_IOCTL_RUN_SEQUENCE _IOWR('a', 1, struct asidrv_run_param)
--
2.18.2
Powered by blists - more mailing lists