46cb11b17c
Out of the box Ubuntu's 20.04 compiler warns about missing return value checks for write() (sys)calls. Make GCC happy by checking whether we actually managed to write "val". Signed-off-by: Andre Przywara <andre.przywara@arm.com> Reviewed-by: Mark Brown <broone@kernel.org> Link: https://lore.kernel.org/r/20210319165334.29213-5-andre.przywara@arm.com Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
117 lines
3.2 KiB
C
117 lines
3.2 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
// Copyright (C) 2020 ARM Limited
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#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/mman.h>
|
|
|
|
#include "kselftest.h"
|
|
#include "mte_common_util.h"
|
|
#include "mte_def.h"
|
|
|
|
static size_t page_sz;
|
|
|
|
static int check_usermem_access_fault(int mem_type, int mode, int mapping)
|
|
{
|
|
int fd, i, err;
|
|
char val = 'A';
|
|
size_t len, read_len;
|
|
void *ptr, *ptr_next;
|
|
|
|
err = KSFT_FAIL;
|
|
len = 2 * page_sz;
|
|
mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);
|
|
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 */
|
|
read_len = read(fd, ptr, len);
|
|
mte_wait_after_trig();
|
|
if (cur_mte_cxt.fault_valid || read_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;
|
|
|
|
/* Tag the next half of memory with different value */
|
|
ptr_next = (void *)((unsigned long)ptr + page_sz);
|
|
ptr_next = mte_insert_new_tag(ptr_next);
|
|
mte_set_tag_address_range(ptr_next, page_sz);
|
|
|
|
lseek(fd, 0, 0);
|
|
/* Copy from file into buffer with invalid tag */
|
|
read_len = read(fd, ptr, len);
|
|
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 (mode == MTE_SYNC_ERR &&
|
|
!cur_mte_cxt.fault_valid && read_len < len) {
|
|
err = KSFT_PASS;
|
|
} else if (mode == MTE_ASYNC_ERR &&
|
|
!cur_mte_cxt.fault_valid && read_len == len) {
|
|
err = KSFT_PASS;
|
|
}
|
|
usermem_acc_err:
|
|
mte_free_memory((void *)ptr, len, mem_type, true);
|
|
close(fd);
|
|
return err;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int err;
|
|
|
|
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);
|
|
|
|
/* Set test plan */
|
|
ksft_set_plan(4);
|
|
|
|
evaluate_test(check_usermem_access_fault(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE),
|
|
"Check memory access from kernel in sync mode, private mapping and mmap memory\n");
|
|
evaluate_test(check_usermem_access_fault(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED),
|
|
"Check memory access from kernel in sync mode, shared mapping and mmap memory\n");
|
|
|
|
evaluate_test(check_usermem_access_fault(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE),
|
|
"Check memory access from kernel in async mode, private mapping and mmap memory\n");
|
|
evaluate_test(check_usermem_access_fault(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED),
|
|
"Check memory access from kernel in async mode, shared mapping and mmap memory\n");
|
|
|
|
mte_restore_setup();
|
|
ksft_print_cnts();
|
|
return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;
|
|
}
|