mte_common_util.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/* Copyright (C) 2020 ARM Limited */
  3
  4#ifndef _MTE_COMMON_UTIL_H
  5#define _MTE_COMMON_UTIL_H
  6
  7#include <signal.h>
  8#include <stdbool.h>
  9#include <stdlib.h>
 10#include <sys/auxv.h>
 11#include <sys/mman.h>
 12#include <sys/prctl.h>
 13#include "mte_def.h"
 14#include "kselftest.h"
 15
 16enum mte_mem_type {
 17	USE_MALLOC,
 18	USE_MMAP,
 19	USE_MPROTECT,
 20};
 21
 22enum mte_mode {
 23	MTE_NONE_ERR,
 24	MTE_SYNC_ERR,
 25	MTE_ASYNC_ERR,
 26};
 27
 28struct mte_fault_cxt {
 29	/* Address start which triggers mte tag fault */
 30	unsigned long trig_addr;
 31	/* Address range for mte tag fault and negative value means underflow */
 32	ssize_t trig_range;
 33	/* siginfo si code */
 34	unsigned long trig_si_code;
 35	/* Flag to denote if correct fault caught */
 36	bool fault_valid;
 37};
 38
 39extern struct mte_fault_cxt cur_mte_cxt;
 40extern bool mtefar_support;
 41extern bool mtestonly_support;
 42
 43/* MTE utility functions */
 44void mte_default_handler(int signum, siginfo_t *si, void *uc);
 45void mte_register_signal(int signal, void (*handler)(int, siginfo_t *, void *),
 46			 bool export_tags);
 47void mte_wait_after_trig(void);
 48void *mte_allocate_memory(size_t size, int mem_type, int mapping, bool tags);
 49void *mte_allocate_memory_tag_range(size_t size, int mem_type, int mapping,
 50				    size_t range_before, size_t range_after);
 51void *mte_allocate_file_memory(size_t size, int mem_type, int mapping,
 52			       bool tags, int fd);
 53void *mte_allocate_file_memory_tag_range(size_t size, int mem_type, int mapping,
 54					 size_t range_before, size_t range_after, int fd);
 55void mte_free_memory(void *ptr, size_t size, int mem_type, bool tags);
 56void mte_free_memory_tag_range(void *ptr, size_t size, int mem_type,
 57			       size_t range_before, size_t range_after);
 58void *mte_insert_tags(void *ptr, size_t size);
 59void mte_clear_tags(void *ptr, size_t size);
 60void *mte_insert_atag(void *ptr);
 61void *mte_clear_atag(void *ptr);
 62int mte_default_setup(void);
 63void mte_restore_setup(void);
 64int mte_switch_mode(int mte_option, unsigned long incl_mask, bool stonly);
 65void mte_initialize_current_context(int mode, uintptr_t ptr, ssize_t range);
 66
 67/* Common utility functions */
 68int create_temp_file(void);
 69
 70/* Assembly MTE utility functions */
 71void *mte_insert_random_tag(void *ptr);
 72void *mte_insert_new_tag(void *ptr);
 73void *mte_get_tag_address(void *ptr);
 74void mte_set_tag_address_range(void *ptr, int range);
 75void mte_clear_tag_address_range(void *ptr, int range);
 76void mte_disable_pstate_tco(void);
 77void mte_enable_pstate_tco(void);
 78unsigned int mte_get_pstate_tco(void);
 79
 80/* Test framework static inline functions/macros */
 81static inline void evaluate_test(int err, const char *msg)
 82{
 83	switch (err) {
 84	case KSFT_PASS:
 85		ksft_test_result_pass("%s", msg);
 86		break;
 87	case KSFT_FAIL:
 88		ksft_test_result_fail("%s", msg);
 89		break;
 90	case KSFT_SKIP:
 91		ksft_test_result_skip("%s", msg);
 92		break;
 93	default:
 94		ksft_test_result_error("Unknown return code %d from %s",
 95				       err, msg);
 96		break;
 97	}
 98}
 99
100static inline int check_allocated_memory(void *ptr, size_t size,
101					 int mem_type, bool tags)
102{
103	if (ptr == NULL) {
104		ksft_print_msg("FAIL: memory allocation\n");
105		return KSFT_FAIL;
106	}
107
108	if (tags && !MT_FETCH_TAG((uintptr_t)ptr)) {
109		ksft_print_msg("FAIL: tag not found at addr(%p)\n", ptr);
110		mte_free_memory((void *)ptr, size, mem_type, false);
111		return KSFT_FAIL;
112	}
113
114	return KSFT_PASS;
115}
116
117static inline int check_allocated_memory_range(void *ptr, size_t size, int mem_type,
118					       size_t range_before, size_t range_after)
119{
120	if (ptr == NULL) {
121		ksft_print_msg("FAIL: memory allocation\n");
122		return KSFT_FAIL;
123	}
124
125	if (!MT_FETCH_TAG((uintptr_t)ptr)) {
126		ksft_print_msg("FAIL: tag not found at addr(%p)\n", ptr);
127		mte_free_memory_tag_range((void *)ptr, size, mem_type, range_before,
128					  range_after);
129		return KSFT_FAIL;
130	}
131	return KSFT_PASS;
132}
133
134#endif /* _MTE_COMMON_UTIL_H */