1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _PKEYS_HELPER_H 3 #define _PKEYS_HELPER_H 4 #define _GNU_SOURCE 5 #include <string.h> 6 #include <stdarg.h> 7 #include <stdio.h> 8 #include <stdint.h> 9 #include <stdbool.h> 10 #include <signal.h> 11 #include <assert.h> 12 #include <stdlib.h> 13 #include <ucontext.h> 14 #include <sys/mman.h> 15 16 #include <linux/mman.h> 17 #include <linux/types.h> 18 19 #include "kselftest.h" 20 21 /* Define some kernel-like types */ 22 typedef __u8 u8; 23 typedef __u16 u16; 24 typedef __u32 u32; 25 typedef __u64 u64; 26 27 #define PTR_ERR_ENOTSUP ((void *)-ENOTSUP) 28 29 #ifndef DEBUG_LEVEL 30 #define DEBUG_LEVEL 0 31 #endif 32 extern int dprint_in_signal; 33 34 extern int test_nr; 35 extern int iteration_nr; 36 37 #ifdef __GNUC__ 38 __printf(1, 2) 39 #endif 40 static inline void sigsafe_printf(const char *format, ...) 41 { 42 va_list ap; 43 44 if (!dprint_in_signal) { 45 va_start(ap, format); 46 vprintf(format, ap); 47 va_end(ap); 48 } else { 49 int ret; 50 /* 51 * No printf() functions are signal-safe. 52 * They deadlock easily. Write the format 53 * string to get some output, even if 54 * incomplete. 55 */ 56 ret = write(1, format, strlen(format)); 57 if (ret < 0) 58 exit(1); 59 } 60 } 61 #define dprintf_level(level, args...) do { \ 62 if (level <= DEBUG_LEVEL) \ 63 sigsafe_printf(args); \ 64 } while (0) 65 #define dprintf0(args...) dprintf_level(0, args) 66 #define dprintf1(args...) dprintf_level(1, args) 67 #define dprintf2(args...) dprintf_level(2, args) 68 #define dprintf3(args...) dprintf_level(3, args) 69 #define dprintf4(args...) dprintf_level(4, args) 70 71 extern void abort_hooks(void); 72 #define pkey_assert(condition) do { \ 73 if (!(condition)) { \ 74 dprintf0("# assert() at %s::%d test_nr: %d iteration: %d\n", \ 75 __FILE__, __LINE__, \ 76 test_nr, iteration_nr); \ 77 dprintf0("# errno at assert: %d\n", errno); \ 78 abort_hooks(); \ 79 ksft_exit_fail_msg("test %d (iteration %d)\n", \ 80 test_nr, iteration_nr); \ 81 } \ 82 } while (0) 83 84 #define barrier() __asm__ __volatile__("": : :"memory") 85 #ifndef noinline 86 # define noinline __attribute__((noinline)) 87 #endif 88 89 int sys_pkey_alloc(unsigned long flags, unsigned long init_val); 90 int sys_pkey_free(unsigned long pkey); 91 int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot, 92 unsigned long pkey); 93 94 /* For functions called from protection_keys.c only */ 95 noinline int read_ptr(int *ptr); 96 void expected_pkey_fault(int pkey); 97 int mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot, 98 unsigned long pkey); 99 void record_pkey_malloc(void *ptr, long size, int prot); 100 101 #if defined(__i386__) || defined(__x86_64__) /* arch */ 102 #include "pkey-x86.h" 103 #elif defined(__powerpc64__) /* arch */ 104 #include "pkey-powerpc.h" 105 #elif defined(__aarch64__) /* arch */ 106 #include "pkey-arm64.h" 107 #else /* arch */ 108 #error Architecture not supported 109 #endif /* arch */ 110 111 #ifndef PKEY_MASK 112 #define PKEY_MASK (PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE) 113 #endif 114 115 /* 116 * FIXME: Remove once the generic PKEY_UNRESTRICTED definition is merged. 117 */ 118 #ifndef PKEY_UNRESTRICTED 119 #define PKEY_UNRESTRICTED 0x0 120 #endif 121 122 #ifndef set_pkey_bits 123 static inline u64 set_pkey_bits(u64 reg, int pkey, u64 flags) 124 { 125 u32 shift = pkey_bit_position(pkey); 126 /* mask out bits from pkey in old value */ 127 reg &= ~((u64)PKEY_MASK << shift); 128 /* OR in new bits for pkey */ 129 reg |= (flags & PKEY_MASK) << shift; 130 return reg; 131 } 132 #endif 133 134 #ifndef get_pkey_bits 135 static inline u64 get_pkey_bits(u64 reg, int pkey) 136 { 137 u32 shift = pkey_bit_position(pkey); 138 /* 139 * shift down the relevant bits to the lowest two, then 140 * mask off all the other higher bits 141 */ 142 return ((reg >> shift) & PKEY_MASK); 143 } 144 #endif 145 146 extern u64 shadow_pkey_reg; 147 148 static inline u64 _read_pkey_reg(int line) 149 { 150 u64 pkey_reg = __read_pkey_reg(); 151 152 dprintf4("read_pkey_reg(line=%d) pkey_reg: %016llx" 153 " shadow: %016llx\n", 154 line, pkey_reg, shadow_pkey_reg); 155 assert(pkey_reg == shadow_pkey_reg); 156 157 return pkey_reg; 158 } 159 160 #define read_pkey_reg() _read_pkey_reg(__LINE__) 161 162 static inline void write_pkey_reg(u64 pkey_reg) 163 { 164 dprintf4("%s() changing %016llx to %016llx\n", __func__, 165 __read_pkey_reg(), pkey_reg); 166 /* will do the shadow check for us: */ 167 read_pkey_reg(); 168 __write_pkey_reg(pkey_reg); 169 shadow_pkey_reg = pkey_reg; 170 dprintf4("%s(%016llx) pkey_reg: %016llx\n", __func__, 171 pkey_reg, __read_pkey_reg()); 172 } 173 174 #define ALIGN_UP(x, align_to) (((x) + ((align_to)-1)) & ~((align_to)-1)) 175 #define ALIGN_DOWN(x, align_to) ((x) & ~((align_to)-1)) 176 #define ALIGN_PTR_UP(p, ptr_align_to) \ 177 ((typeof(p))ALIGN_UP((unsigned long)(p), ptr_align_to)) 178 #define ALIGN_PTR_DOWN(p, ptr_align_to) \ 179 ((typeof(p))ALIGN_DOWN((unsigned long)(p), ptr_align_to)) 180 #define __stringify_1(x...) #x 181 #define __stringify(x...) __stringify_1(x) 182 183 static inline u32 *siginfo_get_pkey_ptr(siginfo_t *si) 184 { 185 #ifdef si_pkey 186 return &si->si_pkey; 187 #else 188 return (u32 *)(((u8 *)si) + si_pkey_offset); 189 #endif 190 } 191 192 static inline int kernel_has_pkeys(void) 193 { 194 /* try allocating a key and see if it succeeds */ 195 int ret = sys_pkey_alloc(0, PKEY_UNRESTRICTED); 196 if (ret <= 0) { 197 return 0; 198 } 199 sys_pkey_free(ret); 200 return 1; 201 } 202 203 static inline int is_pkeys_supported(void) 204 { 205 /* check if the cpu supports pkeys */ 206 if (!cpu_has_pkeys()) { 207 dprintf1("SKIP: %s: no CPU support\n", __func__); 208 return 0; 209 } 210 211 /* check if the kernel supports pkeys */ 212 if (!kernel_has_pkeys()) { 213 dprintf1("SKIP: %s: no kernel support\n", __func__); 214 return 0; 215 } 216 217 return 1; 218 } 219 220 #endif /* _PKEYS_HELPER_H */ 221