/*
 * SPDX-License-Identifier: GPL-2.0
 *
 * Copyright (C) 2017 Philippe Gerum  <rpm@xenomai.org>.
 */
#include <linux/kernel.h>
#include <linux/torture.h>
#include <linux/printk.h>
#include <linux/delay.h>
#include <linux/tick.h>
#include <linux/smp.h>
#include <linux/cpumask.h>
#include <linux/clockchips.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/irq_pipeline.h>
#include <linux/stop_machine.h>
#include <linux/irq_work.h>
#include <linux/completion.h>
#include <linux/slab.h>
#include "settings.h"

static void torture_event_handler(struct clock_event_device *dev)
{
	/*
	 * We are running on the oob stage, in NMI-like mode. Schedule
	 * a tick on the proxy device to satisfy the corresponding
	 * timing request asap.
	 */
	tick_notify_proxy();
}

static void setup_proxy(struct clock_proxy_device *dev)
{
	dev->handle_oob_event = torture_event_handler;
}

static int start_tick_takeover_test(void)
{
	return tick_install_proxy(setup_proxy, cpu_online_mask);
}

static void stop_tick_takeover_test(void)
{
	tick_uninstall_proxy(cpu_online_mask);
}

struct stop_machine_p_data {
	int origin_cpu;
	cpumask_var_t disable_mask;
};

static int stop_machine_handler(void *arg)
{
	struct stop_machine_p_data *p = arg;
	int cpu = raw_smp_processor_id();

	/*
	 * The stop_machine() handler must run with hard
	 * IRQs off, note the current state in the result mask.
	 */
	if (hard_irqs_disabled())
		cpumask_set_cpu(cpu, p->disable_mask);

	if (cpu != p->origin_cpu)
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d responds to stop_machine()\n", cpu);
	return 0;
}

/*
 * We test stop_machine() as a way to validate IPI handling in a
 * pipelined interrupt context.
 */
static int test_stop_machine(void)
{
	struct stop_machine_p_data d;
	cpumask_var_t tmp_mask;
	int ret = -ENOMEM, cpu;

	if (!zalloc_cpumask_var(&d.disable_mask, GFP_KERNEL)) {
		WARN_ON(1);
		return ret;
	}

	if (!alloc_cpumask_var(&tmp_mask, GFP_KERNEL)) {
		WARN_ON(1);
		goto fail;
	}

	ret = -EINVAL;
	d.origin_cpu = raw_smp_processor_id();
	pr_alert("irq_pipeline" TORTURE_FLAG
		 " CPU%d initiates stop_machine()\n",
		 d.origin_cpu);

	ret = stop_machine(stop_machine_handler, &d, cpu_online_mask);
	WARN_ON(ret);
	if (ret)
		goto fail;

	/*
	 * Check whether all handlers did run with hard IRQs off. If
	 * some of them did not, then we have a problem with the stop
	 * IRQ delivery.
	 */
	cpumask_xor(tmp_mask, cpu_online_mask, d.disable_mask);
	if (!cpumask_empty(tmp_mask)) {
		for_each_cpu(cpu, tmp_mask)
			pr_alert("irq_pipeline" TORTURE_FLAG
				 " CPU%d: hard IRQs ON in stop_machine()"
				 " handler!\n", cpu);
	}

	free_cpumask_var(tmp_mask);
fail:
	free_cpumask_var(d.disable_mask);

	return ret;
}

static struct irq_work_tester {
	struct irq_work work;
	struct completion done;
} irq_work_tester;

static void irq_work_handler(struct irq_work *work)
{
	int cpu = raw_smp_processor_id();

	if (!running_inband()) {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: irq_work handler not running on"
			 " in-band stage?!\n", cpu);
		return;
	}

	if (work != &irq_work_tester.work)
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: irq_work handler received broken"
			 " arg?!\n", cpu);
	else {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: irq_work handled\n", cpu);
		complete(&irq_work_tester.done);
	}
}

static int trigger_oob_work(void *arg)
{
	int cpu = raw_smp_processor_id();

	if (!running_oob()) {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: escalated request not running on"
			 " oob stage?!\n", cpu);
		return -EINVAL;
	}

	if ((struct irq_work_tester *)arg != &irq_work_tester) {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: escalation handler received broken"
			 " arg?!\n", cpu);
		return -EINVAL;
	}

	irq_work_queue(&irq_work_tester.work);
	pr_alert("irq_pipeline" TORTURE_FLAG
		 " CPU%d: stage escalation request works\n",
		 cpu);

	return 0;
}

static int test_interstage_work_injection(void)
{
	struct irq_work_tester *p = &irq_work_tester;
	int ret, cpu = raw_smp_processor_id();
	unsigned long rem;

	init_completion(&p->done);
	init_irq_work(&p->work, irq_work_handler);

	/* Trigger over the in-band stage. */
	irq_work_queue(&p->work);
	rem = wait_for_completion_timeout(&p->done, HZ / 10);
	if (!rem) {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: irq_work trigger from in-band stage not handled!\n",
			 cpu);
		return -EINVAL;
	}

	pr_alert("irq_pipeline" TORTURE_FLAG
		 " CPU%d: in-band->in-band irq_work trigger works\n", cpu);

	reinit_completion(&p->done);

	/* Now try over the oob stage. */
	ret = run_oob_call(trigger_oob_work, p);
	if (ret)
		return ret;

	ret = wait_for_completion_timeout(&p->done, HZ / 10);
	if (!rem) {
		pr_alert("irq_pipeline" TORTURE_FLAG
			 " CPU%d: irq_work trigger from oob"
			 " stage not handled!\n", cpu);
		return -EINVAL;
	}

	pr_alert("irq_pipeline" TORTURE_FLAG
		 " CPU%d: oob->in-band irq_work trigger works\n",
		 cpu);

	return 0;
}

static int __init irqp_torture_init(void)
{
	int ret;

	pr_info("Starting IRQ pipeline tests...");

	ret = enable_oob_stage("torture");
	if (ret) {
		if (ret == -EBUSY)
			pr_alert("irq_pipeline" TORTURE_FLAG
			 " won't run, oob stage '%s' is already installed",
			 oob_stage.name);

		return ret;
	}

	ret = test_stop_machine();
	if (ret)
		goto out;

	ret = start_tick_takeover_test();
	if (ret)
		goto out;

	ret = test_interstage_work_injection();
	if (!ret)
		msleep(1000);

	stop_tick_takeover_test();
out:
	disable_oob_stage();
	pr_info("IRQ pipeline tests %s.", ret ? "FAILED" : "OK");

	return 0;
}
late_initcall(irqp_torture_init);