#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/completion.h>
#include <linux/cpu.h>
#include <linux/cpumask.h>
#include <linux/ktime.h>
#include <linux/module.h>
#include <linux/smp.h>
#include <linux/workqueue.h>
#define STALL_MS_MAX 10000
static unsigned int stall_ms = 1000;
module_param(stall_ms, uint, 0444);
MODULE_PARM_DESC(stall_ms, "Time the target CPU ignores the IPI, in milliseconds.");
static int stall_cpu = -1;
module_param(stall_cpu, int, 0444);
MODULE_PARM_DESC(stall_cpu, "CPU to stall, or -1 for the first online one.");
static bool in_handler;
module_param(in_handler, bool, 0444);
MODULE_PARM_DESC(in_handler, "Stall inside a CSD handler instead of with interrupts disabled.");
static int target_cpu;
static bool target_stalling;
static bool hog_launched;
static struct work_struct irqoff_work;
static struct work_struct sender_work;
static call_single_data_t hog_csd;
static DECLARE_COMPLETION(hog_done);
static void csd_test_nop(void *unused)
{
}
static void csd_test_spin(void)
{
u64 end = ktime_get_mono_fast_ns() + (u64)stall_ms * NSEC_PER_MSEC;
while (ktime_get_mono_fast_ns() < end)
cpu_relax();
}
static void csd_test_irqoff_fn(struct work_struct *work)
{
local_irq_disable();
smp_store_release(&target_stalling, true);
csd_test_spin();
local_irq_enable();
}
static void csd_test_hog_fn(void *unused)
{
smp_store_release(&target_stalling, true);
csd_test_spin();
complete(&hog_done);
}
static void csd_test_sender_fn(struct work_struct *work)
{
u64 deadline, ts;
int err;
if (in_handler) {
hog_csd.func = csd_test_hog_fn;
err = smp_call_function_single_async(target_cpu, &hog_csd);
if (err) {
pr_err("cannot queue the CSD handler on CPU%d: %d\n", target_cpu, err);
return;
}
} else {
queue_work_on(target_cpu, system_highpri_wq, &irqoff_work);
}
WRITE_ONCE(hog_launched, true);
deadline = ktime_get_mono_fast_ns() + (u64)STALL_MS_MAX * NSEC_PER_MSEC;
while (!smp_load_acquire(&target_stalling)) {
if (ktime_get_mono_fast_ns() > deadline) {
pr_err("CPU%d never stopped answering\n", target_cpu);
return;
}
cpu_relax();
}
ts = ktime_get_mono_fast_ns();
smp_call_function_single(target_cpu, csd_test_nop, NULL, 1);
pr_info("CPU%d answered after %llu ns\n", target_cpu,
ktime_get_mono_fast_ns() - ts);
}
static int __init test_csd_lock_init(void)
{
int sender_cpu;
int ret = 0;
if (!stall_ms || stall_ms > STALL_MS_MAX) {
pr_err("stall_ms must be between 1 and %d\n", STALL_MS_MAX);
return -EINVAL;
}
INIT_WORK(&irqoff_work, csd_test_irqoff_fn);
INIT_WORK(&sender_work, csd_test_sender_fn);
cpus_read_lock();
target_cpu = stall_cpu < 0 ? cpumask_first(cpu_online_mask) : stall_cpu;
sender_cpu = nr_cpu_ids;
if (target_cpu < nr_cpu_ids && cpu_online(target_cpu))
sender_cpu = cpumask_any_but(cpu_online_mask, target_cpu);
if (sender_cpu >= nr_cpu_ids) {
pr_err("need CPU%d and one other CPU online\n", target_cpu);
ret = -EINVAL;
goto unlock;
}
pr_info("stalling CPU%d for %u ms %s, IPI from CPU%d\n", target_cpu, stall_ms,
in_handler ? "inside a CSD handler" : "with interrupts disabled", sender_cpu);
queue_work_on(sender_cpu, system_highpri_wq, &sender_work);
flush_work(&sender_work);
flush_work(&irqoff_work);
if (in_handler && READ_ONCE(hog_launched) &&
!wait_for_completion_timeout(&hog_done, msecs_to_jiffies(2 * STALL_MS_MAX)))
pr_err("CSD handler on CPU%d never finished\n", target_cpu);
ret = -EAGAIN;
unlock:
cpus_read_unlock();
return ret;
}
module_init(test_csd_lock_init);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Breno Leitao <leitao@debian.org>");
MODULE_DESCRIPTION("Test module to stall a CPU on a CSD lock"