// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2011 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
 *
 * Selftests for breakpoints (and more generally the do_debug() path) in x86.
 */


#include <sys/ptrace.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/user.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>

#include "kselftest.h"

#define COUNT_ISN_BPS   4
#define COUNT_WPS       4

/* Breakpoint access modes */
enum {
        BP_X = 1,
        BP_RW = 2,
        BP_W = 4,
};

static pid_t child_pid;

/*
 * Ensures the child and parent are always "talking" about
 * the same test sequence. (ie: that we haven't forgotten
 * to call check_trapped() somewhere).
 */
static int nr_tests;

static void set_breakpoint_addr(void *addr, int n)
{
        int ret;

        ret = ptrace(PTRACE_POKEUSER, child_pid,
                     offsetof(struct user, u_debugreg[n]), addr);
        if (ret)
                ksft_exit_fail_msg("Can't set breakpoint addr: %s\n",
                        strerror(errno));
}

static void toggle_breakpoint(int n, int type, int len,
                              int local, int global, int set)
{
        int ret;

        int xtype, xlen;
        unsigned long vdr7, dr7;

        switch (type) {
        case BP_X:
                xtype = 0;
                break;
        case BP_W:
                xtype = 1;
                break;
        case BP_RW:
                xtype = 3;
                break;
        }

        switch (len) {
        case 1:
                xlen = 0;
                break;
        case 2:
                xlen = 4;
                break;
        case 4:
                xlen = 0xc;
                break;
        case 8:
                xlen = 8;
                break;
        }

        dr7 = ptrace(PTRACE_PEEKUSER, child_pid,
                     offsetof(struct user, u_debugreg[7]), 0);

        vdr7 = (xlen | xtype) << 16;
        vdr7 <<= 4 * n;

        if (local) {
                vdr7 |= 1 << (2 * n);
                vdr7 |= 1 << 8;
        }
        if (global) {
                vdr7 |= 2 << (2 * n);
                vdr7 |= 1 << 9;
        }

        if (set)
                dr7 |= vdr7;
        else
                dr7 &= ~vdr7;

        ret = ptrace(PTRACE_POKEUSER, child_pid,
                     offsetof(struct user, u_debugreg[7]), dr7);
        if (ret) {
                ksft_print_msg("Can't set dr7: %s\n", strerror(errno));
                exit(-1);
        }
}

/* Dummy variables to test read/write accesses */
static unsigned long long dummy_var[4];

/* Dummy functions to test execution accesses */
static void dummy_func(void) { }
static void dummy_func1(void) { }
static void dummy_func2(void) { }
static void dummy_func3(void) { }

static void (*dummy_funcs[])(void) = {
        dummy_func,
        dummy_func1,
        dummy_func2,
        dummy_func3,
};

static int trapped;

static void check_trapped(void)
{
        /*
         * If we haven't trapped, wake up the parent
         * so that it notices the failure.
         */
        if (!trapped)
                kill(getpid(), SIGUSR1);
        trapped = 0;

        nr_tests++;
}

static void write_var(int len)
{
        char *pcval; short *psval; int *pival; long long *plval;
        int i;

        for (i = 0; i < 4; i++) {
                switch (len) {
                case 1:
                        pcval = (char *)&dummy_var[i];
                        *pcval = 0xff;
                        break;
                case 2:
                        psval = (short *)&dummy_var[i];
                        *psval = 0xffff;
                        break;
                case 4:
                        pival = (int *)&dummy_var[i];
                        *pival = 0xffffffff;
                        break;
                case 8:
                        plval = (long long *)&dummy_var[i];
                        *plval = 0xffffffffffffffffLL;
                        break;
                }
                check_trapped();
        }
}

static void read_var(int len)
{
        char cval; short sval; int ival; long long lval;
        int i;

        for (i = 0; i < 4; i++) {
                switch (len) {
                case 1:
                        cval = *(char *)&dummy_var[i];
                        break;
                case 2:
                        sval = *(short *)&dummy_var[i];
                        break;
                case 4:
                        ival = *(int *)&dummy_var[i];
                        break;
                case 8:
                        lval = *(long long *)&dummy_var[i];
                        break;
                }
                check_trapped();
        }
}

/*
 * Do the r/w/x accesses to trigger the breakpoints. And run
 * the usual traps.
 */
static void trigger_tests(void)
{
        int len, local, global, i;
        char val;
        int ret;

        ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);
        if (ret) {
                ksft_print_msg("Can't be traced? %s\n", strerror(errno));
                return;
        }

        /* Wake up father so that it sets up the first test */
        kill(getpid(), SIGUSR1);

        /* Test instruction breakpoints */
        for (local = 0; local < 2; local++) {
                for (global = 0; global < 2; global++) {
                        if (!local && !global)
                                continue;

                        for (i = 0; i < COUNT_ISN_BPS; i++) {
                                dummy_funcs[i]();
                                check_trapped();
                        }
                }
        }

        /* Test write watchpoints */
        for (len = 1; len <= sizeof(long); len <<= 1) {
                for (local = 0; local < 2; local++) {
                        for (global = 0; global < 2; global++) {
                                if (!local && !global)
                                        continue;
                                write_var(len);
                        }
                }
        }

        /* Test read/write watchpoints (on read accesses) */
        for (len = 1; len <= sizeof(long); len <<= 1) {
                for (local = 0; local < 2; local++) {
                        for (global = 0; global < 2; global++) {
                                if (!local && !global)
                                        continue;
                                read_var(len);
                        }
                }
        }

        /* Icebp trap */
        asm(".byte 0xf1\n");
        check_trapped();

        /* Int 3 trap */
        asm("int $3\n");
        check_trapped();

        kill(getpid(), SIGUSR1);
}

static void check_success(const char *msg)
{
        int child_nr_tests;
        int status;
        int ret;

        /* Wait for the child to SIGTRAP */
        wait(&status);

        ret = 0;

        if (WSTOPSIG(status) == SIGTRAP) {
                child_nr_tests = ptrace(PTRACE_PEEKDATA, child_pid,
                                        &nr_tests, 0);
                if (child_nr_tests == nr_tests)
                        ret = 1;
                if (ptrace(PTRACE_POKEDATA, child_pid, &trapped, 1))
                        ksft_exit_fail_msg("Can't poke: %s\n", strerror(errno));
        }

        nr_tests++;

        if (ret)
                ksft_test_result_pass("%s", msg);
        else
                ksft_test_result_fail("%s", msg);
}

static void launch_instruction_breakpoints(char *buf, int local, int global)
{
        int i;

        for (i = 0; i < COUNT_ISN_BPS; i++) {
                set_breakpoint_addr(dummy_funcs[i], i);
                toggle_breakpoint(i, BP_X, 1, local, global, 1);
                ptrace(PTRACE_CONT, child_pid, NULL, 0);
                sprintf(buf, "Test breakpoint %d with local: %d global: %d\n",
                        i, local, global);
                check_success(buf);
                toggle_breakpoint(i, BP_X, 1, local, global, 0);
        }
}

static void launch_watchpoints(char *buf, int mode, int len,
                               int local, int global)
{
        const char *mode_str;
        int i;

        if (mode == BP_W)
                mode_str = "write";
        else
                mode_str = "read";

        for (i = 0; i < COUNT_WPS; i++) {
                set_breakpoint_addr(&dummy_var[i], i);
                toggle_breakpoint(i, mode, len, local, global, 1);
                ptrace(PTRACE_CONT, child_pid, NULL, 0);
                sprintf(buf,
                        "Test %s watchpoint %d with len: %d local: %d global: %d\n",
                        mode_str, i, len, local, global);
                check_success(buf);
                toggle_breakpoint(i, mode, len, local, global, 0);
        }
}

/* Set the breakpoints and check the child successfully trigger them */
static void launch_tests(void)
{
        char buf[1024];
        unsigned int tests = 0;
        int len, local, global, i;

        tests += 3 * COUNT_ISN_BPS;
        tests += sizeof(long) / 2 * 3 * COUNT_WPS;
        tests += sizeof(long) / 2 * 3 * COUNT_WPS;
        tests += 2;
        ksft_set_plan(tests);

        /* Instruction breakpoints */
        for (local = 0; local < 2; local++) {
                for (global = 0; global < 2; global++) {
                        if (!local && !global)
                                continue;
                        launch_instruction_breakpoints(buf, local, global);
                }
        }

        /* Write watchpoint */
        for (len = 1; len <= sizeof(long); len <<= 1) {
                for (local = 0; local < 2; local++) {
                        for (global = 0; global < 2; global++) {
                                if (!local && !global)
                                        continue;
                                launch_watchpoints(buf, BP_W, len,
                                                   local, global);
                        }
                }
        }

        /* Read-Write watchpoint */
        for (len = 1; len <= sizeof(long); len <<= 1) {
                for (local = 0; local < 2; local++) {
                        for (global = 0; global < 2; global++) {
                                if (!local && !global)
                                        continue;
                                launch_watchpoints(buf, BP_RW, len,
                                                   local, global);
                        }
                }
        }

        /* Icebp traps */
        ptrace(PTRACE_CONT, child_pid, NULL, 0);
        check_success("Test icebp\n");

        /* Int 3 traps */
        ptrace(PTRACE_CONT, child_pid, NULL, 0);
        check_success("Test int 3 trap\n");

        ptrace(PTRACE_CONT, child_pid, NULL, 0);
}

int main(int argc, char **argv)
{
        pid_t pid;
        int ret;

        ksft_print_header();

        pid = fork();
        if (!pid) {
                trigger_tests();
                exit(0);
        }

        child_pid = pid;

        wait(NULL);

        launch_tests();

        wait(NULL);

        ksft_exit_pass();
}