Commit 53ec81d2 authored by Amit Daniel Kachhap's avatar Amit Daniel Kachhap Committed by Will Deacon
Browse files

kselftest/arm64: Verify all different mmap MTE options 



This testcase checks the different unsupported/supported options for mmap
if used with PROT_MTE memory protection flag. These checks are,

* Either pstate.tco enable or prctl PR_MTE_TCF_NONE option should not cause
  any tag mismatch faults.
* Different combinations of anonymous/file memory mmap, mprotect,
  sync/async error mode and private/shared mappings should work.
* mprotect should not be able to clear the PROT_MTE page property.

Co-developed-by: default avatarGabor Kertesz <gabor.kertesz@arm.com>
Signed-off-by: default avatarGabor Kertesz <gabor.kertesz@arm.com>
Signed-off-by: default avatarAmit Daniel Kachhap <amit.kachhap@arm.com>
Tested-by: default avatarCatalin Marinas <catalin.marinas@arm.com>
Acked-by: default avatarCatalin Marinas <catalin.marinas@arm.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will@kernel.org>
Link: https://lore.kernel.org/r/20201002115630.24683-5-amit.kachhap@arm.com


Signed-off-by: default avatarWill Deacon <will@kernel.org>
parent dfe537cf

tools/testing/selftests/arm64/mte/.gitignore

+1 −0
Original line number Diff line number Diff line 
check_buffer_fill

check_tags_inclusion

check_child_memory

check_mmap_options

tools/testing/selftests/arm64/mte/check_mmap_options.c

0 → 100644
+262 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// Copyright (C) 2020 ARM Limited



#define _GNU_SOURCE



#include <errno.h>

#include <fcntl.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ucontext.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/types.h>



#include "kselftest.h"

#include "mte_common_util.h"

#include "mte_def.h"



#define RUNS			(MT_TAG_COUNT)

#define UNDERFLOW		MT_GRANULE_SIZE

#define OVERFLOW		MT_GRANULE_SIZE

#define TAG_CHECK_ON		0

#define TAG_CHECK_OFF		1



static size_t page_size;

static int sizes[] = {

	1, 537, 989, 1269, MT_GRANULE_SIZE - 1, MT_GRANULE_SIZE,

	/* page size - 1*/ 0, /* page_size */ 0, /* page size + 1 */ 0

};



static int check_mte_memory(char *ptr, int size, int mode, int tag_check)

{

	mte_initialize_current_context(mode, (uintptr_t)ptr, size);

	memset(ptr, '1', size);

	mte_wait_after_trig();

	if (cur_mte_cxt.fault_valid == true)

		return KSFT_FAIL;



	mte_initialize_current_context(mode, (uintptr_t)ptr, -UNDERFLOW);

	memset(ptr - UNDERFLOW, '2', UNDERFLOW);

	mte_wait_after_trig();

	if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)

		return KSFT_FAIL;

	if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)

		return KSFT_FAIL;



	mte_initialize_current_context(mode, (uintptr_t)ptr, size + OVERFLOW);

	memset(ptr + size, '3', OVERFLOW);

	mte_wait_after_trig();

	if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)

		return KSFT_FAIL;

	if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)

		return KSFT_FAIL;



	return KSFT_PASS;

}



static int check_anonymous_memory_mapping(int mem_type, int mode, int mapping, int tag_check)

{

	char *ptr, *map_ptr;

	int run, result, map_size;

	int item = sizeof(sizes)/sizeof(int);



	item = sizeof(sizes)/sizeof(int);

	mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);

	for (run = 0; run < item; run++) {

		map_size = sizes[run] + OVERFLOW + UNDERFLOW;

		map_ptr = (char *)mte_allocate_memory(map_size, mem_type, mapping, false);

		if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS)

			return KSFT_FAIL;



		ptr = map_ptr + UNDERFLOW;

		mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);

		/* Only mte enabled memory will allow tag insertion */

		ptr = mte_insert_tags((void *)ptr, sizes[run]);

		if (!ptr || cur_mte_cxt.fault_valid == true) {

			ksft_print_msg("FAIL: Insert tags on anonymous mmap memory\n");

			munmap((void *)map_ptr, map_size);

			return KSFT_FAIL;

		}

		result = check_mte_memory(ptr, sizes[run], mode, tag_check);

		mte_clear_tags((void *)ptr, sizes[run]);

		mte_free_memory((void *)map_ptr, map_size, mem_type, false);

		if (result == KSFT_FAIL)

			return KSFT_FAIL;

	}

	return KSFT_PASS;

}



static int check_file_memory_mapping(int mem_type, int mode, int mapping, int tag_check)

{

	char *ptr, *map_ptr;

	int run, fd, map_size;

	int total = sizeof(sizes)/sizeof(int);

	int result = KSFT_PASS;



	mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);

	for (run = 0; run < total; run++) {

		fd = create_temp_file();

		if (fd == -1)

			return KSFT_FAIL;



		map_size = sizes[run] + UNDERFLOW + OVERFLOW;

		map_ptr = (char *)mte_allocate_file_memory(map_size, mem_type, mapping, false, fd);

		if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS) {

			close(fd);

			return KSFT_FAIL;

		}

		ptr = map_ptr + UNDERFLOW;

		mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);

		/* Only mte enabled memory will allow tag insertion */

		ptr = mte_insert_tags((void *)ptr, sizes[run]);

		if (!ptr || cur_mte_cxt.fault_valid == true) {

			ksft_print_msg("FAIL: Insert tags on file based memory\n");

			munmap((void *)map_ptr, map_size);

			close(fd);

			return KSFT_FAIL;

		}

		result = check_mte_memory(ptr, sizes[run], mode, tag_check);

		mte_clear_tags((void *)ptr, sizes[run]);

		munmap((void *)map_ptr, map_size);

		close(fd);

		if (result == KSFT_FAIL)

			break;

	}

	return result;

}



static int check_clear_prot_mte_flag(int mem_type, int mode, int mapping)

{

	char *ptr, *map_ptr;

	int run, prot_flag, result, fd, map_size;

	int total = sizeof(sizes)/sizeof(int);



	prot_flag = PROT_READ | PROT_WRITE;

	mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);

	for (run = 0; run < total; run++) {

		map_size = sizes[run] + OVERFLOW + UNDERFLOW;

		ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping,

							    UNDERFLOW, OVERFLOW);

		if (check_allocated_memory_range(ptr, sizes[run], mem_type,

						 UNDERFLOW, OVERFLOW) != KSFT_PASS)

			return KSFT_FAIL;

		map_ptr = ptr - UNDERFLOW;

		/* Try to clear PROT_MTE property and verify it by tag checking */

		if (mprotect(map_ptr, map_size, prot_flag)) {

			mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,

						  UNDERFLOW, OVERFLOW);

			ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");

			return KSFT_FAIL;

		}

		result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON);

		mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);

		if (result != KSFT_PASS)

			return KSFT_FAIL;



		fd = create_temp_file();

		if (fd == -1)

			return KSFT_FAIL;

		ptr = (char *)mte_allocate_file_memory_tag_range(sizes[run], mem_type, mapping,

								 UNDERFLOW, OVERFLOW, fd);

		if (check_allocated_memory_range(ptr, sizes[run], mem_type,

						 UNDERFLOW, OVERFLOW) != KSFT_PASS) {

			close(fd);

			return KSFT_FAIL;

		}

		map_ptr = ptr - UNDERFLOW;

		/* Try to clear PROT_MTE property and verify it by tag checking */

		if (mprotect(map_ptr, map_size, prot_flag)) {

			ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");

			mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,

						  UNDERFLOW, OVERFLOW);

			close(fd);

			return KSFT_FAIL;

		}

		result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON);

		mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);

		close(fd);

		if (result != KSFT_PASS)

			return KSFT_FAIL;

	}

	return KSFT_PASS;

}



int main(int argc, char *argv[])

{

	int err;

	int item = sizeof(sizes)/sizeof(int);



	err = mte_default_setup();

	if (err)

		return err;

	page_size = getpagesize();

	if (!page_size) {

		ksft_print_msg("ERR: Unable to get page size\n");

		return KSFT_FAIL;

	}

	sizes[item - 3] = page_size - 1;

	sizes[item - 2] = page_size;

	sizes[item - 1] = page_size + 1;



	/* Register signal handlers */

	mte_register_signal(SIGBUS, mte_default_handler);

	mte_register_signal(SIGSEGV, mte_default_handler);



	mte_enable_pstate_tco();

	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),

	"Check anonymous memory with private mapping, sync error mode, mmap memory and tag check off\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),

	"Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check off\n");



	mte_disable_pstate_tco();

	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),

	"Check anonymous memory with private mapping, no error mode, mmap memory and tag check off\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),

	"Check file memory with private mapping, no error mode, mmap/mprotect memory and tag check off\n");



	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check anonymous memory with private mapping, sync error mode, mmap memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check anonymous memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check anonymous memory with shared mapping, sync error mode, mmap memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check anonymous memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check anonymous memory with private mapping, async error mode, mmap memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check anonymous memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check anonymous memory with shared mapping, async error mode, mmap memory and tag check on\n");

	evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check anonymous memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");



	evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check file memory with private mapping, sync error mode, mmap memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check file memory with shared mapping, sync error mode, mmap memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check file memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check file memory with private mapping, async error mode, mmap memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),

	"Check file memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check file memory with shared mapping, async error mode, mmap memory and tag check on\n");

	evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),

	"Check file memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");



	evaluate_test(check_clear_prot_mte_flag(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE),

	"Check clear PROT_MTE flags with private mapping, sync error mode and mmap memory\n");

	evaluate_test(check_clear_prot_mte_flag(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE),

	"Check clear PROT_MTE flags with private mapping and sync error mode and mmap/mprotect memory\n");



	mte_restore_setup();

	ksft_print_cnts();

	return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE