| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| 503 | 55.89% | 4 | 20.00% | |
| 197 | 21.89% | 6 | 30.00% | |
| 104 | 11.56% | 2 | 10.00% | |
| 43 | 4.78% | 2 | 10.00% | |
| 20 | 2.22% | 1 | 5.00% | |
| 17 | 1.89% | 1 | 5.00% | |
| 10 | 1.11% | 1 | 5.00% | |
| 3 | 0.33% | 1 | 5.00% | |
| 2 | 0.22% | 1 | 5.00% | |
| 1 | 0.11% | 1 | 5.00% | |
| Total | 900 | 20 |
| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Dave Hansen | 503 | 55.89% | 4 | 20.00% |
| Ram Pai | 197 | 21.89% | 6 | 30.00% |
| Sandipan Das | 104 | 11.56% | 2 | 10.00% |
| Thiago Jung Bauermann | 43 | 4.78% | 2 | 10.00% |
| Keith Lucas | 20 | 2.22% | 1 | 5.00% |
| Joey Gouly | 17 | 1.89% | 1 | 5.00% |
| Kevin Brodsky | 10 | 1.11% | 1 | 5.00% |
| Kalesh Singh | 3 | 0.33% | 1 | 5.00% |
| Maciej Wieczor-Retman | 2 | 0.22% | 1 | 5.00% |
| Greg Kroah-Hartman | 1 | 0.11% | 1 | 5.00% |
| Total | 900 | 20 |
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _PKEYS_HELPER_H #define _PKEYS_HELPER_H #define _GNU_SOURCE #include <string.h> #include <stdarg.h> #include <stdio.h> #include <stdint.h> #include <stdbool.h> #include <signal.h> #include <assert.h> #include <stdlib.h> #include <ucontext.h> #include <sys/mman.h> #include "../kselftest.h" /* Define some kernel-like types */ #define u8 __u8 #define u16 __u16 #define u32 __u32 #define u64 __u64 #define PTR_ERR_ENOTSUP ((void *)-ENOTSUP) #ifndef DEBUG_LEVEL #define DEBUG_LEVEL 0 #endif #define DPRINT_IN_SIGNAL_BUF_SIZE 4096 extern int dprint_in_signal; extern char dprint_in_signal_buffer[DPRINT_IN_SIGNAL_BUF_SIZE]; extern int test_nr; extern int iteration_nr; #ifdef __GNUC__ __printf(1, 2) #endif static inline void sigsafe_printf(const char *format, ...) { va_list ap; if (!dprint_in_signal) { va_start(ap, format); vprintf(format, ap); va_end(ap); } else { int ret; /* * No printf() functions are signal-safe. * They deadlock easily. Write the format * string to get some output, even if * incomplete. */ ret = write(1, format, strlen(format)); if (ret < 0) exit(1); } } #define dprintf_level(level, args...) do { \ if (level <= DEBUG_LEVEL) \ sigsafe_printf(args); \ } while (0) #define dprintf0(args...) dprintf_level(0, args) #define dprintf1(args...) dprintf_level(1, args) #define dprintf2(args...) dprintf_level(2, args) #define dprintf3(args...) dprintf_level(3, args) #define dprintf4(args...) dprintf_level(4, args) extern void abort_hooks(void); #define pkey_assert(condition) do { \ if (!(condition)) { \ dprintf0("assert() at %s::%d test_nr: %d iteration: %d\n", \ __FILE__, __LINE__, \ test_nr, iteration_nr); \ dprintf0("errno at assert: %d", errno); \ abort_hooks(); \ exit(__LINE__); \ } \ } while (0) #define barrier() __asm__ __volatile__("": : :"memory") #ifndef noinline # define noinline __attribute__((noinline)) #endif noinline int read_ptr(int *ptr) { /* Keep GCC from optimizing this away somehow */ barrier(); return *ptr; } void expected_pkey_fault(int pkey); int sys_pkey_alloc(unsigned long flags, unsigned long init_val); int sys_pkey_free(unsigned long pkey); int mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot, unsigned long pkey); void record_pkey_malloc(void *ptr, long size, int prot); #if defined(__i386__) || defined(__x86_64__) /* arch */ #include "pkey-x86.h" #elif defined(__powerpc64__) /* arch */ #include "pkey-powerpc.h" #elif defined(__aarch64__) /* arch */ #include "pkey-arm64.h" #else /* arch */ #error Architecture not supported #endif /* arch */ #ifndef PKEY_MASK #define PKEY_MASK (PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE) #endif /* * FIXME: Remove once the generic PKEY_UNRESTRICTED definition is merged. */ #ifndef PKEY_UNRESTRICTED #define PKEY_UNRESTRICTED 0x0 #endif #ifndef set_pkey_bits static inline u64 set_pkey_bits(u64 reg, int pkey, u64 flags) { u32 shift = pkey_bit_position(pkey); /* mask out bits from pkey in old value */ reg &= ~((u64)PKEY_MASK << shift); /* OR in new bits for pkey */ reg |= (flags & PKEY_MASK) << shift; return reg; } #endif #ifndef get_pkey_bits static inline u64 get_pkey_bits(u64 reg, int pkey) { u32 shift = pkey_bit_position(pkey); /* * shift down the relevant bits to the lowest two, then * mask off all the other higher bits */ return ((reg >> shift) & PKEY_MASK); } #endif extern u64 shadow_pkey_reg; static inline u64 _read_pkey_reg(int line) { u64 pkey_reg = __read_pkey_reg(); dprintf4("read_pkey_reg(line=%d) pkey_reg: %016llx" " shadow: %016llx\n", line, pkey_reg, shadow_pkey_reg); assert(pkey_reg == shadow_pkey_reg); return pkey_reg; } #define read_pkey_reg() _read_pkey_reg(__LINE__) static inline void write_pkey_reg(u64 pkey_reg) { dprintf4("%s() changing %016llx to %016llx\n", __func__, __read_pkey_reg(), pkey_reg); /* will do the shadow check for us: */ read_pkey_reg(); __write_pkey_reg(pkey_reg); shadow_pkey_reg = pkey_reg; dprintf4("%s(%016llx) pkey_reg: %016llx\n", __func__, pkey_reg, __read_pkey_reg()); } /* * These are technically racy. since something could * change PKEY register between the read and the write. */ static inline void __pkey_access_allow(int pkey, int do_allow) { u64 pkey_reg = read_pkey_reg(); int bit = pkey * 2; if (do_allow) pkey_reg &= (1<<bit); else pkey_reg |= (1<<bit); dprintf4("pkey_reg now: %016llx\n", read_pkey_reg()); write_pkey_reg(pkey_reg); } static inline void __pkey_write_allow(int pkey, int do_allow_write) { u64 pkey_reg = read_pkey_reg(); int bit = pkey * 2 + 1; if (do_allow_write) pkey_reg &= (1<<bit); else pkey_reg |= (1<<bit); write_pkey_reg(pkey_reg); dprintf4("pkey_reg now: %016llx\n", read_pkey_reg()); } #define ALIGN_UP(x, align_to) (((x) + ((align_to)-1)) & ~((align_to)-1)) #define ALIGN_DOWN(x, align_to) ((x) & ~((align_to)-1)) #define ALIGN_PTR_UP(p, ptr_align_to) \ ((typeof(p))ALIGN_UP((unsigned long)(p), ptr_align_to)) #define ALIGN_PTR_DOWN(p, ptr_align_to) \ ((typeof(p))ALIGN_DOWN((unsigned long)(p), ptr_align_to)) #define __stringify_1(x...) #x #define __stringify(x...) __stringify_1(x) static inline u32 *siginfo_get_pkey_ptr(siginfo_t *si) { #ifdef si_pkey return &si->si_pkey; #else return (u32 *)(((u8 *)si) + si_pkey_offset); #endif } static inline int kernel_has_pkeys(void) { /* try allocating a key and see if it succeeds */ int ret = sys_pkey_alloc(0, 0); if (ret <= 0) { return 0; } sys_pkey_free(ret); return 1; } static inline int is_pkeys_supported(void) { /* check if the cpu supports pkeys */ if (!cpu_has_pkeys()) { dprintf1("SKIP: %s: no CPU support\n", __func__); return 0; } /* check if the kernel supports pkeys */ if (!kernel_has_pkeys()) { dprintf1("SKIP: %s: no kernel support\n", __func__); return 0; } return 1; } #endif /* _PKEYS_HELPER_H */