// SPDX-License-Identifier: GPL-2.0
/*
 * KUnit test for hw_breakpoint constraints accounting logic.
 *
 * Copyright (C) 2022, Google LLC.
 */

#include <kunit/test.h>
#include <linux/cpumask.h>
#include <linux/hw_breakpoint.h>
#include <linux/kthread.h>
#include <linux/perf_event.h>
#include <asm/hw_breakpoint.h>

#define TEST_REQUIRES_BP_SLOTS(test, slots)                                             \
        do {                                                                            \
                if ((slots) > get_test_bp_slots()) {                                    \
                        kunit_skip((test), "Requires breakpoint slots: %d > %d", slots, \
                                   get_test_bp_slots());                                \
                }                                                                       \
        } while (0)

#define TEST_EXPECT_NOSPC(expr) KUNIT_EXPECT_EQ(test, -ENOSPC, PTR_ERR(expr))

#define MAX_TEST_BREAKPOINTS 512

static char break_vars[MAX_TEST_BREAKPOINTS];
static struct perf_event *test_bps[MAX_TEST_BREAKPOINTS];
static struct task_struct *__other_task;

static struct perf_event *register_test_bp(int cpu, struct task_struct *tsk, int idx)
{
        struct perf_event_attr attr = {};

        if (WARN_ON(idx < 0 || idx >= MAX_TEST_BREAKPOINTS))
                return NULL;

        hw_breakpoint_init(&attr);
        attr.bp_addr = (unsigned long)&break_vars[idx];
        attr.bp_len = HW_BREAKPOINT_LEN_1;
        attr.bp_type = HW_BREAKPOINT_RW;
        return perf_event_create_kernel_counter(&attr, cpu, tsk, NULL, NULL);
}

static void unregister_test_bp(struct perf_event **bp)
{
        if (WARN_ON(IS_ERR(*bp)))
                return;
        if (WARN_ON(!*bp))
                return;
        unregister_hw_breakpoint(*bp);
        *bp = NULL;
}

static int get_test_bp_slots(void)
{
        static int slots;

        if (!slots)
                slots = hw_breakpoint_slots(TYPE_DATA);

        return slots;
}

static void fill_one_bp_slot(struct kunit *test, int *id, int cpu, struct task_struct *tsk)
{
        struct perf_event *bp = register_test_bp(cpu, tsk, *id);

        KUNIT_ASSERT_NOT_NULL(test, bp);
        KUNIT_ASSERT_FALSE(test, IS_ERR(bp));
        KUNIT_ASSERT_NULL(test, test_bps[*id]);
        test_bps[(*id)++] = bp;
}

/*
 * Fills up the given @cpu/@tsk with breakpoints, only leaving @skip slots free.
 *
 * Returns true if this can be called again, continuing at @id.
 */
static bool fill_bp_slots(struct kunit *test, int *id, int cpu, struct task_struct *tsk, int skip)
{
        for (int i = 0; i < get_test_bp_slots() - skip; ++i)
                fill_one_bp_slot(test, id, cpu, tsk);

        return *id + get_test_bp_slots() <= MAX_TEST_BREAKPOINTS;
}

static int dummy_kthread(void *arg)
{
        return 0;
}

static struct task_struct *get_other_task(struct kunit *test)
{
        struct task_struct *tsk;

        if (__other_task)
                return __other_task;

        tsk = kthread_create(dummy_kthread, NULL, "hw_breakpoint_dummy_task");
        KUNIT_ASSERT_FALSE(test, IS_ERR(tsk));
        __other_task = tsk;
        return __other_task;
}

static int get_test_cpu(int num)
{
        int cpu;

        WARN_ON(num < 0);

        for_each_online_cpu(cpu) {
                if (num-- <= 0)
                        break;
        }

        return cpu;
}

/* ===== Test cases ===== */

static void test_one_cpu(struct kunit *test)
{
        int idx = 0;

        fill_bp_slots(test, &idx, get_test_cpu(0), NULL, 0);
        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
}

static void test_many_cpus(struct kunit *test)
{
        int idx = 0;
        int cpu;

        /* Test that CPUs are independent. */
        for_each_online_cpu(cpu) {
                bool do_continue = fill_bp_slots(test, &idx, cpu, NULL, 0);

                TEST_EXPECT_NOSPC(register_test_bp(cpu, NULL, idx));
                if (!do_continue)
                        break;
        }
}

static void test_one_task_on_all_cpus(struct kunit *test)
{
        int idx = 0;

        fill_bp_slots(test, &idx, -1, current, 0);
        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        /* Remove one and adding back CPU-target should work. */
        unregister_test_bp(&test_bps[0]);
        fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
}

static void test_two_tasks_on_all_cpus(struct kunit *test)
{
        int idx = 0;

        /* Test that tasks are independent. */
        fill_bp_slots(test, &idx, -1, current, 0);
        fill_bp_slots(test, &idx, -1, get_other_task(test), 0);

        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        /* Remove one from first task and adding back CPU-target should not work. */
        unregister_test_bp(&test_bps[0]);
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
}

static void test_one_task_on_one_cpu(struct kunit *test)
{
        int idx = 0;

        fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        /*
         * Remove one and adding back CPU-target should work; this case is
         * special vs. above because the task's constraints are CPU-dependent.
         */
        unregister_test_bp(&test_bps[0]);
        fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
}

static void test_one_task_mixed(struct kunit *test)
{
        int idx = 0;

        TEST_REQUIRES_BP_SLOTS(test, 3);

        fill_one_bp_slot(test, &idx, get_test_cpu(0), current);
        fill_bp_slots(test, &idx, -1, current, 1);
        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));

        /* Transition from CPU-dependent pinned count to CPU-independent. */
        unregister_test_bp(&test_bps[0]);
        unregister_test_bp(&test_bps[1]);
        fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
        fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
}

static void test_two_tasks_on_one_cpu(struct kunit *test)
{
        int idx = 0;

        fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
        fill_bp_slots(test, &idx, get_test_cpu(0), get_other_task(test), 0);

        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        /* Can still create breakpoints on some other CPU. */
        fill_bp_slots(test, &idx, get_test_cpu(1), NULL, 0);
}

static void test_two_tasks_on_one_all_cpus(struct kunit *test)
{
        int idx = 0;

        fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
        fill_bp_slots(test, &idx, -1, get_other_task(test), 0);

        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        /* Cannot create breakpoints on some other CPU either. */
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));
}

static void test_task_on_all_and_one_cpu(struct kunit *test)
{
        int tsk_on_cpu_idx, cpu_idx;
        int idx = 0;

        TEST_REQUIRES_BP_SLOTS(test, 3);

        fill_bp_slots(test, &idx, -1, current, 2);
        /* Transitioning from only all CPU breakpoints to mixed. */
        tsk_on_cpu_idx = idx;
        fill_one_bp_slot(test, &idx, get_test_cpu(0), current);
        fill_one_bp_slot(test, &idx, -1, current);

        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));

        /* We should still be able to use up another CPU's slots. */
        cpu_idx = idx;
        fill_one_bp_slot(test, &idx, get_test_cpu(1), NULL);
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));

        /* Transitioning back to task target on all CPUs. */
        unregister_test_bp(&test_bps[tsk_on_cpu_idx]);
        /* Still have a CPU target breakpoint in get_test_cpu(1). */
        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        /* Remove it and try again. */
        unregister_test_bp(&test_bps[cpu_idx]);
        fill_one_bp_slot(test, &idx, -1, current);

        TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
        TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));
}

static struct kunit_case hw_breakpoint_test_cases[] = {
        KUNIT_CASE(test_one_cpu),
        KUNIT_CASE(test_many_cpus),
        KUNIT_CASE(test_one_task_on_all_cpus),
        KUNIT_CASE(test_two_tasks_on_all_cpus),
        KUNIT_CASE(test_one_task_on_one_cpu),
        KUNIT_CASE(test_one_task_mixed),
        KUNIT_CASE(test_two_tasks_on_one_cpu),
        KUNIT_CASE(test_two_tasks_on_one_all_cpus),
        KUNIT_CASE(test_task_on_all_and_one_cpu),
        {},
};

static int test_init(struct kunit *test)
{
        /* Most test cases want 2 distinct CPUs. */
        if (num_online_cpus() < 2)
                kunit_skip(test, "not enough cpus");

        /* Want the system to not use breakpoints elsewhere. */
        if (hw_breakpoint_is_used())
                kunit_skip(test, "hw breakpoint already in use");

        return 0;
}

static void test_exit(struct kunit *test)
{
        for (int i = 0; i < MAX_TEST_BREAKPOINTS; ++i) {
                if (test_bps[i])
                        unregister_test_bp(&test_bps[i]);
        }

        if (__other_task) {
                kthread_stop(__other_task);
                __other_task = NULL;
        }

        /* Verify that internal state agrees that no breakpoints are in use. */
        KUNIT_EXPECT_FALSE(test, hw_breakpoint_is_used());
}

static struct kunit_suite hw_breakpoint_test_suite = {
        .name = "hw_breakpoint",
        .test_cases = hw_breakpoint_test_cases,
        .init = test_init,
        .exit = test_exit,
};

kunit_test_suites(&hw_breakpoint_test_suite);

MODULE_AUTHOR("Marco Elver <elver@google.com>");