// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 ARM Limited

#define _GNU_SOURCE

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ucontext.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/mman.h>

#include "kselftest.h"
#include "mte_common_util.h"
#include "mte_def.h"

static size_t page_sz;

#define TEST_NAME_MAX 100

enum test_type {
        READ_TEST,
        WRITE_TEST,
        READV_TEST,
        WRITEV_TEST,
        LAST_TEST,
};

static int check_usermem_access_fault(int mem_type, int mode, int mapping,
                                      int tag_offset, int tag_len,
                                      enum test_type test_type)
{
        int fd, i, err;
        char val = 'A';
        ssize_t len, syscall_len;
        void *ptr, *ptr_next;
        int fileoff, ptroff, size;
        int sizes[] = {1, 2, 3, 8, 16, 32, 4096, page_sz};

        err = KSFT_PASS;
        len = 2 * page_sz;
        mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG, false);
        fd = create_temp_file();
        if (fd == -1)
                return KSFT_FAIL;
        for (i = 0; i < len; i++)
                if (write(fd, &val, sizeof(val)) != sizeof(val))
                        return KSFT_FAIL;
        lseek(fd, 0, 0);
        ptr = mte_allocate_memory(len, mem_type, mapping, true);
        if (check_allocated_memory(ptr, len, mem_type, true) != KSFT_PASS) {
                close(fd);
                return KSFT_FAIL;
        }
        mte_initialize_current_context(mode, (uintptr_t)ptr, len);
        /* Copy from file into buffer with valid tag */
        syscall_len = read(fd, ptr, len);
        mte_wait_after_trig();
        if (cur_mte_cxt.fault_valid || syscall_len < len)
                goto usermem_acc_err;
        /* Verify same pattern is read */
        for (i = 0; i < len; i++)
                if (*(char *)(ptr + i) != val)
                        break;
        if (i < len)
                goto usermem_acc_err;

        if (!tag_len)
                tag_len = len - tag_offset;
        /* Tag a part of memory with different value */
        ptr_next = (void *)((unsigned long)ptr + tag_offset);
        ptr_next = mte_insert_new_tag(ptr_next);
        mte_set_tag_address_range(ptr_next, tag_len);

        for (fileoff = 0; fileoff < 16; fileoff++) {
                for (ptroff = 0; ptroff < 16; ptroff++) {
                        for (i = 0; i < ARRAY_SIZE(sizes); i++) {
                                size = sizes[i];
                                lseek(fd, 0, 0);

                                /* perform file operation on buffer with invalid tag */
                                switch (test_type) {
                                case READ_TEST:
                                        syscall_len = read(fd, ptr + ptroff, size);
                                        break;
                                case WRITE_TEST:
                                        syscall_len = write(fd, ptr + ptroff, size);
                                        break;
                                case READV_TEST: {
                                        struct iovec iov[1];
                                        iov[0].iov_base = ptr + ptroff;
                                        iov[0].iov_len = size;
                                        syscall_len = readv(fd, iov, 1);
                                        break;
                                }
                                case WRITEV_TEST: {
                                        struct iovec iov[1];
                                        iov[0].iov_base = ptr + ptroff;
                                        iov[0].iov_len = size;
                                        syscall_len = writev(fd, iov, 1);
                                        break;
                                }
                                case LAST_TEST:
                                        goto usermem_acc_err;
                                }

                                mte_wait_after_trig();
                                /*
                                 * Accessing user memory in kernel with invalid tag should fail in sync
                                 * mode without fault but may not fail in async mode as per the
                                 * implemented MTE userspace support in Arm64 kernel.
                                 */
                                if (cur_mte_cxt.fault_valid) {
                                        goto usermem_acc_err;
                                }
                                if (mode == MTE_SYNC_ERR && syscall_len < len) {
                                        /* test passed */
                                } else if (mode == MTE_ASYNC_ERR && syscall_len == size) {
                                        /* test passed */
                                } else {
                                        goto usermem_acc_err;
                                }
                        }
                }
        }

        goto exit;

usermem_acc_err:
        err = KSFT_FAIL;
exit:
        mte_free_memory((void *)ptr, len, mem_type, true);
        close(fd);
        return err;
}

void format_test_name(char* name, int name_len, int type, int sync, int map, int len, int offset) {
        const char* test_type;
        const char* mte_type;
        const char* map_type;

        switch (type) {
        case READ_TEST:
                test_type = "read";
                break;
        case WRITE_TEST:
                test_type = "write";
                break;
        case READV_TEST:
                test_type = "readv";
                break;
        case WRITEV_TEST:
                test_type = "writev";
                break;
        default:
                assert(0);
                break;
        }

        switch (sync) {
        case MTE_SYNC_ERR:
                mte_type = "MTE_SYNC_ERR";
                break;
        case MTE_ASYNC_ERR:
                mte_type = "MTE_ASYNC_ERR";
                break;
        default:
                assert(0);
                break;
        }

        switch (map) {
        case MAP_SHARED:
                map_type = "MAP_SHARED";
                break;
        case MAP_PRIVATE:
                map_type = "MAP_PRIVATE";
                break;
        default:
                assert(0);
                break;
        }

        snprintf(name, name_len,
                 "test type: %s, %s, %s, tag len: %d, tag offset: %d\n",
                 test_type, mte_type, map_type, len, offset);
}

int main(int argc, char *argv[])
{
        int err;
        int t, s, m, l, o;
        int mte_sync[] = {MTE_SYNC_ERR, MTE_ASYNC_ERR};
        int maps[] = {MAP_SHARED, MAP_PRIVATE};
        int tag_lens[] = {0, MT_GRANULE_SIZE};
        int tag_offsets[] = {page_sz, MT_GRANULE_SIZE};
        char test_name[TEST_NAME_MAX];

        page_sz = getpagesize();
        if (!page_sz) {
                ksft_print_msg("ERR: Unable to get page size\n");
                return KSFT_FAIL;
        }
        err = mte_default_setup();
        if (err)
                return err;

        /* Register signal handlers */
        mte_register_signal(SIGSEGV, mte_default_handler, false);

        /* Set test plan */
        ksft_set_plan(64);

        for (t = 0; t < LAST_TEST; t++) {
                for (s = 0; s < ARRAY_SIZE(mte_sync); s++) {
                        for (m = 0; m < ARRAY_SIZE(maps); m++) {
                                for (l = 0; l < ARRAY_SIZE(tag_lens); l++) {
                                        for (o = 0; o < ARRAY_SIZE(tag_offsets); o++) {
                                                int sync = mte_sync[s];
                                                int map = maps[m];
                                                int offset = tag_offsets[o];
                                                int tag_len = tag_lens[l];
                                                int res = check_usermem_access_fault(USE_MMAP, sync,
                                                                                     map, offset,
                                                                                     tag_len, t);
                                                format_test_name(test_name, TEST_NAME_MAX,
                                                                 t, sync, map, tag_len, offset);
                                                evaluate_test(res, test_name);
                                        }
                                }
                        }
                }
        }

        mte_restore_setup();
        ksft_print_cnts();
        return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;
}