// SPDX-License-Identifier: GPL-2.0

/*
 * Copyright 2022, Nicholas Miehlbradt, IBM Corporation
 * based on pkey_exec_prot.c
 *
 * Test if applying execute protection on pages works as expected.
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

#include <unistd.h>
#include <sys/mman.h>

#include "pkeys.h"


#define PPC_INST_NOP    0x60000000
#define PPC_INST_TRAP   0x7fe00008
#define PPC_INST_BLR    0x4e800020

static volatile sig_atomic_t fault_code;
static volatile sig_atomic_t remaining_faults;
static volatile unsigned int *fault_addr;
static unsigned long pgsize, numinsns;
static unsigned int *insns;
static bool pkeys_supported;

static bool is_fault_expected(int fault_code)
{
        if (fault_code == SEGV_ACCERR)
                return true;

        /* Assume any pkey error is fine since pkey_exec_prot test covers them */
        if (fault_code == SEGV_PKUERR && pkeys_supported)
                return true;

        return false;
}

static void trap_handler(int signum, siginfo_t *sinfo, void *ctx)
{
        /* Check if this fault originated from the expected address */
        if (sinfo->si_addr != (void *)fault_addr)
                sigsafe_err("got a fault for an unexpected address\n");

        _exit(1);
}

static void segv_handler(int signum, siginfo_t *sinfo, void *ctx)
{
        fault_code = sinfo->si_code;

        /* Check if this fault originated from the expected address */
        if (sinfo->si_addr != (void *)fault_addr) {
                sigsafe_err("got a fault for an unexpected address\n");
                _exit(1);
        }

        /* Check if too many faults have occurred for a single test case */
        if (!remaining_faults) {
                sigsafe_err("got too many faults for the same address\n");
                _exit(1);
        }


        /* Restore permissions in order to continue */
        if (is_fault_expected(fault_code)) {
                if (mprotect(insns, pgsize, PROT_READ | PROT_WRITE | PROT_EXEC)) {
                        sigsafe_err("failed to set access permissions\n");
                        _exit(1);
                }
        } else {
                sigsafe_err("got a fault with an unexpected code\n");
                _exit(1);
        }

        remaining_faults--;
}

static int check_exec_fault(int rights)
{
        /*
         * Jump to the executable region.
         *
         * The first iteration also checks if the overwrite of the
         * first instruction word from a trap to a no-op succeeded.
         */
        fault_code = -1;
        remaining_faults = 0;
        if (!(rights & PROT_EXEC))
                remaining_faults = 1;

        FAIL_IF(mprotect(insns, pgsize, rights) != 0);
        asm volatile("mtctr     %0; bctrl" : : "r"(insns));

        FAIL_IF(remaining_faults != 0);
        if (!(rights & PROT_EXEC))
                FAIL_IF(!is_fault_expected(fault_code));

        return 0;
}

static int test(void)
{
        struct sigaction segv_act, trap_act;
        int i;

        /* Skip the test if the CPU doesn't support Radix */
        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));

        /* Check if pkeys are supported */
        pkeys_supported = pkeys_unsupported() == 0;

        /* Setup SIGSEGV handler */
        segv_act.sa_handler = 0;
        segv_act.sa_sigaction = segv_handler;
        FAIL_IF(sigprocmask(SIG_SETMASK, 0, &segv_act.sa_mask) != 0);
        segv_act.sa_flags = SA_SIGINFO;
        segv_act.sa_restorer = 0;
        FAIL_IF(sigaction(SIGSEGV, &segv_act, NULL) != 0);

        /* Setup SIGTRAP handler */
        trap_act.sa_handler = 0;
        trap_act.sa_sigaction = trap_handler;
        FAIL_IF(sigprocmask(SIG_SETMASK, 0, &trap_act.sa_mask) != 0);
        trap_act.sa_flags = SA_SIGINFO;
        trap_act.sa_restorer = 0;
        FAIL_IF(sigaction(SIGTRAP, &trap_act, NULL) != 0);

        /* Setup executable region */
        pgsize = getpagesize();
        numinsns = pgsize / sizeof(unsigned int);
        insns = (unsigned int *)mmap(NULL, pgsize, PROT_READ | PROT_WRITE,
                                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
        FAIL_IF(insns == MAP_FAILED);

        /* Write the instruction words */
        for (i = 1; i < numinsns - 1; i++)
                insns[i] = PPC_INST_NOP;

        /*
         * Set the first instruction as an unconditional trap. If
         * the last write to this address succeeds, this should
         * get overwritten by a no-op.
         */
        insns[0] = PPC_INST_TRAP;

        /*
         * Later, to jump to the executable region, we use a branch
         * and link instruction (bctrl) which sets the return address
         * automatically in LR. Use that to return back.
         */
        insns[numinsns - 1] = PPC_INST_BLR;

        /*
         * Pick the first instruction's address from the executable
         * region.
         */
        fault_addr = insns;

        /*
         * Read an instruction word from the address when the page
         * is execute only. This should generate an access fault.
         */
        fault_code = -1;
        remaining_faults = 1;
        printf("Testing read on --x, should fault...");
        FAIL_IF(mprotect(insns, pgsize, PROT_EXEC) != 0);
        i = *fault_addr;
        FAIL_IF(remaining_faults != 0 || !is_fault_expected(fault_code));
        printf("ok!\n");

        /*
         * Write an instruction word to the address when the page
         * execute only. This should also generate an access fault.
         */
        fault_code = -1;
        remaining_faults = 1;
        printf("Testing write on --x, should fault...");
        FAIL_IF(mprotect(insns, pgsize, PROT_EXEC) != 0);
        *fault_addr = PPC_INST_NOP;
        FAIL_IF(remaining_faults != 0 || !is_fault_expected(fault_code));
        printf("ok!\n");

        printf("Testing exec on ---, should fault...");
        FAIL_IF(check_exec_fault(PROT_NONE));
        printf("ok!\n");

        printf("Testing exec on r--, should fault...");
        FAIL_IF(check_exec_fault(PROT_READ));
        printf("ok!\n");

        printf("Testing exec on -w-, should fault...");
        FAIL_IF(check_exec_fault(PROT_WRITE));
        printf("ok!\n");

        printf("Testing exec on rw-, should fault...");
        FAIL_IF(check_exec_fault(PROT_READ | PROT_WRITE));
        printf("ok!\n");

        printf("Testing exec on --x, should succeed...");
        FAIL_IF(check_exec_fault(PROT_EXEC));
        printf("ok!\n");

        printf("Testing exec on r-x, should succeed...");
        FAIL_IF(check_exec_fault(PROT_READ | PROT_EXEC));
        printf("ok!\n");

        printf("Testing exec on -wx, should succeed...");
        FAIL_IF(check_exec_fault(PROT_WRITE | PROT_EXEC));
        printf("ok!\n");

        printf("Testing exec on rwx, should succeed...");
        FAIL_IF(check_exec_fault(PROT_READ | PROT_WRITE | PROT_EXEC));
        printf("ok!\n");

        /* Cleanup */
        FAIL_IF(munmap((void *)insns, pgsize));

        return 0;
}

int main(void)
{
        return test_harness(test, "exec_prot");
}