History

x86/mpx: Remove selftests themselves

MPX is being removed from the kernel due to a lack of support in the toolchain going forward (gcc). Remove the x86 selftests since they have been causing some issues because of their propensity to do some debug-aiding tracepoint mucking.

Dave Hansen committed 7 years ago

Commit e28df791 parent 48febc05 files · +0 −2259Browse files

Unified · Split

5 files
  1. tools/testing/selftests/x86/mpx-debug.h +0 −15
  2. tools/testing/selftests/x86/mpx-dig.c +0 −497
  3. tools/testing/selftests/x86/mpx-hw.h +0 −124
  4. tools/testing/selftests/x86/mpx-mini-test.c +0 −1613
  5. tools/testing/selftests/x86/mpx-mm.h +0 −10
tools/testing/selftests/x86/mpx-debug.h+0−15
@@ -1,15 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0 */
2−#ifndef _MPX_DEBUG_H
3−#define _MPX_DEBUG_H
4−
5−#ifndef DEBUG_LEVEL
6−#define DEBUG_LEVEL 0
7−#endif
8−#define dprintf_level(level, args...) do { if(level <= DEBUG_LEVEL) printf(args); } while(0)
9−#define dprintf1(args...) dprintf_level(1, args)
10−#define dprintf2(args...) dprintf_level(2, args)
11−#define dprintf3(args...) dprintf_level(3, args)
12−#define dprintf4(args...) dprintf_level(4, args)
13−#define dprintf5(args...) dprintf_level(5, args)
14−
15−#endif /* _MPX_DEBUG_H */
tools/testing/selftests/x86/mpx-dig.c+0−497
@@ -1,497 +0,0 @@
1−// SPDX-License-Identifier: GPL-2.0
2−/*
3− * Written by Dave Hansen <dave.hansen@intel.com>
4− */
5−
6−#include <stdlib.h>
7−#include <sys/types.h>
8−#include <unistd.h>
9−#include <stdio.h>
10−#include <errno.h>
11−#include <sys/stat.h>
12−#include <sys/mman.h>
13−#include <string.h>
14−#include <fcntl.h>
15−#include "mpx-debug.h"
16−#include "mpx-mm.h"
17−#include "mpx-hw.h"
18−
19−unsigned long bounds_dir_global;
20−
21−#define mpx_dig_abort() __mpx_dig_abort(__FILE__, __func__, __LINE__)
22−static void inline __mpx_dig_abort(const char *file, const char *func, int line)
23−{
24− fprintf(stderr, "MPX dig abort @ %s::%d in %s()\n", file, line, func);
25− printf("MPX dig abort @ %s::%d in %s()\n", file, line, func);
26− abort();
27−}
28−
29−/*
30− * run like this (BDIR finds the probably bounds directory):
31− *
32− * BDIR="$(cat /proc/$pid/smaps | grep -B1 2097152 \
33− * | head -1 | awk -F- '{print $1}')";
34− * ./mpx-dig $pid 0x$BDIR
35− *
36− * NOTE:
37− * assumes that the only 2097152-kb VMA is the bounds dir
38− */
39−
40−long nr_incore(void *ptr, unsigned long size_bytes)
41−{
42− int i;
43− long ret = 0;
44− long vec_len = size_bytes / PAGE_SIZE;
45− unsigned char *vec = malloc(vec_len);
46− int incore_ret;
47−
48− if (!vec)
49− mpx_dig_abort();
50−
51− incore_ret = mincore(ptr, size_bytes, vec);
52− if (incore_ret) {
53− printf("mincore ret: %d\n", incore_ret);
54− perror("mincore");
55− mpx_dig_abort();
56− }
57− for (i = 0; i < vec_len; i++)
58− ret += vec[i];
59− free(vec);
60− return ret;
61−}
62−
63−int open_proc(int pid, char *file)
64−{
65− static char buf[100];
66− int fd;
67−
68− snprintf(&buf[0], sizeof(buf), "/proc/%d/%s", pid, file);
69− fd = open(&buf[0], O_RDONLY);
70− if (fd < 0)
71− perror(buf);
72−
73− return fd;
74−}
75−
76−struct vaddr_range {
77− unsigned long start;
78− unsigned long end;
79−};
80−struct vaddr_range *ranges;
81−int nr_ranges_allocated;
82−int nr_ranges_populated;
83−int last_range = -1;
84−
85−int __pid_load_vaddrs(int pid)
86−{
87− int ret = 0;
88− int proc_maps_fd = open_proc(pid, "maps");
89− char linebuf[10000];
90− unsigned long start;
91− unsigned long end;
92− char rest[1000];
93− FILE *f = fdopen(proc_maps_fd, "r");
94−
95− if (!f)
96− mpx_dig_abort();
97− nr_ranges_populated = 0;
98− while (!feof(f)) {
99− char *readret = fgets(linebuf, sizeof(linebuf), f);
100− int parsed;
101−
102− if (readret == NULL) {
103− if (feof(f))
104− break;
105− mpx_dig_abort();
106− }
107−
108− parsed = sscanf(linebuf, "%lx-%lx%s", &start, &end, rest);
109− if (parsed != 3)
110− mpx_dig_abort();
111−
112− dprintf4("result[%d]: %lx-%lx<->%s\n", parsed, start, end, rest);
113− if (nr_ranges_populated >= nr_ranges_allocated) {
114− ret = -E2BIG;
115− break;
116− }
117− ranges[nr_ranges_populated].start = start;
118− ranges[nr_ranges_populated].end = end;
119− nr_ranges_populated++;
120− }
121− last_range = -1;
122− fclose(f);
123− close(proc_maps_fd);
124− return ret;
125−}
126−
127−int pid_load_vaddrs(int pid)
128−{
129− int ret;
130−
131− dprintf2("%s(%d)\n", __func__, pid);
132− if (!ranges) {
133− nr_ranges_allocated = 4;
134− ranges = malloc(nr_ranges_allocated * sizeof(ranges[0]));
135− dprintf2("%s(%d) allocated %d ranges @ %p\n", __func__, pid,
136− nr_ranges_allocated, ranges);
137− assert(ranges != NULL);
138− }
139− do {
140− ret = __pid_load_vaddrs(pid);
141− if (!ret)
142− break;
143− if (ret == -E2BIG) {
144− dprintf2("%s(%d) need to realloc\n", __func__, pid);
145− nr_ranges_allocated *= 2;
146− ranges = realloc(ranges,
147− nr_ranges_allocated * sizeof(ranges[0]));
148− dprintf2("%s(%d) allocated %d ranges @ %p\n", __func__,
149− pid, nr_ranges_allocated, ranges);
150− assert(ranges != NULL);
151− dprintf1("reallocating to hold %d ranges\n", nr_ranges_allocated);
152− }
153− } while (1);
154−
155− dprintf2("%s(%d) done\n", __func__, pid);
156−
157− return ret;
158−}
159−
160−static inline int vaddr_in_range(unsigned long vaddr, struct vaddr_range *r)
161−{
162− if (vaddr < r->start)
163− return 0;
164− if (vaddr >= r->end)
165− return 0;
166− return 1;
167−}
168−
169−static inline int vaddr_mapped_by_range(unsigned long vaddr)
170−{
171− int i;
172−
173− if (last_range > 0 && vaddr_in_range(vaddr, &ranges[last_range]))
174− return 1;
175−
176− for (i = 0; i < nr_ranges_populated; i++) {
177− struct vaddr_range *r = &ranges[i];
178−
179− if (vaddr_in_range(vaddr, r))
180− continue;
181− last_range = i;
182− return 1;
183− }
184− return 0;
185−}
186−
187−const int bt_entry_size_bytes = sizeof(unsigned long) * 4;
188−
189−void *read_bounds_table_into_buf(unsigned long table_vaddr)
190−{
191−#ifdef MPX_DIG_STANDALONE
192− static char bt_buf[MPX_BOUNDS_TABLE_SIZE_BYTES];
193− off_t seek_ret = lseek(fd, table_vaddr, SEEK_SET);
194− if (seek_ret != table_vaddr)
195− mpx_dig_abort();
196−
197− int read_ret = read(fd, &bt_buf, sizeof(bt_buf));
198− if (read_ret != sizeof(bt_buf))
199− mpx_dig_abort();
200− return &bt_buf;
201−#else
202− return (void *)table_vaddr;
203−#endif
204−}
205−
206−int dump_table(unsigned long table_vaddr, unsigned long base_controlled_vaddr,
207− unsigned long bde_vaddr)
208−{
209− unsigned long offset_inside_bt;
210− int nr_entries = 0;
211− int do_abort = 0;
212− char *bt_buf;
213−
214− dprintf3("%s() base_controlled_vaddr: 0x%012lx bde_vaddr: 0x%012lx\n",
215− __func__, base_controlled_vaddr, bde_vaddr);
216−
217− bt_buf = read_bounds_table_into_buf(table_vaddr);
218−
219− dprintf4("%s() read done\n", __func__);
220−
221− for (offset_inside_bt = 0;
222− offset_inside_bt < MPX_BOUNDS_TABLE_SIZE_BYTES;
223− offset_inside_bt += bt_entry_size_bytes) {
224− unsigned long bt_entry_index;
225− unsigned long bt_entry_controls;
226− unsigned long this_bt_entry_for_vaddr;
227− unsigned long *bt_entry_buf;
228− int i;
229−
230− dprintf4("%s() offset_inside_bt: 0x%lx of 0x%llx\n", __func__,
231− offset_inside_bt, MPX_BOUNDS_TABLE_SIZE_BYTES);
232− bt_entry_buf = (void *)&bt_buf[offset_inside_bt];
233− if (!bt_buf) {
234− printf("null bt_buf\n");
235− mpx_dig_abort();
236− }
237− if (!bt_entry_buf) {
238− printf("null bt_entry_buf\n");
239− mpx_dig_abort();
240− }
241− dprintf4("%s() reading *bt_entry_buf @ %p\n", __func__,
242− bt_entry_buf);
243− if (!bt_entry_buf[0] &&
244− !bt_entry_buf[1] &&
245− !bt_entry_buf[2] &&
246− !bt_entry_buf[3])
247− continue;
248−
249− nr_entries++;
250−
251− bt_entry_index = offset_inside_bt/bt_entry_size_bytes;
252− bt_entry_controls = sizeof(void *);
253− this_bt_entry_for_vaddr =
254− base_controlled_vaddr + bt_entry_index*bt_entry_controls;
255− /*
256− * We sign extend vaddr bits 48->63 which effectively
257− * creates a hole in the virtual address space.
258− * This calculation corrects for the hole.
259− */
260− if (this_bt_entry_for_vaddr > 0x00007fffffffffffUL)
261− this_bt_entry_for_vaddr |= 0xffff800000000000;
262−
263− if (!vaddr_mapped_by_range(this_bt_entry_for_vaddr)) {
264− printf("bt_entry_buf: %p\n", bt_entry_buf);
265− printf("there is a bte for %lx but no mapping\n",
266− this_bt_entry_for_vaddr);
267− printf(" bde vaddr: %016lx\n", bde_vaddr);
268− printf("base_controlled_vaddr: %016lx\n", base_controlled_vaddr);
269− printf(" table_vaddr: %016lx\n", table_vaddr);
270− printf(" entry vaddr: %016lx @ offset %lx\n",
271− table_vaddr + offset_inside_bt, offset_inside_bt);
272− do_abort = 1;
273− mpx_dig_abort();
274− }
275− if (DEBUG_LEVEL < 4)
276− continue;
277−
278− printf("table entry[%lx]: ", offset_inside_bt);
279− for (i = 0; i < bt_entry_size_bytes; i += sizeof(unsigned long))
280− printf("0x%016lx ", bt_entry_buf[i]);
281− printf("\n");
282− }
283− if (do_abort)
284− mpx_dig_abort();
285− dprintf4("%s() done\n", __func__);
286− return nr_entries;
287−}
288−
289−int search_bd_buf(char *buf, int len_bytes, unsigned long bd_offset_bytes,
290− int *nr_populated_bdes)
291−{
292− unsigned long i;
293− int total_entries = 0;
294−
295− dprintf3("%s(%p, %x, %lx, ...) buf end: %p\n", __func__, buf,
296− len_bytes, bd_offset_bytes, buf + len_bytes);
297−
298− for (i = 0; i < len_bytes; i += sizeof(unsigned long)) {
299− unsigned long bd_index = (bd_offset_bytes + i) / sizeof(unsigned long);
300− unsigned long *bounds_dir_entry_ptr = (unsigned long *)&buf[i];
301− unsigned long bounds_dir_entry;
302− unsigned long bd_for_vaddr;
303− unsigned long bt_start;
304− unsigned long bt_tail;
305− int nr_entries;
306−
307− dprintf4("%s() loop i: %ld bounds_dir_entry_ptr: %p\n", __func__, i,
308− bounds_dir_entry_ptr);
309−
310− bounds_dir_entry = *bounds_dir_entry_ptr;
311− if (!bounds_dir_entry) {
312− dprintf4("no bounds dir at index 0x%lx / 0x%lx "
313− "start at offset:%lx %lx\n", bd_index, bd_index,
314− bd_offset_bytes, i);
315− continue;
316− }
317− dprintf3("found bounds_dir_entry: 0x%lx @ "
318− "index 0x%lx buf ptr: %p\n", bounds_dir_entry, i,
319− &buf[i]);
320− /* mask off the enable bit: */
321− bounds_dir_entry &= ~0x1;
322− (*nr_populated_bdes)++;
323− dprintf4("nr_populated_bdes: %p\n", nr_populated_bdes);
324− dprintf4("*nr_populated_bdes: %d\n", *nr_populated_bdes);
325−
326− bt_start = bounds_dir_entry;
327− bt_tail = bounds_dir_entry + MPX_BOUNDS_TABLE_SIZE_BYTES - 1;
328− if (!vaddr_mapped_by_range(bt_start)) {
329− printf("bounds directory 0x%lx points to nowhere\n",
330− bounds_dir_entry);
331− mpx_dig_abort();
332− }
333− if (!vaddr_mapped_by_range(bt_tail)) {
334− printf("bounds directory end 0x%lx points to nowhere\n",
335− bt_tail);
336− mpx_dig_abort();
337− }
338− /*
339− * Each bounds directory entry controls 1MB of virtual address
340− * space. This variable is the virtual address in the process
341− * of the beginning of the area controlled by this bounds_dir.
342− */
343− bd_for_vaddr = bd_index * (1UL<<20);
344−
345− nr_entries = dump_table(bounds_dir_entry, bd_for_vaddr,
346− bounds_dir_global+bd_offset_bytes+i);
347− total_entries += nr_entries;
348− dprintf5("dir entry[%4ld @ %p]: 0x%lx %6d entries "
349− "total this buf: %7d bd_for_vaddrs: 0x%lx -> 0x%lx\n",
350− bd_index, buf+i,
351− bounds_dir_entry, nr_entries, total_entries,
352− bd_for_vaddr, bd_for_vaddr + (1UL<<20));
353− }
354− dprintf3("%s(%p, %x, %lx, ...) done\n", __func__, buf, len_bytes,
355− bd_offset_bytes);
356− return total_entries;
357−}
358−
359−int proc_pid_mem_fd = -1;
360−
361−void *fill_bounds_dir_buf_other(long byte_offset_inside_bounds_dir,
362− long buffer_size_bytes, void *buffer)
363−{
364− unsigned long seekto = bounds_dir_global + byte_offset_inside_bounds_dir;
365− int read_ret;
366− off_t seek_ret = lseek(proc_pid_mem_fd, seekto, SEEK_SET);
367−
368− if (seek_ret != seekto)
369− mpx_dig_abort();
370−
371− read_ret = read(proc_pid_mem_fd, buffer, buffer_size_bytes);
372− /* there shouldn't practically be short reads of /proc/$pid/mem */
373− if (read_ret != buffer_size_bytes)
374− mpx_dig_abort();
375−
376− return buffer;
377−}
378−void *fill_bounds_dir_buf_self(long byte_offset_inside_bounds_dir,
379− long buffer_size_bytes, void *buffer)
380−
381−{
382− unsigned char vec[buffer_size_bytes / PAGE_SIZE];
383− char *dig_bounds_dir_ptr =
384− (void *)(bounds_dir_global + byte_offset_inside_bounds_dir);
385− /*
386− * use mincore() to quickly find the areas of the bounds directory
387− * that have memory and thus will be worth scanning.
388− */
389− int incore_ret;
390−
391− int incore = 0;
392− int i;
393−
394− dprintf4("%s() dig_bounds_dir_ptr: %p\n", __func__, dig_bounds_dir_ptr);
395−
396− incore_ret = mincore(dig_bounds_dir_ptr, buffer_size_bytes, &vec[0]);
397− if (incore_ret) {
398− printf("mincore ret: %d\n", incore_ret);
399− perror("mincore");
400− mpx_dig_abort();
401− }
402− for (i = 0; i < sizeof(vec); i++)
403− incore += vec[i];
404− dprintf4("%s() total incore: %d\n", __func__, incore);
405− if (!incore)
406− return NULL;
407− dprintf3("%s() total incore: %d\n", __func__, incore);
408− return dig_bounds_dir_ptr;
409−}
410−
411−int inspect_pid(int pid)
412−{
413− static int dig_nr;
414− long offset_inside_bounds_dir;
415− char bounds_dir_buf[sizeof(unsigned long) * (1UL << 15)];
416− char *dig_bounds_dir_ptr;
417− int total_entries = 0;
418− int nr_populated_bdes = 0;
419− int inspect_self;
420−
421− if (getpid() == pid) {
422− dprintf4("inspecting self\n");
423− inspect_self = 1;
424− } else {
425− dprintf4("inspecting pid %d\n", pid);
426− mpx_dig_abort();
427− }
428−
429− for (offset_inside_bounds_dir = 0;
430− offset_inside_bounds_dir < MPX_BOUNDS_TABLE_SIZE_BYTES;
431− offset_inside_bounds_dir += sizeof(bounds_dir_buf)) {
432− static int bufs_skipped;
433− int this_entries;
434−
435− if (inspect_self) {
436− dig_bounds_dir_ptr =
437− fill_bounds_dir_buf_self(offset_inside_bounds_dir,
438− sizeof(bounds_dir_buf),
439− &bounds_dir_buf[0]);
440− } else {
441− dig_bounds_dir_ptr =
442− fill_bounds_dir_buf_other(offset_inside_bounds_dir,
443− sizeof(bounds_dir_buf),
444− &bounds_dir_buf[0]);
445− }
446− if (!dig_bounds_dir_ptr) {
447− bufs_skipped++;
448− continue;
449− }
450− this_entries = search_bd_buf(dig_bounds_dir_ptr,
451− sizeof(bounds_dir_buf),
452− offset_inside_bounds_dir,
453− &nr_populated_bdes);
454− total_entries += this_entries;
455− }
456− printf("mpx dig (%3d) complete, SUCCESS (%8d / %4d)\n", ++dig_nr,
457− total_entries, nr_populated_bdes);
458− return total_entries + nr_populated_bdes;
459−}
460−
461−#ifdef MPX_DIG_REMOTE
462−int main(int argc, char **argv)
463−{
464− int err;
465− char *c;
466− unsigned long bounds_dir_entry;
467− int pid;
468−
469− printf("mpx-dig starting...\n");
470− err = sscanf(argv[1], "%d", &pid);
471− printf("parsing: '%s', err: %d\n", argv[1], err);
472− if (err != 1)
473− mpx_dig_abort();
474−
475− err = sscanf(argv[2], "%lx", &bounds_dir_global);
476− printf("parsing: '%s': %d\n", argv[2], err);
477− if (err != 1)
478− mpx_dig_abort();
479−
480− proc_pid_mem_fd = open_proc(pid, "mem");
481− if (proc_pid_mem_fd < 0)
482− mpx_dig_abort();
483−
484− inspect_pid(pid);
485− return 0;
486−}
487−#endif
488−
489−long inspect_me(struct mpx_bounds_dir *bounds_dir)
490−{
491− int pid = getpid();
492−
493− pid_load_vaddrs(pid);
494− bounds_dir_global = (unsigned long)bounds_dir;
495− dprintf4("enter %s() bounds dir: %p\n", __func__, bounds_dir);
496− return inspect_pid(pid);
497−}
tools/testing/selftests/x86/mpx-hw.h+0−124
@@ -1,124 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0 */
2−#ifndef _MPX_HW_H
3−#define _MPX_HW_H
4−
5−#include <assert.h>
6−
7−/* Describe the MPX Hardware Layout in here */
8−
9−#define NR_MPX_BOUNDS_REGISTERS 4
10−
11−#ifdef __i386__
12−
13−#define MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES 16 /* 4 * 32-bits */
14−#define MPX_BOUNDS_TABLE_SIZE_BYTES (1ULL << 14) /* 16k */
15−#define MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES 4
16−#define MPX_BOUNDS_DIR_SIZE_BYTES (1ULL << 22) /* 4MB */
17−
18−#define MPX_BOUNDS_TABLE_BOTTOM_BIT 2
19−#define MPX_BOUNDS_TABLE_TOP_BIT 11
20−#define MPX_BOUNDS_DIR_BOTTOM_BIT 12
21−#define MPX_BOUNDS_DIR_TOP_BIT 31
22−
23−#else
24−
25−/*
26− * Linear Address of "pointer" (LAp)
27− * 0 -> 2: ignored
28− * 3 -> 19: index in to bounds table
29− * 20 -> 47: index in to bounds directory
30− * 48 -> 63: ignored
31− */
32−
33−#define MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES 32
34−#define MPX_BOUNDS_TABLE_SIZE_BYTES (1ULL << 22) /* 4MB */
35−#define MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES 8
36−#define MPX_BOUNDS_DIR_SIZE_BYTES (1ULL << 31) /* 2GB */
37−
38−#define MPX_BOUNDS_TABLE_BOTTOM_BIT 3
39−#define MPX_BOUNDS_TABLE_TOP_BIT 19
40−#define MPX_BOUNDS_DIR_BOTTOM_BIT 20
41−#define MPX_BOUNDS_DIR_TOP_BIT 47
42−
43−#endif
44−
45−#define MPX_BOUNDS_DIR_NR_ENTRIES \
46− (MPX_BOUNDS_DIR_SIZE_BYTES/MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES)
47−#define MPX_BOUNDS_TABLE_NR_ENTRIES \
48− (MPX_BOUNDS_TABLE_SIZE_BYTES/MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES)
49−
50−#define MPX_BOUNDS_TABLE_ENTRY_VALID_BIT 0x1
51−
52−struct mpx_bd_entry {
53− union {
54− char x[MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES];
55− void *contents[0];
56− };
57−} __attribute__((packed));
58−
59−struct mpx_bt_entry {
60− union {
61− char x[MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES];
62− unsigned long contents[0];
63− };
64−} __attribute__((packed));
65−
66−struct mpx_bounds_dir {
67− struct mpx_bd_entry entries[MPX_BOUNDS_DIR_NR_ENTRIES];
68−} __attribute__((packed));
69−
70−struct mpx_bounds_table {
71− struct mpx_bt_entry entries[MPX_BOUNDS_TABLE_NR_ENTRIES];
72−} __attribute__((packed));
73−
74−static inline unsigned long GET_BITS(unsigned long val, int bottombit, int topbit)
75−{
76− int total_nr_bits = topbit - bottombit;
77− unsigned long mask = (1UL << total_nr_bits)-1;
78− return (val >> bottombit) & mask;
79−}
80−
81−static inline unsigned long __vaddr_bounds_table_index(void *vaddr)
82−{
83− return GET_BITS((unsigned long)vaddr, MPX_BOUNDS_TABLE_BOTTOM_BIT,
84− MPX_BOUNDS_TABLE_TOP_BIT);
85−}
86−
87−static inline unsigned long __vaddr_bounds_directory_index(void *vaddr)
88−{
89− return GET_BITS((unsigned long)vaddr, MPX_BOUNDS_DIR_BOTTOM_BIT,
90− MPX_BOUNDS_DIR_TOP_BIT);
91−}
92−
93−static inline struct mpx_bd_entry *mpx_vaddr_to_bd_entry(void *vaddr,
94− struct mpx_bounds_dir *bounds_dir)
95−{
96− unsigned long index = __vaddr_bounds_directory_index(vaddr);
97− return &bounds_dir->entries[index];
98−}
99−
100−static inline int bd_entry_valid(struct mpx_bd_entry *bounds_dir_entry)
101−{
102− unsigned long __bd_entry = (unsigned long)bounds_dir_entry->contents;
103− return (__bd_entry & MPX_BOUNDS_TABLE_ENTRY_VALID_BIT);
104−}
105−
106−static inline struct mpx_bounds_table *
107−__bd_entry_to_bounds_table(struct mpx_bd_entry *bounds_dir_entry)
108−{
109− unsigned long __bd_entry = (unsigned long)bounds_dir_entry->contents;
110− assert(__bd_entry & MPX_BOUNDS_TABLE_ENTRY_VALID_BIT);
111− __bd_entry &= ~MPX_BOUNDS_TABLE_ENTRY_VALID_BIT;
112− return (struct mpx_bounds_table *)__bd_entry;
113−}
114−
115−static inline struct mpx_bt_entry *
116−mpx_vaddr_to_bt_entry(void *vaddr, struct mpx_bounds_dir *bounds_dir)
117−{
118− struct mpx_bd_entry *bde = mpx_vaddr_to_bd_entry(vaddr, bounds_dir);
119− struct mpx_bounds_table *bt = __bd_entry_to_bounds_table(bde);
120− unsigned long index = __vaddr_bounds_table_index(vaddr);
121− return &bt->entries[index];
122−}
123−
124−#endif /* _MPX_HW_H */
tools/testing/selftests/x86/mpx-mini-test.c+0−1613
@@ -1,1613 +0,0 @@
1−// SPDX-License-Identifier: GPL-2.0-only
2−/*
3− * mpx-mini-test.c: routines to test Intel MPX (Memory Protection eXtentions)
4− *
5− * Written by:
6− * "Ren, Qiaowei" <qiaowei.ren@intel.com>
7− * "Wei, Gang" <gang.wei@intel.com>
8− * "Hansen, Dave" <dave.hansen@intel.com>
9− */
10−
11−/*
12− * 2014-12-05: Dave Hansen: fixed all of the compiler warnings, and made sure
13− * it works on 32-bit.
14− */
15−
16−int inspect_every_this_many_mallocs = 100;
17−int zap_all_every_this_many_mallocs = 1000;
18−
19−#define _GNU_SOURCE
20−#define _LARGEFILE64_SOURCE
21−
22−#include <string.h>
23−#include <stdio.h>
24−#include <stdint.h>
25−#include <stdbool.h>
26−#include <signal.h>
27−#include <assert.h>
28−#include <stdlib.h>
29−#include <ucontext.h>
30−#include <sys/mman.h>
31−#include <sys/types.h>
32−#include <sys/stat.h>
33−#include <fcntl.h>
34−#include <unistd.h>
35−
36−#include "mpx-hw.h"
37−#include "mpx-debug.h"
38−#include "mpx-mm.h"
39−
40−#ifndef __always_inline
41−#define __always_inline inline __attribute__((always_inline)
42−#endif
43−
44−#ifndef TEST_DURATION_SECS
45−#define TEST_DURATION_SECS 3
46−#endif
47−
48−void write_int_to(char *prefix, char *file, int int_to_write)
49−{
50− char buf[100];
51− int fd = open(file, O_RDWR);
52− int len;
53− int ret;
54−
55− assert(fd >= 0);
56− len = snprintf(buf, sizeof(buf), "%s%d", prefix, int_to_write);
57− assert(len >= 0);
58− assert(len < sizeof(buf));
59− ret = write(fd, buf, len);
60− assert(ret == len);
61− ret = close(fd);
62− assert(!ret);
63−}
64−
65−void write_pid_to(char *prefix, char *file)
66−{
67− write_int_to(prefix, file, getpid());
68−}
69−
70−void trace_me(void)
71−{
72−/* tracing events dir */
73−#define TED "/sys/kernel/debug/tracing/events/"
74−/*
75− write_pid_to("common_pid=", TED "signal/filter");
76− write_pid_to("common_pid=", TED "exceptions/filter");
77− write_int_to("", TED "signal/enable", 1);
78− write_int_to("", TED "exceptions/enable", 1);
79−*/
80− write_pid_to("", "/sys/kernel/debug/tracing/set_ftrace_pid");
81− write_int_to("", "/sys/kernel/debug/tracing/trace", 0);
82−}
83−
84−#define test_failed() __test_failed(__FILE__, __LINE__)
85−static void __test_failed(char *f, int l)
86−{
87− fprintf(stderr, "abort @ %s::%d\n", f, l);
88− abort();
89−}
90−
91−/* Error Printf */
92−#define eprintf(args...) fprintf(stderr, args)
93−
94−#ifdef __i386__
95−
96−/* i386 directory size is 4MB */
97−#define REG_IP_IDX REG_EIP
98−#define REX_PREFIX
99−
100−#define XSAVE_OFFSET_IN_FPMEM sizeof(struct _libc_fpstate)
101−
102−/*
103− * __cpuid() is from the Linux Kernel:
104− */
105−static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
106− unsigned int *ecx, unsigned int *edx)
107−{
108− /* ecx is often an input as well as an output. */
109− asm volatile(
110− "push %%ebx;"
111− "cpuid;"
112− "mov %%ebx, %1;"
113− "pop %%ebx"
114− : "=a" (*eax),
115− "=g" (*ebx),
116− "=c" (*ecx),
117− "=d" (*edx)
118− : "0" (*eax), "2" (*ecx));
119−}
120−
121−#else /* __i386__ */
122−
123−#define REG_IP_IDX REG_RIP
124−#define REX_PREFIX "0x48, "
125−
126−#define XSAVE_OFFSET_IN_FPMEM 0
127−
128−/*
129− * __cpuid() is from the Linux Kernel:
130− */
131−static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
132− unsigned int *ecx, unsigned int *edx)
133−{
134− /* ecx is often an input as well as an output. */
135− asm volatile(
136− "cpuid;"
137− : "=a" (*eax),
138− "=b" (*ebx),
139− "=c" (*ecx),
140− "=d" (*edx)
141− : "0" (*eax), "2" (*ecx));
142−}
143−
144−#endif /* !__i386__ */
145−
146−struct xsave_hdr_struct {
147− uint64_t xstate_bv;
148− uint64_t reserved1[2];
149− uint64_t reserved2[5];
150−} __attribute__((packed));
151−
152−struct bndregs_struct {
153− uint64_t bndregs[8];
154−} __attribute__((packed));
155−
156−struct bndcsr_struct {
157− uint64_t cfg_reg_u;
158− uint64_t status_reg;
159−} __attribute__((packed));
160−
161−struct xsave_struct {
162− uint8_t fpu_sse[512];
163− struct xsave_hdr_struct xsave_hdr;
164− uint8_t ymm[256];
165− uint8_t lwp[128];
166− struct bndregs_struct bndregs;
167− struct bndcsr_struct bndcsr;
168−} __attribute__((packed));
169−
170−uint8_t __attribute__((__aligned__(64))) buffer[4096];
171−struct xsave_struct *xsave_buf = (struct xsave_struct *)buffer;
172−
173−uint8_t __attribute__((__aligned__(64))) test_buffer[4096];
174−struct xsave_struct *xsave_test_buf = (struct xsave_struct *)test_buffer;
175−
176−uint64_t num_bnd_chk;
177−
178−static __always_inline void xrstor_state(struct xsave_struct *fx, uint64_t mask)
179−{
180− uint32_t lmask = mask;
181− uint32_t hmask = mask >> 32;
182−
183− asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x2f\n\t"
184− : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
185− : "memory");
186−}
187−
188−static __always_inline void xsave_state_1(void *_fx, uint64_t mask)
189−{
190− uint32_t lmask = mask;
191− uint32_t hmask = mask >> 32;
192− unsigned char *fx = _fx;
193−
194− asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x27\n\t"
195− : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
196− : "memory");
197−}
198−
199−static inline uint64_t xgetbv(uint32_t index)
200−{
201− uint32_t eax, edx;
202−
203− asm volatile(".byte 0x0f,0x01,0xd0" /* xgetbv */
204− : "=a" (eax), "=d" (edx)
205− : "c" (index));
206− return eax + ((uint64_t)edx << 32);
207−}
208−
209−static uint64_t read_mpx_status_sig(ucontext_t *uctxt)
210−{
211− memset(buffer, 0, sizeof(buffer));
212− memcpy(buffer,
213− (uint8_t *)uctxt->uc_mcontext.fpregs + XSAVE_OFFSET_IN_FPMEM,
214− sizeof(struct xsave_struct));
215−
216− return xsave_buf->bndcsr.status_reg;
217−}
218−
219−#include <pthread.h>
220−
221−static uint8_t *get_next_inst_ip(uint8_t *addr)
222−{
223− uint8_t *ip = addr;
224− uint8_t sib;
225− uint8_t rm;
226− uint8_t mod;
227− uint8_t base;
228− uint8_t modrm;
229−
230− /* determine the prefix. */
231− switch(*ip) {
232− case 0xf2:
233− case 0xf3:
234− case 0x66:
235− ip++;
236− break;
237− }
238−
239− /* look for rex prefix */
240− if ((*ip & 0x40) == 0x40)
241− ip++;
242−
243− /* Make sure we have a MPX instruction. */
244− if (*ip++ != 0x0f)
245− return addr;
246−
247− /* Skip the op code byte. */
248− ip++;
249−
250− /* Get the modrm byte. */
251− modrm = *ip++;
252−
253− /* Break it down into parts. */
254− rm = modrm & 7;
255− mod = (modrm >> 6);
256−
257− /* Init the parts of the address mode. */
258− base = 8;
259−
260− /* Is it a mem mode? */
261− if (mod != 3) {
262− /* look for scaled indexed addressing */
263− if (rm == 4) {
264− /* SIB addressing */
265− sib = *ip++;
266− base = sib & 7;
267− switch (mod) {
268− case 0:
269− if (base == 5)
270− ip += 4;
271− break;
272−
273− case 1:
274− ip++;
275− break;
276−
277− case 2:
278− ip += 4;
279− break;
280− }
281−
282− } else {
283− /* MODRM addressing */
284− switch (mod) {
285− case 0:
286− /* DISP32 addressing, no base */
287− if (rm == 5)
288− ip += 4;
289− break;
290−
291− case 1:
292− ip++;
293− break;
294−
295− case 2:
296− ip += 4;
297− break;
298− }
299− }
300− }
301− return ip;
302−}
303−
304−#ifdef si_lower
305−static inline void *__si_bounds_lower(siginfo_t *si)
306−{
307− return si->si_lower;
308−}
309−
310−static inline void *__si_bounds_upper(siginfo_t *si)
311−{
312− return si->si_upper;
313−}
314−#else
315−
316−/*
317− * This deals with old version of _sigfault in some distros:
318− *
319−
320−old _sigfault:
321− struct {
322− void *si_addr;
323− } _sigfault;
324−
325−new _sigfault:
326− struct {
327− void __user *_addr;
328− int _trapno;
329− short _addr_lsb;
330− union {
331− struct {
332− void __user *_lower;
333− void __user *_upper;
334− } _addr_bnd;
335− __u32 _pkey;
336− };
337− } _sigfault;
338− *
339− */
340−
341−static inline void **__si_bounds_hack(siginfo_t *si)
342−{
343− void *sigfault = &si->_sifields._sigfault;
344− void *end_sigfault = sigfault + sizeof(si->_sifields._sigfault);
345− int *trapno = (int*)end_sigfault;
346− /* skip _trapno and _addr_lsb */
347− void **__si_lower = (void**)(trapno + 2);
348−
349− return __si_lower;
350−}
351−
352−static inline void *__si_bounds_lower(siginfo_t *si)
353−{
354− return *__si_bounds_hack(si);
355−}
356−
357−static inline void *__si_bounds_upper(siginfo_t *si)
358−{
359− return *(__si_bounds_hack(si) + 1);
360−}
361−#endif
362−
363−static int br_count;
364−static int expected_bnd_index = -1;
365−uint64_t shadow_plb[NR_MPX_BOUNDS_REGISTERS][2]; /* shadow MPX bound registers */
366−unsigned long shadow_map[NR_MPX_BOUNDS_REGISTERS];
367−
368−/* Failed address bound checks: */
369−#ifndef SEGV_BNDERR
370−# define SEGV_BNDERR 3
371−#endif
372−
373−/*
374− * The kernel is supposed to provide some information about the bounds
375− * exception in the siginfo. It should match what we have in the bounds
376− * registers that we are checking against. Just check against the shadow copy
377− * since it is easily available, and we also check that *it* matches the real
378− * registers.
379− */
380−void check_siginfo_vs_shadow(siginfo_t* si)
381−{
382− int siginfo_ok = 1;
383− void *shadow_lower = (void *)(unsigned long)shadow_plb[expected_bnd_index][0];
384− void *shadow_upper = (void *)(unsigned long)shadow_plb[expected_bnd_index][1];
385−
386− if ((expected_bnd_index < 0) ||
387− (expected_bnd_index >= NR_MPX_BOUNDS_REGISTERS)) {
388− fprintf(stderr, "ERROR: invalid expected_bnd_index: %d\n",
389− expected_bnd_index);
390− exit(6);
391− }
392− if (__si_bounds_lower(si) != shadow_lower)
393− siginfo_ok = 0;
394− if (__si_bounds_upper(si) != shadow_upper)
395− siginfo_ok = 0;
396−
397− if (!siginfo_ok) {
398− fprintf(stderr, "ERROR: siginfo bounds do not match "
399− "shadow bounds for register %d\n", expected_bnd_index);
400− exit(7);
401− }
402−}
403−
404−void handler(int signum, siginfo_t *si, void *vucontext)
405−{
406− int i;
407− ucontext_t *uctxt = vucontext;
408− int trapno;
409− unsigned long ip;
410−
411− dprintf1("entered signal handler\n");
412−
413− trapno = uctxt->uc_mcontext.gregs[REG_TRAPNO];
414− ip = uctxt->uc_mcontext.gregs[REG_IP_IDX];
415−
416− if (trapno == 5) {
417− typeof(si->si_addr) *si_addr_ptr = &si->si_addr;
418− uint64_t status = read_mpx_status_sig(uctxt);
419− uint64_t br_reason = status & 0x3;
420−
421− br_count++;
422− dprintf1("#BR 0x%jx (total seen: %d)\n", status, br_count);
423−
424− dprintf2("Saw a #BR! status 0x%jx at %016lx br_reason: %jx\n",
425− status, ip, br_reason);
426− dprintf2("si_signo: %d\n", si->si_signo);
427− dprintf2(" signum: %d\n", signum);
428− dprintf2("info->si_code == SEGV_BNDERR: %d\n",
429− (si->si_code == SEGV_BNDERR));
430− dprintf2("info->si_code: %d\n", si->si_code);
431− dprintf2("info->si_lower: %p\n", __si_bounds_lower(si));
432− dprintf2("info->si_upper: %p\n", __si_bounds_upper(si));
433−
434− for (i = 0; i < 8; i++)
435− dprintf3("[%d]: %p\n", i, si_addr_ptr[i]);
436− switch (br_reason) {
437− case 0: /* traditional BR */
438− fprintf(stderr,
439− "Undefined status with bound exception:%jx\n",
440− status);
441− exit(5);
442− case 1: /* #BR MPX bounds exception */
443− /* these are normal and we expect to see them */
444−
445− check_siginfo_vs_shadow(si);
446−
447− dprintf1("bounds exception (normal): status 0x%jx at %p si_addr: %p\n",
448− status, (void *)ip, si->si_addr);
449− num_bnd_chk++;
450− uctxt->uc_mcontext.gregs[REG_IP_IDX] =
451− (greg_t)get_next_inst_ip((uint8_t *)ip);
452− break;
453− case 2:
454− fprintf(stderr, "#BR status == 2, missing bounds table,"
455− "kernel should have handled!!\n");
456− exit(4);
457− break;
458− default:
459− fprintf(stderr, "bound check error: status 0x%jx at %p\n",
460− status, (void *)ip);
461− num_bnd_chk++;
462− uctxt->uc_mcontext.gregs[REG_IP_IDX] =
463− (greg_t)get_next_inst_ip((uint8_t *)ip);
464− fprintf(stderr, "bound check error: si_addr %p\n", si->si_addr);
465− exit(3);
466− }
467− } else if (trapno == 14) {
468− eprintf("ERROR: In signal handler, page fault, trapno = %d, ip = %016lx\n",
469− trapno, ip);
470− eprintf("si_addr %p\n", si->si_addr);
471− eprintf("REG_ERR: %lx\n", (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
472− test_failed();
473− } else {
474− eprintf("unexpected trap %d! at 0x%lx\n", trapno, ip);
475− eprintf("si_addr %p\n", si->si_addr);
476− eprintf("REG_ERR: %lx\n", (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
477− test_failed();
478− }
479−}
480−
481−static inline void cpuid_count(unsigned int op, int count,
482− unsigned int *eax, unsigned int *ebx,
483− unsigned int *ecx, unsigned int *edx)
484−{
485− *eax = op;
486− *ecx = count;
487− __cpuid(eax, ebx, ecx, edx);
488−}
489−
490−#define XSTATE_CPUID 0x0000000d
491−
492−/*
493− * List of XSAVE features Linux knows about:
494− */
495−enum xfeature_bit {
496− XSTATE_BIT_FP,
497− XSTATE_BIT_SSE,
498− XSTATE_BIT_YMM,
499− XSTATE_BIT_BNDREGS,
500− XSTATE_BIT_BNDCSR,
501− XSTATE_BIT_OPMASK,
502− XSTATE_BIT_ZMM_Hi256,
503− XSTATE_BIT_Hi16_ZMM,
504−
505− XFEATURES_NR_MAX,
506−};
507−
508−#define XSTATE_FP (1 << XSTATE_BIT_FP)
509−#define XSTATE_SSE (1 << XSTATE_BIT_SSE)
510−#define XSTATE_YMM (1 << XSTATE_BIT_YMM)
511−#define XSTATE_BNDREGS (1 << XSTATE_BIT_BNDREGS)
512−#define XSTATE_BNDCSR (1 << XSTATE_BIT_BNDCSR)
513−#define XSTATE_OPMASK (1 << XSTATE_BIT_OPMASK)
514−#define XSTATE_ZMM_Hi256 (1 << XSTATE_BIT_ZMM_Hi256)
515−#define XSTATE_Hi16_ZMM (1 << XSTATE_BIT_Hi16_ZMM)
516−
517−#define MPX_XSTATES (XSTATE_BNDREGS | XSTATE_BNDCSR) /* 0x18 */
518−
519−bool one_bit(unsigned int x, int bit)
520−{
521− return !!(x & (1<<bit));
522−}
523−
524−void print_state_component(int state_bit_nr, char *name)
525−{
526− unsigned int eax, ebx, ecx, edx;
527− unsigned int state_component_size;
528− unsigned int state_component_supervisor;
529− unsigned int state_component_user;
530− unsigned int state_component_aligned;
531−
532− /* See SDM Section 13.2 */
533− cpuid_count(XSTATE_CPUID, state_bit_nr, &eax, &ebx, &ecx, &edx);
534− assert(eax || ebx || ecx);
535− state_component_size = eax;
536− state_component_supervisor = ((!ebx) && one_bit(ecx, 0));
537− state_component_user = !one_bit(ecx, 0);
538− state_component_aligned = one_bit(ecx, 1);
539− printf("%8s: size: %d user: %d supervisor: %d aligned: %d\n",
540− name,
541− state_component_size, state_component_user,
542− state_component_supervisor, state_component_aligned);
543−
544−}
545−
546−/* Intel-defined CPU features, CPUID level 0x00000001 (ecx) */
547−#define XSAVE_FEATURE_BIT (26) /* XSAVE/XRSTOR/XSETBV/XGETBV */
548−#define OSXSAVE_FEATURE_BIT (27) /* XSAVE enabled in the OS */
549−
550−bool check_mpx_support(void)
551−{
552− unsigned int eax, ebx, ecx, edx;
553−
554− cpuid_count(1, 0, &eax, &ebx, &ecx, &edx);
555−
556− /* We can't do much without XSAVE, so just make these assert()'s */
557− if (!one_bit(ecx, XSAVE_FEATURE_BIT)) {
558− fprintf(stderr, "processor lacks XSAVE, can not run MPX tests\n");
559− exit(0);
560− }
561−
562− if (!one_bit(ecx, OSXSAVE_FEATURE_BIT)) {
563− fprintf(stderr, "processor lacks OSXSAVE, can not run MPX tests\n");
564− exit(0);
565− }
566−
567− /* CPUs not supporting the XSTATE CPUID leaf do not support MPX */
568− /* Is this redundant with the feature bit checks? */
569− cpuid_count(0, 0, &eax, &ebx, &ecx, &edx);
570− if (eax < XSTATE_CPUID) {
571− fprintf(stderr, "processor lacks XSTATE CPUID leaf,"
572− " can not run MPX tests\n");
573− exit(0);
574− }
575−
576− printf("XSAVE is supported by HW & OS\n");
577−
578− cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
579−
580− printf("XSAVE processor supported state mask: 0x%x\n", eax);
581− printf("XSAVE OS supported state mask: 0x%jx\n", xgetbv(0));
582−
583− /* Make sure that the MPX states are enabled in in XCR0 */
584− if ((eax & MPX_XSTATES) != MPX_XSTATES) {
585− fprintf(stderr, "processor lacks MPX XSTATE(s), can not run MPX tests\n");
586− exit(0);
587− }
588−
589− /* Make sure the MPX states are supported by XSAVE* */
590− if ((xgetbv(0) & MPX_XSTATES) != MPX_XSTATES) {
591− fprintf(stderr, "MPX XSTATE(s) no enabled in XCR0, "
592− "can not run MPX tests\n");
593− exit(0);
594− }
595−
596− print_state_component(XSTATE_BIT_BNDREGS, "BNDREGS");
597− print_state_component(XSTATE_BIT_BNDCSR, "BNDCSR");
598−
599− return true;
600−}
601−
602−void enable_mpx(void *l1base)
603−{
604− /* enable point lookup */
605− memset(buffer, 0, sizeof(buffer));
606− xrstor_state(xsave_buf, 0x18);
607−
608− xsave_buf->xsave_hdr.xstate_bv = 0x10;
609− xsave_buf->bndcsr.cfg_reg_u = (unsigned long)l1base | 1;
610− xsave_buf->bndcsr.status_reg = 0;
611−
612− dprintf2("bf xrstor\n");
613− dprintf2("xsave cndcsr: status %jx, configu %jx\n",
614− xsave_buf->bndcsr.status_reg, xsave_buf->bndcsr.cfg_reg_u);
615− xrstor_state(xsave_buf, 0x18);
616− dprintf2("after xrstor\n");
617−
618− xsave_state_1(xsave_buf, 0x18);
619−
620− dprintf1("xsave bndcsr: status %jx, configu %jx\n",
621− xsave_buf->bndcsr.status_reg, xsave_buf->bndcsr.cfg_reg_u);
622−}
623−
624−#include <sys/prctl.h>
625−
626−struct mpx_bounds_dir *bounds_dir_ptr;
627−
628−unsigned long __bd_incore(const char *func, int line)
629−{
630− unsigned long ret = nr_incore(bounds_dir_ptr, MPX_BOUNDS_DIR_SIZE_BYTES);
631− return ret;
632−}
633−#define bd_incore() __bd_incore(__func__, __LINE__)
634−
635−void check_clear(void *ptr, unsigned long sz)
636−{
637− unsigned long *i;
638−
639− for (i = ptr; (void *)i < ptr + sz; i++) {
640− if (*i) {
641− dprintf1("%p is NOT clear at %p\n", ptr, i);
642− assert(0);
643− }
644− }
645− dprintf1("%p is clear for %lx\n", ptr, sz);
646−}
647−
648−void check_clear_bd(void)
649−{
650− check_clear(bounds_dir_ptr, 2UL << 30);
651−}
652−
653−#define USE_MALLOC_FOR_BOUNDS_DIR 1
654−bool process_specific_init(void)
655−{
656− unsigned long size;
657− unsigned long *dir;
658− /* Guarantee we have the space to align it, add padding: */
659− unsigned long pad = getpagesize();
660−
661− size = 2UL << 30; /* 2GB */
662− if (sizeof(unsigned long) == 4)
663− size = 4UL << 20; /* 4MB */
664− dprintf1("trying to allocate %ld MB bounds directory\n", (size >> 20));
665−
666− if (USE_MALLOC_FOR_BOUNDS_DIR) {
667− unsigned long _dir;
668−
669− dir = malloc(size + pad);
670− assert(dir);
671− _dir = (unsigned long)dir;
672− _dir += 0xfffUL;
673− _dir &= ~0xfffUL;
674− dir = (void *)_dir;
675− } else {
676− /*
677− * This makes debugging easier because the address
678− * calculations are simpler:
679− */
680− dir = mmap((void *)0x200000000000, size + pad,
681− PROT_READ|PROT_WRITE,
682− MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
683− if (dir == (void *)-1) {
684− perror("unable to allocate bounds directory");
685− abort();
686− }
687− check_clear(dir, size);
688− }
689− bounds_dir_ptr = (void *)dir;
690− madvise(bounds_dir_ptr, size, MADV_NOHUGEPAGE);
691− bd_incore();
692− dprintf1("bounds directory: 0x%p -> 0x%p\n", bounds_dir_ptr,
693− (char *)bounds_dir_ptr + size);
694− check_clear(dir, size);
695− enable_mpx(dir);
696− check_clear(dir, size);
697− if (prctl(43, 0, 0, 0, 0)) {
698− printf("no MPX support\n");
699− abort();
700− return false;
701− }
702− return true;
703−}
704−
705−bool process_specific_finish(void)
706−{
707− if (prctl(44)) {
708− printf("no MPX support\n");
709− return false;
710− }
711− return true;
712−}
713−
714−void setup_handler()
715−{
716− int r, rs;
717− struct sigaction newact;
718− struct sigaction oldact;
719−
720− /* #BR is mapped to sigsegv */
721− int signum = SIGSEGV;
722−
723− newact.sa_handler = 0; /* void(*)(int)*/
724− newact.sa_sigaction = handler; /* void (*)(int, siginfo_t*, void *) */
725−
726− /*sigset_t - signals to block while in the handler */
727− /* get the old signal mask. */
728− rs = sigprocmask(SIG_SETMASK, 0, &newact.sa_mask);
729− assert(rs == 0);
730−
731− /* call sa_sigaction, not sa_handler*/
732− newact.sa_flags = SA_SIGINFO;
733−
734− newact.sa_restorer = 0; /* void(*)(), obsolete */
735− r = sigaction(signum, &newact, &oldact);
736− assert(r == 0);
737−}
738−
739−void mpx_prepare(void)
740−{
741− dprintf2("%s()\n", __func__);
742− setup_handler();
743− process_specific_init();
744−}
745−
746−void mpx_cleanup(void)
747−{
748− printf("%s(): %jd BRs. bye...\n", __func__, num_bnd_chk);
749− process_specific_finish();
750−}
751−
752−/*-------------- the following is test case ---------------*/
753−#include <stdint.h>
754−#include <stdbool.h>
755−#include <stdlib.h>
756−#include <stdio.h>
757−#include <time.h>
758−
759−uint64_t num_lower_brs;
760−uint64_t num_upper_brs;
761−
762−#define MPX_CONFIG_OFFSET 1024
763−#define MPX_BOUNDS_OFFSET 960
764−#define MPX_HEADER_OFFSET 512
765−#define MAX_ADDR_TESTED (1<<28)
766−#define TEST_ROUNDS 100
767−
768−/*
769− 0F 1A /r BNDLDX-Load
770− 0F 1B /r BNDSTX-Store Extended Bounds Using Address Translation
771− 66 0F 1A /r BNDMOV bnd1, bnd2/m128
772− 66 0F 1B /r BNDMOV bnd1/m128, bnd2
773− F2 0F 1A /r BNDCU bnd, r/m64
774− F2 0F 1B /r BNDCN bnd, r/m64
775− F3 0F 1A /r BNDCL bnd, r/m64
776− F3 0F 1B /r BNDMK bnd, m64
777−*/
778−
779−static __always_inline void xsave_state(void *_fx, uint64_t mask)
780−{
781− uint32_t lmask = mask;
782− uint32_t hmask = mask >> 32;
783− unsigned char *fx = _fx;
784−
785− asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x27\n\t"
786− : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
787− : "memory");
788−}
789−
790−static __always_inline void mpx_clear_bnd0(void)
791−{
792− long size = 0;
793− void *ptr = NULL;
794− /* F3 0F 1B /r BNDMK bnd, m64 */
795− /* f3 0f 1b 04 11 bndmk (%rcx,%rdx,1),%bnd0 */
796− asm volatile(".byte 0xf3,0x0f,0x1b,0x04,0x11\n\t"
797− : : "c" (ptr), "d" (size-1)
798− : "memory");
799−}
800−
801−static __always_inline void mpx_make_bound_helper(unsigned long ptr,
802− unsigned long size)
803−{
804− /* F3 0F 1B /r BNDMK bnd, m64 */
805− /* f3 0f 1b 04 11 bndmk (%rcx,%rdx,1),%bnd0 */
806− asm volatile(".byte 0xf3,0x0f,0x1b,0x04,0x11\n\t"
807− : : "c" (ptr), "d" (size-1)
808− : "memory");
809−}
810−
811−static __always_inline void mpx_check_lowerbound_helper(unsigned long ptr)
812−{
813− /* F3 0F 1A /r NDCL bnd, r/m64 */
814− /* f3 0f 1a 01 bndcl (%rcx),%bnd0 */
815− asm volatile(".byte 0xf3,0x0f,0x1a,0x01\n\t"
816− : : "c" (ptr)
817− : "memory");
818−}
819−
820−static __always_inline void mpx_check_upperbound_helper(unsigned long ptr)
821−{
822− /* F2 0F 1A /r BNDCU bnd, r/m64 */
823− /* f2 0f 1a 01 bndcu (%rcx),%bnd0 */
824− asm volatile(".byte 0xf2,0x0f,0x1a,0x01\n\t"
825− : : "c" (ptr)
826− : "memory");
827−}
828−
829−static __always_inline void mpx_movbndreg_helper()
830−{
831− /* 66 0F 1B /r BNDMOV bnd1/m128, bnd2 */
832− /* 66 0f 1b c2 bndmov %bnd0,%bnd2 */
833−
834− asm volatile(".byte 0x66,0x0f,0x1b,0xc2\n\t");
835−}
836−
837−static __always_inline void mpx_movbnd2mem_helper(uint8_t *mem)
838−{
839− /* 66 0F 1B /r BNDMOV bnd1/m128, bnd2 */
840− /* 66 0f 1b 01 bndmov %bnd0,(%rcx) */
841− asm volatile(".byte 0x66,0x0f,0x1b,0x01\n\t"
842− : : "c" (mem)
843− : "memory");
844−}
845−
846−static __always_inline void mpx_movbnd_from_mem_helper(uint8_t *mem)
847−{
848− /* 66 0F 1A /r BNDMOV bnd1, bnd2/m128 */
849− /* 66 0f 1a 01 bndmov (%rcx),%bnd0 */
850− asm volatile(".byte 0x66,0x0f,0x1a,0x01\n\t"
851− : : "c" (mem)
852− : "memory");
853−}
854−
855−static __always_inline void mpx_store_dsc_helper(unsigned long ptr_addr,
856− unsigned long ptr_val)
857−{
858− /* 0F 1B /r BNDSTX-Store Extended Bounds Using Address Translation */
859− /* 0f 1b 04 11 bndstx %bnd0,(%rcx,%rdx,1) */
860− asm volatile(".byte 0x0f,0x1b,0x04,0x11\n\t"
861− : : "c" (ptr_addr), "d" (ptr_val)
862− : "memory");
863−}
864−
865−static __always_inline void mpx_load_dsc_helper(unsigned long ptr_addr,
866− unsigned long ptr_val)
867−{
868− /* 0F 1A /r BNDLDX-Load */
869− /*/ 0f 1a 04 11 bndldx (%rcx,%rdx,1),%bnd0 */
870− asm volatile(".byte 0x0f,0x1a,0x04,0x11\n\t"
871− : : "c" (ptr_addr), "d" (ptr_val)
872− : "memory");
873−}
874−
875−void __print_context(void *__print_xsave_buffer, int line)
876−{
877− uint64_t *bounds = (uint64_t *)(__print_xsave_buffer + MPX_BOUNDS_OFFSET);
878− uint64_t *cfg = (uint64_t *)(__print_xsave_buffer + MPX_CONFIG_OFFSET);
879−
880− int i;
881− eprintf("%s()::%d\n", "print_context", line);
882− for (i = 0; i < 4; i++) {
883− eprintf("bound[%d]: 0x%016lx 0x%016lx(0x%016lx)\n", i,
884− (unsigned long)bounds[i*2],
885− ~(unsigned long)bounds[i*2+1],
886− (unsigned long)bounds[i*2+1]);
887− }
888−
889− eprintf("cpcfg: %jx cpstatus: %jx\n", cfg[0], cfg[1]);
890−}
891−#define print_context(x) __print_context(x, __LINE__)
892−#ifdef DEBUG
893−#define dprint_context(x) print_context(x)
894−#else
895−#define dprint_context(x) do{}while(0)
896−#endif
897−
898−void init()
899−{
900− int i;
901−
902− srand((unsigned int)time(NULL));
903−
904− for (i = 0; i < 4; i++) {
905− shadow_plb[i][0] = 0;
906− shadow_plb[i][1] = ~(unsigned long)0;
907− }
908−}
909−
910−long int __mpx_random(int line)
911−{
912−#ifdef NOT_SO_RANDOM
913− static long fake = 722122311;
914− fake += 563792075;
915− return fakse;
916−#else
917− return random();
918−#endif
919−}
920−#define mpx_random() __mpx_random(__LINE__)
921−
922−uint8_t *get_random_addr()
923−{
924− uint8_t*addr = (uint8_t *)(unsigned long)(rand() % MAX_ADDR_TESTED);
925− return (addr - (unsigned long)addr % sizeof(uint8_t *));
926−}
927−
928−static inline bool compare_context(void *__xsave_buffer)
929−{
930− uint64_t *bounds = (uint64_t *)(__xsave_buffer + MPX_BOUNDS_OFFSET);
931−
932− int i;
933− for (i = 0; i < 4; i++) {
934− dprintf3("shadow[%d]{%016lx/%016lx}\nbounds[%d]{%016lx/%016lx}\n",
935− i, (unsigned long)shadow_plb[i][0], (unsigned long)shadow_plb[i][1],
936− i, (unsigned long)bounds[i*2], ~(unsigned long)bounds[i*2+1]);
937− if ((shadow_plb[i][0] != bounds[i*2]) ||
938− (shadow_plb[i][1] != ~(unsigned long)bounds[i*2+1])) {
939− eprintf("ERROR comparing shadow to real bound register %d\n", i);
940− eprintf("shadow{0x%016lx/0x%016lx}\nbounds{0x%016lx/0x%016lx}\n",
941− (unsigned long)shadow_plb[i][0], (unsigned long)shadow_plb[i][1],
942− (unsigned long)bounds[i*2], (unsigned long)bounds[i*2+1]);
943− return false;
944− }
945− }
946−
947− return true;
948−}
949−
950−void mkbnd_shadow(uint8_t *ptr, int index, long offset)
951−{
952− uint64_t *lower = (uint64_t *)&(shadow_plb[index][0]);
953− uint64_t *upper = (uint64_t *)&(shadow_plb[index][1]);
954− *lower = (unsigned long)ptr;
955− *upper = (unsigned long)ptr + offset - 1;
956−}
957−
958−void check_lowerbound_shadow(uint8_t *ptr, int index)
959−{
960− uint64_t *lower = (uint64_t *)&(shadow_plb[index][0]);
961− if (*lower > (uint64_t)(unsigned long)ptr)
962− num_lower_brs++;
963− else
964− dprintf1("LowerBoundChk passed:%p\n", ptr);
965−}
966−
967−void check_upperbound_shadow(uint8_t *ptr, int index)
968−{
969− uint64_t upper = *(uint64_t *)&(shadow_plb[index][1]);
970− if (upper < (uint64_t)(unsigned long)ptr)
971− num_upper_brs++;
972− else
973− dprintf1("UpperBoundChk passed:%p\n", ptr);
974−}
975−
976−__always_inline void movbndreg_shadow(int src, int dest)
977−{
978− shadow_plb[dest][0] = shadow_plb[src][0];
979− shadow_plb[dest][1] = shadow_plb[src][1];
980−}
981−
982−__always_inline void movbnd2mem_shadow(int src, unsigned long *dest)
983−{
984− unsigned long *lower = (unsigned long *)&(shadow_plb[src][0]);
985− unsigned long *upper = (unsigned long *)&(shadow_plb[src][1]);
986− *dest = *lower;
987− *(dest+1) = *upper;
988−}
989−
990−__always_inline void movbnd_from_mem_shadow(unsigned long *src, int dest)
991−{
992− unsigned long *lower = (unsigned long *)&(shadow_plb[dest][0]);
993− unsigned long *upper = (unsigned long *)&(shadow_plb[dest][1]);
994− *lower = *src;
995− *upper = *(src+1);
996−}
997−
998−__always_inline void stdsc_shadow(int index, uint8_t *ptr, uint8_t *ptr_val)
999−{
1000− shadow_map[0] = (unsigned long)shadow_plb[index][0];
1001− shadow_map[1] = (unsigned long)shadow_plb[index][1];
1002− shadow_map[2] = (unsigned long)ptr_val;
1003− dprintf3("%s(%d, %p, %p) set shadow map[2]: %p\n", __func__,
1004− index, ptr, ptr_val, ptr_val);
1005− /*ptr ignored */
1006−}
1007−
1008−void lddsc_shadow(int index, uint8_t *ptr, uint8_t *ptr_val)
1009−{
1010− uint64_t lower = shadow_map[0];
1011− uint64_t upper = shadow_map[1];
1012− uint8_t *value = (uint8_t *)shadow_map[2];
1013−
1014− if (value != ptr_val) {
1015− dprintf2("%s(%d, %p, %p) init shadow bounds[%d] "
1016− "because %p != %p\n", __func__, index, ptr,
1017− ptr_val, index, value, ptr_val);
1018− shadow_plb[index][0] = 0;
1019− shadow_plb[index][1] = ~(unsigned long)0;
1020− } else {
1021− shadow_plb[index][0] = lower;
1022− shadow_plb[index][1] = upper;
1023− }
1024− /* ptr ignored */
1025−}
1026−
1027−static __always_inline void mpx_test_helper0(uint8_t *buf, uint8_t *ptr)
1028−{
1029− mpx_make_bound_helper((unsigned long)ptr, 0x1800);
1030−}
1031−
1032−static __always_inline void mpx_test_helper0_shadow(uint8_t *buf, uint8_t *ptr)
1033−{
1034− mkbnd_shadow(ptr, 0, 0x1800);
1035−}
1036−
1037−static __always_inline void mpx_test_helper1(uint8_t *buf, uint8_t *ptr)
1038−{
1039− /* these are hard-coded to check bnd0 */
1040− expected_bnd_index = 0;
1041− mpx_check_lowerbound_helper((unsigned long)(ptr-1));
1042− mpx_check_upperbound_helper((unsigned long)(ptr+0x1800));
1043− /* reset this since we do not expect any more bounds exceptions */
1044− expected_bnd_index = -1;
1045−}
1046−
1047−static __always_inline void mpx_test_helper1_shadow(uint8_t *buf, uint8_t *ptr)
1048−{
1049− check_lowerbound_shadow(ptr-1, 0);
1050− check_upperbound_shadow(ptr+0x1800, 0);
1051−}
1052−
1053−static __always_inline void mpx_test_helper2(uint8_t *buf, uint8_t *ptr)
1054−{
1055− mpx_make_bound_helper((unsigned long)ptr, 0x1800);
1056− mpx_movbndreg_helper();
1057− mpx_movbnd2mem_helper(buf);
1058− mpx_make_bound_helper((unsigned long)(ptr+0x12), 0x1800);
1059−}
1060−
1061−static __always_inline void mpx_test_helper2_shadow(uint8_t *buf, uint8_t *ptr)
1062−{
1063− mkbnd_shadow(ptr, 0, 0x1800);
1064− movbndreg_shadow(0, 2);
1065− movbnd2mem_shadow(0, (unsigned long *)buf);
1066− mkbnd_shadow(ptr+0x12, 0, 0x1800);
1067−}
1068−
1069−static __always_inline void mpx_test_helper3(uint8_t *buf, uint8_t *ptr)
1070−{
1071− mpx_movbnd_from_mem_helper(buf);
1072−}
1073−
1074−static __always_inline void mpx_test_helper3_shadow(uint8_t *buf, uint8_t *ptr)
1075−{
1076− movbnd_from_mem_shadow((unsigned long *)buf, 0);
1077−}
1078−
1079−static __always_inline void mpx_test_helper4(uint8_t *buf, uint8_t *ptr)
1080−{
1081− mpx_store_dsc_helper((unsigned long)buf, (unsigned long)ptr);
1082− mpx_make_bound_helper((unsigned long)(ptr+0x12), 0x1800);
1083−}
1084−
1085−static __always_inline void mpx_test_helper4_shadow(uint8_t *buf, uint8_t *ptr)
1086−{
1087− stdsc_shadow(0, buf, ptr);
1088− mkbnd_shadow(ptr+0x12, 0, 0x1800);
1089−}
1090−
1091−static __always_inline void mpx_test_helper5(uint8_t *buf, uint8_t *ptr)
1092−{
1093− mpx_load_dsc_helper((unsigned long)buf, (unsigned long)ptr);
1094−}
1095−
1096−static __always_inline void mpx_test_helper5_shadow(uint8_t *buf, uint8_t *ptr)
1097−{
1098− lddsc_shadow(0, buf, ptr);
1099−}
1100−
1101−#define NR_MPX_TEST_FUNCTIONS 6
1102−
1103−/*
1104− * For compatibility reasons, MPX will clear the bounds registers
1105− * when you make function calls (among other things). We have to
1106− * preserve the registers in between calls to the "helpers" since
1107− * they build on each other.
1108− *
1109− * Be very careful not to make any function calls inside the
1110− * helpers, or anywhere else beween the xrstor and xsave.
1111− */
1112−#define run_helper(helper_nr, buf, buf_shadow, ptr) do { \
1113− xrstor_state(xsave_test_buf, flags); \
1114− mpx_test_helper##helper_nr(buf, ptr); \
1115− xsave_state(xsave_test_buf, flags); \
1116− mpx_test_helper##helper_nr##_shadow(buf_shadow, ptr); \
1117−} while (0)
1118−
1119−static void run_helpers(int nr, uint8_t *buf, uint8_t *buf_shadow, uint8_t *ptr)
1120−{
1121− uint64_t flags = 0x18;
1122−
1123− dprint_context(xsave_test_buf);
1124− switch (nr) {
1125− case 0:
1126− run_helper(0, buf, buf_shadow, ptr);
1127− break;
1128− case 1:
1129− run_helper(1, buf, buf_shadow, ptr);
1130− break;
1131− case 2:
1132− run_helper(2, buf, buf_shadow, ptr);
1133− break;
1134− case 3:
1135− run_helper(3, buf, buf_shadow, ptr);
1136− break;
1137− case 4:
1138− run_helper(4, buf, buf_shadow, ptr);
1139− break;
1140− case 5:
1141− run_helper(5, buf, buf_shadow, ptr);
1142− break;
1143− default:
1144− test_failed();
1145− break;
1146− }
1147− dprint_context(xsave_test_buf);
1148−}
1149−
1150−unsigned long buf_shadow[1024]; /* used to check load / store descriptors */
1151−extern long inspect_me(struct mpx_bounds_dir *bounds_dir);
1152−
1153−long cover_buf_with_bt_entries(void *buf, long buf_len)
1154−{
1155− int i;
1156− long nr_to_fill;
1157− int ratio = 1000;
1158− unsigned long buf_len_in_ptrs;
1159−
1160− /* Fill about 1/100 of the space with bt entries */
1161− nr_to_fill = buf_len / (sizeof(unsigned long) * ratio);
1162−
1163− if (!nr_to_fill)
1164− dprintf3("%s() nr_to_fill: %ld\n", __func__, nr_to_fill);
1165−
1166− /* Align the buffer to pointer size */
1167− while (((unsigned long)buf) % sizeof(void *)) {
1168− buf++;
1169− buf_len--;
1170− }
1171− /* We are storing pointers, so make */
1172− buf_len_in_ptrs = buf_len / sizeof(void *);
1173−
1174− for (i = 0; i < nr_to_fill; i++) {
1175− long index = (mpx_random() % buf_len_in_ptrs);
1176− void *ptr = buf + index * sizeof(unsigned long);
1177− unsigned long ptr_addr = (unsigned long)ptr;
1178−
1179− /* ptr and size can be anything */
1180− mpx_make_bound_helper((unsigned long)ptr, 8);
1181−
1182− /*
1183− * take bnd0 and put it in to bounds tables "buf + index" is an
1184− * address inside the buffer where we are pretending that we
1185− * are going to put a pointer We do not, though because we will
1186− * never load entries from the table, so it doesn't matter.
1187− */
1188− mpx_store_dsc_helper(ptr_addr, (unsigned long)ptr);
1189− dprintf4("storing bound table entry for %lx (buf start @ %p)\n",
1190− ptr_addr, buf);
1191− }
1192− return nr_to_fill;
1193−}
1194−
1195−unsigned long align_down(unsigned long alignme, unsigned long align_to)
1196−{
1197− return alignme & ~(align_to-1);
1198−}
1199−
1200−unsigned long align_up(unsigned long alignme, unsigned long align_to)
1201−{
1202− return (alignme + align_to - 1) & ~(align_to-1);
1203−}
1204−
1205−/*
1206− * Using 1MB alignment guarantees that each no allocation
1207− * will overlap with another's bounds tables.
1208− *
1209− * We have to cook our own allocator here. malloc() can
1210− * mix other allocation with ours which means that even
1211− * if we free all of our allocations, there might still
1212− * be bounds tables for the *areas* since there is other
1213− * valid memory there.
1214− *
1215− * We also can't use malloc() because a free() of an area
1216− * might not free it back to the kernel. We want it
1217− * completely unmapped an malloc() does not guarantee
1218− * that.
1219− */
1220−#ifdef __i386__
1221−long alignment = 4096;
1222−long sz_alignment = 4096;
1223−#else
1224−long alignment = 1 * MB;
1225−long sz_alignment = 1 * MB;
1226−#endif
1227−void *mpx_mini_alloc(unsigned long sz)
1228−{
1229− unsigned long long tries = 0;
1230− static void *last;
1231− void *ptr;
1232− void *try_at;
1233−
1234− sz = align_up(sz, sz_alignment);
1235−
1236− try_at = last + alignment;
1237− while (1) {
1238− ptr = mmap(try_at, sz, PROT_READ|PROT_WRITE,
1239− MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
1240− if (ptr == (void *)-1)
1241− return NULL;
1242− if (ptr == try_at)
1243− break;
1244−
1245− munmap(ptr, sz);
1246− try_at += alignment;
1247−#ifdef __i386__
1248− /*
1249− * This isn't quite correct for 32-bit binaries
1250− * on 64-bit kernels since they can use the
1251− * entire 32-bit address space, but it's close
1252− * enough.
1253− */
1254− if (try_at > (void *)0xC0000000)
1255−#else
1256− if (try_at > (void *)0x0000800000000000)
1257−#endif
1258− try_at = (void *)0x0;
1259− if (!(++tries % 10000))
1260− dprintf1("stuck in %s(), tries: %lld\n", __func__, tries);
1261− continue;
1262− }
1263− last = ptr;
1264− dprintf3("mpx_mini_alloc(0x%lx) returning: %p\n", sz, ptr);
1265− return ptr;
1266−}
1267−void mpx_mini_free(void *ptr, long sz)
1268−{
1269− dprintf2("%s() ptr: %p\n", __func__, ptr);
1270− if ((unsigned long)ptr > 0x100000000000) {
1271− dprintf1("uh oh !!!!!!!!!!!!!!! pointer too high: %p\n", ptr);
1272− test_failed();
1273− }
1274− sz = align_up(sz, sz_alignment);
1275− dprintf3("%s() ptr: %p before munmap\n", __func__, ptr);
1276− munmap(ptr, sz);
1277− dprintf3("%s() ptr: %p DONE\n", __func__, ptr);
1278−}
1279−
1280−#define NR_MALLOCS 100
1281−struct one_malloc {
1282− char *ptr;
1283− int nr_filled_btes;
1284− unsigned long size;
1285−};
1286−struct one_malloc mallocs[NR_MALLOCS];
1287−
1288−void free_one_malloc(int index)
1289−{
1290− unsigned long free_ptr;
1291− unsigned long mask;
1292−
1293− if (!mallocs[index].ptr)
1294− return;
1295−
1296− mpx_mini_free(mallocs[index].ptr, mallocs[index].size);
1297− dprintf4("freed[%d]: %p\n", index, mallocs[index].ptr);
1298−
1299− free_ptr = (unsigned long)mallocs[index].ptr;
1300− mask = alignment-1;
1301− dprintf4("lowerbits: %lx / %lx mask: %lx\n", free_ptr,
1302− (free_ptr & mask), mask);
1303− assert((free_ptr & mask) == 0);
1304−
1305− mallocs[index].ptr = NULL;
1306−}
1307−
1308−#ifdef __i386__
1309−#define MPX_BOUNDS_TABLE_COVERS 4096
1310−#else
1311−#define MPX_BOUNDS_TABLE_COVERS (1 * MB)
1312−#endif
1313−void zap_everything(void)
1314−{
1315− long after_zap;
1316− long before_zap;
1317− int i;
1318−
1319− before_zap = inspect_me(bounds_dir_ptr);
1320− dprintf1("zapping everything start: %ld\n", before_zap);
1321− for (i = 0; i < NR_MALLOCS; i++)
1322− free_one_malloc(i);
1323−
1324− after_zap = inspect_me(bounds_dir_ptr);
1325− dprintf1("zapping everything done: %ld\n", after_zap);
1326− /*
1327− * We only guarantee to empty the thing out if our allocations are
1328− * exactly aligned on the boundaries of a boudns table.
1329− */
1330− if ((alignment >= MPX_BOUNDS_TABLE_COVERS) &&
1331− (sz_alignment >= MPX_BOUNDS_TABLE_COVERS)) {
1332− if (after_zap != 0)
1333− test_failed();
1334−
1335− assert(after_zap == 0);
1336− }
1337−}
1338−
1339−void do_one_malloc(void)
1340−{
1341− static int malloc_counter;
1342− long sz;
1343− int rand_index = (mpx_random() % NR_MALLOCS);
1344− void *ptr = mallocs[rand_index].ptr;
1345−
1346− dprintf3("%s() enter\n", __func__);
1347−
1348− if (ptr) {
1349− dprintf3("freeing one malloc at index: %d\n", rand_index);
1350− free_one_malloc(rand_index);
1351− if (mpx_random() % (NR_MALLOCS*3) == 3) {
1352− int i;
1353− dprintf3("zapping some more\n");
1354− for (i = rand_index; i < NR_MALLOCS; i++)
1355− free_one_malloc(i);
1356− }
1357− if ((mpx_random() % zap_all_every_this_many_mallocs) == 4)
1358− zap_everything();
1359− }
1360−
1361− /* 1->~1M */
1362− sz = (1 + mpx_random() % 1000) * 1000;
1363− ptr = mpx_mini_alloc(sz);
1364− if (!ptr) {
1365− /*
1366− * If we are failing allocations, just assume we
1367− * are out of memory and zap everything.
1368− */
1369− dprintf3("zapping everything because out of memory\n");
1370− zap_everything();
1371− goto out;
1372− }
1373−
1374− dprintf3("malloc: %p size: 0x%lx\n", ptr, sz);
1375− mallocs[rand_index].nr_filled_btes = cover_buf_with_bt_entries(ptr, sz);
1376− mallocs[rand_index].ptr = ptr;
1377− mallocs[rand_index].size = sz;
1378−out:
1379− if ((++malloc_counter) % inspect_every_this_many_mallocs == 0)
1380− inspect_me(bounds_dir_ptr);
1381−}
1382−
1383−void run_timed_test(void (*test_func)(void))
1384−{
1385− int done = 0;
1386− long iteration = 0;
1387− static time_t last_print;
1388− time_t now;
1389− time_t start;
1390−
1391− time(&start);
1392− while (!done) {
1393− time(&now);
1394− if ((now - start) > TEST_DURATION_SECS)
1395− done = 1;
1396−
1397− test_func();
1398− iteration++;
1399−
1400− if ((now - last_print > 1) || done) {
1401− printf("iteration %ld complete, OK so far\n", iteration);
1402− last_print = now;
1403− }
1404− }
1405−}
1406−
1407−void check_bounds_table_frees(void)
1408−{
1409− printf("executing unmaptest\n");
1410− inspect_me(bounds_dir_ptr);
1411− run_timed_test(&do_one_malloc);
1412− printf("done with malloc() fun\n");
1413−}
1414−
1415−void insn_test_failed(int test_nr, int test_round, void *buf,
1416− void *buf_shadow, void *ptr)
1417−{
1418− print_context(xsave_test_buf);
1419− eprintf("ERROR: test %d round %d failed\n", test_nr, test_round);
1420− while (test_nr == 5) {
1421− struct mpx_bt_entry *bte;
1422− struct mpx_bounds_dir *bd = (void *)bounds_dir_ptr;
1423− struct mpx_bd_entry *bde = mpx_vaddr_to_bd_entry(buf, bd);
1424−
1425− printf(" bd: %p\n", bd);
1426− printf("&bde: %p\n", bde);
1427− printf("*bde: %lx\n", *(unsigned long *)bde);
1428− if (!bd_entry_valid(bde))
1429− break;
1430−
1431− bte = mpx_vaddr_to_bt_entry(buf, bd);
1432− printf(" te: %p\n", bte);
1433− printf("bte[0]: %lx\n", bte->contents[0]);
1434− printf("bte[1]: %lx\n", bte->contents[1]);
1435− printf("bte[2]: %lx\n", bte->contents[2]);
1436− printf("bte[3]: %lx\n", bte->contents[3]);
1437− break;
1438− }
1439− test_failed();
1440−}
1441−
1442−void check_mpx_insns_and_tables(void)
1443−{
1444− int successes = 0;
1445− int failures = 0;
1446− int buf_size = (1024*1024);
1447− unsigned long *buf = malloc(buf_size);
1448− const int total_nr_tests = NR_MPX_TEST_FUNCTIONS * TEST_ROUNDS;
1449− int i, j;
1450−
1451− memset(buf, 0, buf_size);
1452− memset(buf_shadow, 0, sizeof(buf_shadow));
1453−
1454− for (i = 0; i < TEST_ROUNDS; i++) {
1455− uint8_t *ptr = get_random_addr() + 8;
1456−
1457− for (j = 0; j < NR_MPX_TEST_FUNCTIONS; j++) {
1458− if (0 && j != 5) {
1459− successes++;
1460− continue;
1461− }
1462− dprintf2("starting test %d round %d\n", j, i);
1463− dprint_context(xsave_test_buf);
1464− /*
1465− * test5 loads an address from the bounds tables.
1466− * The load will only complete if 'ptr' matches
1467− * the load and the store, so with random addrs,
1468− * the odds of this are very small. Make it
1469− * higher by only moving 'ptr' 1/10 times.
1470− */
1471− if (random() % 10 <= 0)
1472− ptr = get_random_addr() + 8;
1473− dprintf3("random ptr{%p}\n", ptr);
1474− dprint_context(xsave_test_buf);
1475− run_helpers(j, (void *)buf, (void *)buf_shadow, ptr);
1476− dprint_context(xsave_test_buf);
1477− if (!compare_context(xsave_test_buf)) {
1478− insn_test_failed(j, i, buf, buf_shadow, ptr);
1479− failures++;
1480− goto exit;
1481− }
1482− successes++;
1483− dprint_context(xsave_test_buf);
1484− dprintf2("finished test %d round %d\n", j, i);
1485− dprintf3("\n");
1486− dprint_context(xsave_test_buf);
1487− }
1488− }
1489−
1490−exit:
1491− dprintf2("\nabout to free:\n");
1492− free(buf);
1493− dprintf1("successes: %d\n", successes);
1494− dprintf1(" failures: %d\n", failures);
1495− dprintf1(" tests: %d\n", total_nr_tests);
1496− dprintf1(" expected: %jd #BRs\n", num_upper_brs + num_lower_brs);
1497− dprintf1(" saw: %d #BRs\n", br_count);
1498− if (failures) {
1499− eprintf("ERROR: non-zero number of failures\n");
1500− exit(20);
1501− }
1502− if (successes != total_nr_tests) {
1503− eprintf("ERROR: succeeded fewer than number of tries (%d != %d)\n",
1504− successes, total_nr_tests);
1505− exit(21);
1506− }
1507− if (num_upper_brs + num_lower_brs != br_count) {
1508− eprintf("ERROR: unexpected number of #BRs: %jd %jd %d\n",
1509− num_upper_brs, num_lower_brs, br_count);
1510− eprintf("successes: %d\n", successes);
1511− eprintf(" failures: %d\n", failures);
1512− eprintf(" tests: %d\n", total_nr_tests);
1513− eprintf(" expected: %jd #BRs\n", num_upper_brs + num_lower_brs);
1514− eprintf(" saw: %d #BRs\n", br_count);
1515− exit(22);
1516− }
1517−}
1518−
1519−/*
1520− * This is supposed to SIGSEGV nicely once the kernel
1521− * can no longer allocate vaddr space.
1522− */
1523−void exhaust_vaddr_space(void)
1524−{
1525− unsigned long ptr;
1526− /* Try to make sure there is no room for a bounds table anywhere */
1527− unsigned long skip = MPX_BOUNDS_TABLE_SIZE_BYTES - PAGE_SIZE;
1528−#ifdef __i386__
1529− unsigned long max_vaddr = 0xf7788000UL;
1530−#else
1531− unsigned long max_vaddr = 0x800000000000UL;
1532−#endif
1533−
1534− dprintf1("%s() start\n", __func__);
1535− /* do not start at 0, we aren't allowed to map there */
1536− for (ptr = PAGE_SIZE; ptr < max_vaddr; ptr += skip) {
1537− void *ptr_ret;
1538− int ret = madvise((void *)ptr, PAGE_SIZE, MADV_NORMAL);
1539−
1540− if (!ret) {
1541− dprintf1("madvise() %lx ret: %d\n", ptr, ret);
1542− continue;
1543− }
1544− ptr_ret = mmap((void *)ptr, PAGE_SIZE, PROT_READ|PROT_WRITE,
1545− MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
1546− if (ptr_ret != (void *)ptr) {
1547− perror("mmap");
1548− dprintf1("mmap(%lx) ret: %p\n", ptr, ptr_ret);
1549− break;
1550− }
1551− if (!(ptr & 0xffffff))
1552− dprintf1("mmap(%lx) ret: %p\n", ptr, ptr_ret);
1553− }
1554− for (ptr = PAGE_SIZE; ptr < max_vaddr; ptr += skip) {
1555− dprintf2("covering 0x%lx with bounds table entries\n", ptr);
1556− cover_buf_with_bt_entries((void *)ptr, PAGE_SIZE);
1557− }
1558− dprintf1("%s() end\n", __func__);
1559− printf("done with vaddr space fun\n");
1560−}
1561−
1562−void mpx_table_test(void)
1563−{
1564− printf("starting mpx bounds table test\n");
1565− run_timed_test(check_mpx_insns_and_tables);
1566− printf("done with mpx bounds table test\n");
1567−}
1568−
1569−int main(int argc, char **argv)
1570−{
1571− int unmaptest = 0;
1572− int vaddrexhaust = 0;
1573− int tabletest = 0;
1574− int i;
1575−
1576− check_mpx_support();
1577− mpx_prepare();
1578− srandom(11179);
1579−
1580− bd_incore();
1581− init();
1582− bd_incore();
1583−
1584− trace_me();
1585−
1586− xsave_state((void *)xsave_test_buf, 0x1f);
1587− if (!compare_context(xsave_test_buf))
1588− printf("Init failed\n");
1589−
1590− for (i = 1; i < argc; i++) {
1591− if (!strcmp(argv[i], "unmaptest"))
1592− unmaptest = 1;
1593− if (!strcmp(argv[i], "vaddrexhaust"))
1594− vaddrexhaust = 1;
1595− if (!strcmp(argv[i], "tabletest"))
1596− tabletest = 1;
1597− }
1598− if (!(unmaptest || vaddrexhaust || tabletest)) {
1599− unmaptest = 1;
1600− /* vaddrexhaust = 1; */
1601− tabletest = 1;
1602− }
1603− if (unmaptest)
1604− check_bounds_table_frees();
1605− if (tabletest)
1606− mpx_table_test();
1607− if (vaddrexhaust)
1608− exhaust_vaddr_space();
1609− printf("%s completed successfully\n", argv[0]);
1610− exit(0);
1611−}
1612−
1613−#include "mpx-dig.c"
tools/testing/selftests/x86/mpx-mm.h+0−10
@@ -1,10 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0 */
2−#ifndef _MPX_MM_H
3−#define _MPX_MM_H
4−
5−#define PAGE_SIZE 4096
6−#define MB (1UL<<20)
7−
8−extern long nr_incore(void *ptr, unsigned long size_bytes);
9−
10−#endif /* _MPX_MM_H */