Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_EXECMEM_ALLOC_H#define _LINUX_EXECMEM_ALLOC_H
#include <linux/types.h>#include <linux/moduleloader.h>#include <linux/cleanup.h>
#if (defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)) && \ !defined(CONFIG_KASAN_VMALLOC)#include <linux/kasan.h>#define MODULE_ALIGN (PAGE_SIZE << KASAN_SHADOW_SCALE_SHIFT)#else#define MODULE_ALIGN PAGE_SIZE#endif
/** * enum execmem_type - types of executable memory ranges * * There are several subsystems that allocate executable memory. * Architectures define different restrictions on placement, * permissions, alignment and other parameters for memory that can be used * by these subsystems. * Types in this enum identify subsystems that allocate executable memory * and let architectures define parameters for ranges suitable for * allocations by each subsystem. * * @EXECMEM_DEFAULT: default parameters that would be used for types that * are not explicitly defined. * @EXECMEM_MODULE_TEXT: parameters for module text sections * @EXECMEM_KPROBES: parameters for kprobes * @EXECMEM_FTRACE: parameters for ftrace * @EXECMEM_BPF: parameters for BPF * @EXECMEM_MODULE_DATA: parameters for module data sections * @EXECMEM_TYPE_MAX: */enum execmem_type { EXECMEM_DEFAULT, EXECMEM_MODULE_TEXT = EXECMEM_DEFAULT, EXECMEM_KPROBES, EXECMEM_FTRACE, EXECMEM_BPF, EXECMEM_MODULE_DATA, EXECMEM_TYPE_MAX,};
/** * enum execmem_range_flags - options for executable memory allocations * @EXECMEM_KASAN_SHADOW: allocate kasan shadow * @EXECMEM_ROX_CACHE: allocations should use ROX cache of huge pages */enum execmem_range_flags { EXECMEM_KASAN_SHADOW = (1 << 0), EXECMEM_ROX_CACHE = (1 << 1),};
#ifdef CONFIG_ARCH_HAS_EXECMEM_ROX/** * execmem_fill_trapping_insns - set memory to contain instructions that * will trap * @ptr: pointer to memory to fill * @size: size of the range to fill * * A hook for architecures to fill execmem ranges with invalid instructions. * Architectures that use EXECMEM_ROX_CACHE must implement this. */void execmem_fill_trapping_insns(void *ptr, size_t size);
/** * execmem_restore_rox - restore read-only-execute permissions * @ptr: address of the region to remap * @size: size of the region to remap * * Restores read-only-execute permissions on a range [@ptr, @ptr + @size) * after it was temporarily remapped as writable. Relies on architecture * implementation of set_memory_rox() to restore mapping using large pages. * * Return: 0 on success or negative error code on failure. */int execmem_restore_rox(void *ptr, size_t size);#elsestatic inline int execmem_restore_rox(void *ptr, size_t size) { return 0; }#endif
/** * struct execmem_range - definition of an address space suitable for code and * related data allocations * @start: address space start * @end: address space end (inclusive) * @fallback_start: start of the secondary address space range for fallback * allocations on architectures that require it * @fallback_end: end of the secondary address space (inclusive) * @pgprot: permissions for memory in this address space * @alignment: alignment required for text allocations * @flags: options for memory allocations for this range */struct execmem_range { unsigned long start; unsigned long end; unsigned long fallback_start; unsigned long fallback_end; pgprot_t pgprot; unsigned int alignment; enum execmem_range_flags flags;};
/** * struct execmem_info - architecture parameters for code allocations * @ranges: array of parameter sets defining architecture specific * parameters for executable memory allocations. The ranges that are not * explicitly initialized by an architecture use parameters defined for * @EXECMEM_DEFAULT. */struct execmem_info { struct execmem_range ranges[EXECMEM_TYPE_MAX];};
/** * execmem_arch_setup - define parameters for allocations of executable memory * * A hook for architectures to define parameters for allocations of * executable memory. These parameters should be filled into the * @execmem_info structure. * * For architectures that do not implement this method a default set of * parameters will be used * * Return: a structure defining architecture parameters and restrictions * for allocations of executable memory */struct execmem_info *execmem_arch_setup(void);
/** * execmem_alloc - allocate executable memory * @type: type of the allocation * @size: how many bytes of memory are required * * Allocates memory that will contain executable code, either generated or * loaded from kernel modules. * * Allocates memory that will contain data coupled with executable code, * like data sections in kernel modules. * * The memory will have protections defined by architecture for executable * region of the @type. * * Return: a pointer to the allocated memory or %NULL */void *execmem_alloc(enum execmem_type type, size_t size);
/** * execmem_alloc_rw - allocate writable executable memory * @type: type of the allocation * @size: how many bytes of memory are required * * Allocates memory that will contain executable code, either generated or * loaded from kernel modules. * * Allocates memory that will contain data coupled with executable code, * like data sections in kernel modules. * * Forces writable permissions on the allocated memory and the caller is * responsible to manage the permissions afterwards. * * For architectures that use ROX cache the permissions will be set to R+W. * For architectures that don't use ROX cache the default permissions for @type * will be used as they must be writable. * * Return: a pointer to the allocated memory or %NULL */void *execmem_alloc_rw(enum execmem_type type, size_t size);
/** * execmem_free - free executable memory * @ptr: pointer to the memory that should be freed */void execmem_free(void *ptr);
DEFINE_FREE(execmem, void *, if (_T) execmem_free(_T));
#ifdef CONFIG_MMU/** * execmem_vmap - create virtual mapping for EXECMEM_MODULE_DATA memory * @size: size of the virtual mapping in bytes * * Maps virtually contiguous area in the range suitable for EXECMEM_MODULE_DATA. * * Return: the area descriptor on success or %NULL on failure. */struct vm_struct *execmem_vmap(size_t size);#endif
/** * execmem_is_rox - check if execmem is read-only * @type - the execmem type to check * * Return: %true if the @type is read-only, %false if it's writable */bool execmem_is_rox(enum execmem_type type);
#if defined(CONFIG_EXECMEM) && !defined(CONFIG_ARCH_WANTS_EXECMEM_LATE)void execmem_init(void);#elsestatic inline void execmem_init(void) {}#endif
#endif /* _LINUX_EXECMEM_ALLOC_H */