1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ldt_gdt.c - Test cases for LDT and GDT access
4  * Copyright (c) 2015 Andrew Lutomirski
5  */
6 
7 #define _GNU_SOURCE
8 #include <err.h>
9 #include <stdio.h>
10 #include <stdint.h>
11 #include <signal.h>
12 #include <setjmp.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <errno.h>
16 #include <unistd.h>
17 #include <sys/syscall.h>
18 #include <asm/ldt.h>
19 #include <sys/types.h>
20 #include <sys/wait.h>
21 #include <stdbool.h>
22 #include <pthread.h>
23 #include <sched.h>
24 #include <linux/futex.h>
25 #include <sys/mman.h>
26 #include <asm/prctl.h>
27 #include <sys/prctl.h>
28 
29 #define AR_ACCESSED		(1<<8)
30 
31 #define AR_TYPE_RODATA		(0 * (1<<9))
32 #define AR_TYPE_RWDATA		(1 * (1<<9))
33 #define AR_TYPE_RODATA_EXPDOWN	(2 * (1<<9))
34 #define AR_TYPE_RWDATA_EXPDOWN	(3 * (1<<9))
35 #define AR_TYPE_XOCODE		(4 * (1<<9))
36 #define AR_TYPE_XRCODE		(5 * (1<<9))
37 #define AR_TYPE_XOCODE_CONF	(6 * (1<<9))
38 #define AR_TYPE_XRCODE_CONF	(7 * (1<<9))
39 
40 #define AR_DPL3			(3 * (1<<13))
41 
42 #define AR_S			(1 << 12)
43 #define AR_P			(1 << 15)
44 #define AR_AVL			(1 << 20)
45 #define AR_L			(1 << 21)
46 #define AR_DB			(1 << 22)
47 #define AR_G			(1 << 23)
48 
49 #ifdef __x86_64__
50 # define INT80_CLOBBERS "r8", "r9", "r10", "r11"
51 #else
52 # define INT80_CLOBBERS
53 #endif
54 
55 static int nerrs;
56 
57 /* Points to an array of 1024 ints, each holding its own index. */
58 static const unsigned int *counter_page;
59 static struct user_desc *low_user_desc;
60 static struct user_desc *low_user_desc_clear;  /* Use to delete GDT entry */
61 static int gdt_entry_num;
62 
63 static void check_invalid_segment(uint16_t index, int ldt)
64 {
65 	uint32_t has_limit = 0, has_ar = 0, limit, ar;
66 	uint32_t selector = (index << 3) | (ldt << 2) | 3;
67 
68 	asm ("lsl %[selector], %[limit]\n\t"
69 	     "jnz 1f\n\t"
70 	     "movl $1, %[has_limit]\n\t"
71 	     "1:"
72 	     : [limit] "=r" (limit), [has_limit] "+rm" (has_limit)
73 	     : [selector] "r" (selector));
74 	asm ("larl %[selector], %[ar]\n\t"
75 	     "jnz 1f\n\t"
76 	     "movl $1, %[has_ar]\n\t"
77 	     "1:"
78 	     : [ar] "=r" (ar), [has_ar] "+rm" (has_ar)
79 	     : [selector] "r" (selector));
80 
81 	if (has_limit || has_ar) {
82 		printf("[FAIL]\t%s entry %hu is valid but should be invalid\n",
83 		       (ldt ? "LDT" : "GDT"), index);
84 		nerrs++;
85 	} else {
86 		printf("[OK]\t%s entry %hu is invalid\n",
87 		       (ldt ? "LDT" : "GDT"), index);
88 	}
89 }
90 
91 static void check_valid_segment(uint16_t index, int ldt,
92 				uint32_t expected_ar, uint32_t expected_limit,
93 				bool verbose)
94 {
95 	uint32_t has_limit = 0, has_ar = 0, limit, ar;
96 	uint32_t selector = (index << 3) | (ldt << 2) | 3;
97 
98 	asm ("lsl %[selector], %[limit]\n\t"
99 	     "jnz 1f\n\t"
100 	     "movl $1, %[has_limit]\n\t"
101 	     "1:"
102 	     : [limit] "=r" (limit), [has_limit] "+rm" (has_limit)
103 	     : [selector] "r" (selector));
104 	asm ("larl %[selector], %[ar]\n\t"
105 	     "jnz 1f\n\t"
106 	     "movl $1, %[has_ar]\n\t"
107 	     "1:"
108 	     : [ar] "=r" (ar), [has_ar] "+rm" (has_ar)
109 	     : [selector] "r" (selector));
110 
111 	if (!has_limit || !has_ar) {
112 		printf("[FAIL]\t%s entry %hu is invalid but should be valid\n",
113 		       (ldt ? "LDT" : "GDT"), index);
114 		nerrs++;
115 		return;
116 	}
117 
118 	/* The SDM says "bits 19:16 are undefined".  Thanks. */
119 	ar &= ~0xF0000;
120 
121 	/*
122 	 * NB: Different Linux versions do different things with the
123 	 * accessed bit in set_thread_area().
124 	 */
125 	if (ar != expected_ar && ar != (expected_ar | AR_ACCESSED)) {
126 		printf("[FAIL]\t%s entry %hu has AR 0x%08X but expected 0x%08X\n",
127 		       (ldt ? "LDT" : "GDT"), index, ar, expected_ar);
128 		nerrs++;
129 	} else if (limit != expected_limit) {
130 		printf("[FAIL]\t%s entry %hu has limit 0x%08X but expected 0x%08X\n",
131 		       (ldt ? "LDT" : "GDT"), index, limit, expected_limit);
132 		nerrs++;
133 	} else if (verbose) {
134 		printf("[OK]\t%s entry %hu has AR 0x%08X and limit 0x%08X\n",
135 		       (ldt ? "LDT" : "GDT"), index, ar, limit);
136 	}
137 }
138 
139 static bool install_valid_mode(const struct user_desc *d, uint32_t ar,
140 			       bool oldmode, bool ldt)
141 {
142 	struct user_desc desc = *d;
143 	int ret;
144 
145 	if (!ldt) {
146 #ifndef __i386__
147 		/* No point testing set_thread_area in a 64-bit build */
148 		return false;
149 #endif
150 		if (!gdt_entry_num)
151 			return false;
152 		desc.entry_number = gdt_entry_num;
153 
154 		ret = syscall(SYS_set_thread_area, &desc);
155 	} else {
156 		ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
157 			      &desc, sizeof(desc));
158 
159 		if (ret < -1)
160 			errno = -ret;
161 
162 		if (ret != 0 && errno == ENOSYS) {
163 			printf("[OK]\tmodify_ldt returned -ENOSYS\n");
164 			return false;
165 		}
166 	}
167 
168 	if (ret == 0) {
169 		uint32_t limit = desc.limit;
170 		if (desc.limit_in_pages)
171 			limit = (limit << 12) + 4095;
172 		check_valid_segment(desc.entry_number, ldt, ar, limit, true);
173 		return true;
174 	} else {
175 		if (desc.seg_32bit) {
176 			printf("[FAIL]\tUnexpected %s failure %d\n",
177 			       ldt ? "modify_ldt" : "set_thread_area",
178 			       errno);
179 			nerrs++;
180 			return false;
181 		} else {
182 			printf("[OK]\t%s rejected 16 bit segment\n",
183 			       ldt ? "modify_ldt" : "set_thread_area");
184 			return false;
185 		}
186 	}
187 }
188 
189 static bool install_valid(const struct user_desc *desc, uint32_t ar)
190 {
191 	bool ret = install_valid_mode(desc, ar, false, true);
192 
193 	if (desc->contents <= 1 && desc->seg_32bit &&
194 	    !desc->seg_not_present) {
195 		/* Should work in the GDT, too. */
196 		install_valid_mode(desc, ar, false, false);
197 	}
198 
199 	return ret;
200 }
201 
202 static void install_invalid(const struct user_desc *desc, bool oldmode)
203 {
204 	int ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
205 			  desc, sizeof(*desc));
206 	if (ret < -1)
207 		errno = -ret;
208 	if (ret == 0) {
209 		check_invalid_segment(desc->entry_number, 1);
210 	} else if (errno == ENOSYS) {
211 		printf("[OK]\tmodify_ldt returned -ENOSYS\n");
212 	} else {
213 		if (desc->seg_32bit) {
214 			printf("[FAIL]\tUnexpected modify_ldt failure %d\n",
215 			       errno);
216 			nerrs++;
217 		} else {
218 			printf("[OK]\tmodify_ldt rejected 16 bit segment\n");
219 		}
220 	}
221 }
222 
223 static int safe_modify_ldt(int func, struct user_desc *ptr,
224 			   unsigned long bytecount)
225 {
226 	int ret = syscall(SYS_modify_ldt, 0x11, ptr, bytecount);
227 	if (ret < -1)
228 		errno = -ret;
229 	return ret;
230 }
231 
232 static void fail_install(struct user_desc *desc)
233 {
234 	if (safe_modify_ldt(0x11, desc, sizeof(*desc)) == 0) {
235 		printf("[FAIL]\tmodify_ldt accepted a bad descriptor\n");
236 		nerrs++;
237 	} else if (errno == ENOSYS) {
238 		printf("[OK]\tmodify_ldt returned -ENOSYS\n");
239 	} else {
240 		printf("[OK]\tmodify_ldt failure %d\n", errno);
241 	}
242 }
243 
244 static void do_simple_tests(void)
245 {
246 	struct user_desc desc = {
247 		.entry_number    = 0,
248 		.base_addr       = 0,
249 		.limit           = 10,
250 		.seg_32bit       = 1,
251 		.contents        = 2, /* Code, not conforming */
252 		.read_exec_only  = 0,
253 		.limit_in_pages  = 0,
254 		.seg_not_present = 0,
255 		.useable         = 0
256 	};
257 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE | AR_S | AR_P | AR_DB);
258 
259 	desc.limit_in_pages = 1;
260 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
261 		      AR_S | AR_P | AR_DB | AR_G);
262 
263 	check_invalid_segment(1, 1);
264 
265 	desc.entry_number = 2;
266 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
267 		      AR_S | AR_P | AR_DB | AR_G);
268 
269 	check_invalid_segment(1, 1);
270 
271 	desc.base_addr = 0xf0000000;
272 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
273 		      AR_S | AR_P | AR_DB | AR_G);
274 
275 	desc.useable = 1;
276 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
277 		      AR_S | AR_P | AR_DB | AR_G | AR_AVL);
278 
279 	desc.seg_not_present = 1;
280 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
281 		      AR_S | AR_DB | AR_G | AR_AVL);
282 
283 	desc.seg_32bit = 0;
284 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
285 		      AR_S | AR_G | AR_AVL);
286 
287 	desc.seg_32bit = 1;
288 	desc.contents = 0;
289 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA |
290 		      AR_S | AR_DB | AR_G | AR_AVL);
291 
292 	desc.read_exec_only = 1;
293 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA |
294 		      AR_S | AR_DB | AR_G | AR_AVL);
295 
296 	desc.contents = 1;
297 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA_EXPDOWN |
298 		      AR_S | AR_DB | AR_G | AR_AVL);
299 
300 	desc.read_exec_only = 0;
301 	desc.limit_in_pages = 0;
302 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA_EXPDOWN |
303 		      AR_S | AR_DB | AR_AVL);
304 
305 	desc.contents = 3;
306 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE_CONF |
307 		      AR_S | AR_DB | AR_AVL);
308 
309 	desc.read_exec_only = 1;
310 	install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE_CONF |
311 		      AR_S | AR_DB | AR_AVL);
312 
313 	desc.read_exec_only = 0;
314 	desc.contents = 2;
315 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE |
316 		      AR_S | AR_DB | AR_AVL);
317 
318 	desc.read_exec_only = 1;
319 
320 #ifdef __x86_64__
321 	desc.lm = 1;
322 	install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE |
323 		      AR_S | AR_DB | AR_AVL);
324 	desc.lm = 0;
325 #endif
326 
327 	bool entry1_okay = install_valid(&desc, AR_DPL3 | AR_TYPE_XOCODE |
328 					 AR_S | AR_DB | AR_AVL);
329 
330 	if (entry1_okay) {
331 		printf("[RUN]\tTest fork\n");
332 		pid_t child = fork();
333 		if (child == 0) {
334 			nerrs = 0;
335 			check_valid_segment(desc.entry_number, 1,
336 					    AR_DPL3 | AR_TYPE_XOCODE |
337 					    AR_S | AR_DB | AR_AVL, desc.limit,
338 					    true);
339 			check_invalid_segment(1, 1);
340 			exit(nerrs ? 1 : 0);
341 		} else {
342 			int status;
343 			if (waitpid(child, &status, 0) != child ||
344 			    !WIFEXITED(status)) {
345 				printf("[FAIL]\tChild died\n");
346 				nerrs++;
347 			} else if (WEXITSTATUS(status) != 0) {
348 				printf("[FAIL]\tChild failed\n");
349 				nerrs++;
350 			} else {
351 				printf("[OK]\tChild succeeded\n");
352 			}
353 		}
354 
355 		printf("[RUN]\tTest size\n");
356 		int i;
357 		for (i = 0; i < 8192; i++) {
358 			desc.entry_number = i;
359 			desc.limit = i;
360 			if (safe_modify_ldt(0x11, &desc, sizeof(desc)) != 0) {
361 				printf("[FAIL]\tFailed to install entry %d\n", i);
362 				nerrs++;
363 				break;
364 			}
365 		}
366 		for (int j = 0; j < i; j++) {
367 			check_valid_segment(j, 1, AR_DPL3 | AR_TYPE_XOCODE |
368 					    AR_S | AR_DB | AR_AVL, j, false);
369 		}
370 		printf("[DONE]\tSize test\n");
371 	} else {
372 		printf("[SKIP]\tSkipping fork and size tests because we have no LDT\n");
373 	}
374 
375 	/* Test entry_number too high. */
376 	desc.entry_number = 8192;
377 	fail_install(&desc);
378 
379 	/* Test deletion and actions mistakeable for deletion. */
380 	memset(&desc, 0, sizeof(desc));
381 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P);
382 
383 	desc.seg_not_present = 1;
384 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S);
385 
386 	desc.seg_not_present = 0;
387 	desc.read_exec_only = 1;
388 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S | AR_P);
389 
390 	desc.read_exec_only = 0;
391 	desc.seg_not_present = 1;
392 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S);
393 
394 	desc.read_exec_only = 1;
395 	desc.limit = 1;
396 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S);
397 
398 	desc.limit = 0;
399 	desc.base_addr = 1;
400 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S);
401 
402 	desc.base_addr = 0;
403 	install_invalid(&desc, false);
404 
405 	desc.seg_not_present = 0;
406 	desc.seg_32bit = 1;
407 	desc.read_exec_only = 0;
408 	desc.limit = 0xfffff;
409 
410 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P | AR_DB);
411 
412 	desc.limit_in_pages = 1;
413 
414 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P | AR_DB | AR_G);
415 	desc.read_exec_only = 1;
416 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S | AR_P | AR_DB | AR_G);
417 	desc.contents = 1;
418 	desc.read_exec_only = 0;
419 	install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA_EXPDOWN | AR_S | AR_P | AR_DB | AR_G);
420 	desc.read_exec_only = 1;
421 	install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA_EXPDOWN | AR_S | AR_P | AR_DB | AR_G);
422 
423 	desc.limit = 0;
424 	install_invalid(&desc, true);
425 }
426 
427 /*
428  * 0: thread is idle
429  * 1: thread armed
430  * 2: thread should clear LDT entry 0
431  * 3: thread should exit
432  */
433 static volatile unsigned int ftx;
434 
435 static void *threadproc(void *ctx)
436 {
437 	cpu_set_t cpuset;
438 	CPU_ZERO(&cpuset);
439 	CPU_SET(1, &cpuset);
440 	if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0)
441 		err(1, "sched_setaffinity to CPU 1");	/* should never fail */
442 
443 	while (1) {
444 		syscall(SYS_futex, &ftx, FUTEX_WAIT, 0, NULL, NULL, 0);
445 		while (ftx != 2) {
446 			if (ftx >= 3)
447 				return NULL;
448 		}
449 
450 		/* clear LDT entry 0 */
451 		const struct user_desc desc = {};
452 		if (syscall(SYS_modify_ldt, 1, &desc, sizeof(desc)) != 0)
453 			err(1, "modify_ldt");
454 
455 		/* If ftx == 2, set it to zero.  If ftx == 100, quit. */
456 		unsigned int x = -2;
457 		asm volatile ("lock xaddl %[x], %[ftx]" :
458 			      [x] "+r" (x), [ftx] "+m" (ftx));
459 		if (x != 2)
460 			return NULL;
461 	}
462 }
463 
464 #ifdef __i386__
465 
466 #ifndef SA_RESTORE
467 #define SA_RESTORER 0x04000000
468 #endif
469 
470 /*
471  * The UAPI header calls this 'struct sigaction', which conflicts with
472  * glibc.  Sigh.
473  */
474 struct fake_ksigaction {
475 	void *handler;  /* the real type is nasty */
476 	unsigned long sa_flags;
477 	void (*sa_restorer)(void);
478 	unsigned char sigset[8];
479 };
480 
481 static void fix_sa_restorer(int sig)
482 {
483 	struct fake_ksigaction ksa;
484 
485 	if (syscall(SYS_rt_sigaction, sig, NULL, &ksa, 8) == 0) {
486 		/*
487 		 * glibc has a nasty bug: it sometimes writes garbage to
488 		 * sa_restorer.  This interacts quite badly with anything
489 		 * that fiddles with SS because it can trigger legacy
490 		 * stack switching.  Patch it up.  See:
491 		 *
492 		 * https://sourceware.org/bugzilla/show_bug.cgi?id=21269
493 		 */
494 		if (!(ksa.sa_flags & SA_RESTORER) && ksa.sa_restorer) {
495 			ksa.sa_restorer = NULL;
496 			if (syscall(SYS_rt_sigaction, sig, &ksa, NULL,
497 				    sizeof(ksa.sigset)) != 0)
498 				err(1, "rt_sigaction");
499 		}
500 	}
501 }
502 #else
503 static void fix_sa_restorer(int sig)
504 {
505 	/* 64-bit glibc works fine. */
506 }
507 #endif
508 
509 static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
510 		       int flags)
511 {
512 	struct sigaction sa;
513 	memset(&sa, 0, sizeof(sa));
514 	sa.sa_sigaction = handler;
515 	sa.sa_flags = SA_SIGINFO | flags;
516 	sigemptyset(&sa.sa_mask);
517 	if (sigaction(sig, &sa, 0))
518 		err(1, "sigaction");
519 
520 	fix_sa_restorer(sig);
521 }
522 
523 static jmp_buf jmpbuf;
524 
525 static void sigsegv(int sig, siginfo_t *info, void *ctx_void)
526 {
527 	siglongjmp(jmpbuf, 1);
528 }
529 
530 static void do_multicpu_tests(void)
531 {
532 	cpu_set_t cpuset;
533 	pthread_t thread;
534 	int failures = 0, iters = 5, i;
535 	unsigned short orig_ss;
536 
537 	CPU_ZERO(&cpuset);
538 	CPU_SET(1, &cpuset);
539 	if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) {
540 		printf("[SKIP]\tCannot set affinity to CPU 1\n");
541 		return;
542 	}
543 
544 	CPU_ZERO(&cpuset);
545 	CPU_SET(0, &cpuset);
546 	if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) {
547 		printf("[SKIP]\tCannot set affinity to CPU 0\n");
548 		return;
549 	}
550 
551 	sethandler(SIGSEGV, sigsegv, 0);
552 #ifdef __i386__
553 	/* True 32-bit kernels send SIGILL instead of SIGSEGV on IRET faults. */
554 	sethandler(SIGILL, sigsegv, 0);
555 #endif
556 
557 	printf("[RUN]\tCross-CPU LDT invalidation\n");
558 
559 	if (pthread_create(&thread, 0, threadproc, 0) != 0)
560 		err(1, "pthread_create");
561 
562 	asm volatile ("mov %%ss, %0" : "=rm" (orig_ss));
563 
564 	for (i = 0; i < 5; i++) {
565 		if (sigsetjmp(jmpbuf, 1) != 0)
566 			continue;
567 
568 		/* Make sure the thread is ready after the last test. */
569 		while (ftx != 0)
570 			;
571 
572 		struct user_desc desc = {
573 			.entry_number    = 0,
574 			.base_addr       = 0,
575 			.limit           = 0xfffff,
576 			.seg_32bit       = 1,
577 			.contents        = 0, /* Data */
578 			.read_exec_only  = 0,
579 			.limit_in_pages  = 1,
580 			.seg_not_present = 0,
581 			.useable         = 0
582 		};
583 
584 		if (safe_modify_ldt(0x11, &desc, sizeof(desc)) != 0) {
585 			if (errno != ENOSYS)
586 				err(1, "modify_ldt");
587 			printf("[SKIP]\tmodify_ldt unavailable\n");
588 			break;
589 		}
590 
591 		/* Arm the thread. */
592 		ftx = 1;
593 		syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
594 
595 		asm volatile ("mov %0, %%ss" : : "r" (0x7));
596 
597 		/* Go! */
598 		ftx = 2;
599 
600 		while (ftx != 0)
601 			;
602 
603 		/*
604 		 * On success, modify_ldt will segfault us synchronously,
605 		 * and we'll escape via siglongjmp.
606 		 */
607 
608 		failures++;
609 		asm volatile ("mov %0, %%ss" : : "rm" (orig_ss));
610 	}
611 
612 	ftx = 100;  /* Kill the thread. */
613 	syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
614 
615 	if (pthread_join(thread, NULL) != 0)
616 		err(1, "pthread_join");
617 
618 	if (failures) {
619 		printf("[FAIL]\t%d of %d iterations failed\n", failures, iters);
620 		nerrs++;
621 	} else {
622 		printf("[OK]\tAll %d iterations succeeded\n", iters);
623 	}
624 }
625 
626 static int finish_exec_test(void)
627 {
628 	/*
629 	 * Older kernel versions did inherit the LDT on exec() which is
630 	 * wrong because exec() starts from a clean state.
631 	 */
632 	check_invalid_segment(0, 1);
633 
634 	return nerrs ? 1 : 0;
635 }
636 
637 static void do_exec_test(void)
638 {
639 	printf("[RUN]\tTest exec\n");
640 
641 	struct user_desc desc = {
642 		.entry_number    = 0,
643 		.base_addr       = 0,
644 		.limit           = 42,
645 		.seg_32bit       = 1,
646 		.contents        = 2, /* Code, not conforming */
647 		.read_exec_only  = 0,
648 		.limit_in_pages  = 0,
649 		.seg_not_present = 0,
650 		.useable         = 0
651 	};
652 	install_valid(&desc, AR_DPL3 | AR_TYPE_XRCODE | AR_S | AR_P | AR_DB);
653 
654 	pid_t child = fork();
655 	if (child == 0) {
656 		execl("/proc/self/exe", "ldt_gdt_test_exec", NULL);
657 		printf("[FAIL]\tCould not exec self\n");
658 		exit(1);	/* exec failed */
659 	} else {
660 		int status;
661 		if (waitpid(child, &status, 0) != child ||
662 		    !WIFEXITED(status)) {
663 			printf("[FAIL]\tChild died\n");
664 			nerrs++;
665 		} else if (WEXITSTATUS(status) != 0) {
666 			printf("[FAIL]\tChild failed\n");
667 			nerrs++;
668 		} else {
669 			printf("[OK]\tChild succeeded\n");
670 		}
671 	}
672 }
673 
674 static void setup_counter_page(void)
675 {
676 	unsigned int *page = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
677 			 MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT, -1, 0);
678 	if (page == MAP_FAILED)
679 		err(1, "mmap");
680 
681 	for (int i = 0; i < 1024; i++)
682 		page[i] = i;
683 	counter_page = page;
684 }
685 
686 static int invoke_set_thread_area(void)
687 {
688 	int ret;
689 	asm volatile ("int $0x80"
690 		      : "=a" (ret), "+m" (low_user_desc) :
691 			"a" (243), "b" (low_user_desc)
692 		      : INT80_CLOBBERS);
693 	return ret;
694 }
695 
696 static void setup_low_user_desc(void)
697 {
698 	low_user_desc = mmap(NULL, 2 * sizeof(struct user_desc),
699 			     PROT_READ | PROT_WRITE,
700 			     MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT, -1, 0);
701 	if (low_user_desc == MAP_FAILED)
702 		err(1, "mmap");
703 
704 	low_user_desc->entry_number	= -1;
705 	low_user_desc->base_addr	= (unsigned long)&counter_page[1];
706 	low_user_desc->limit		= 0xfffff;
707 	low_user_desc->seg_32bit	= 1;
708 	low_user_desc->contents		= 0; /* Data, grow-up*/
709 	low_user_desc->read_exec_only	= 0;
710 	low_user_desc->limit_in_pages	= 1;
711 	low_user_desc->seg_not_present	= 0;
712 	low_user_desc->useable		= 0;
713 
714 	if (invoke_set_thread_area() == 0) {
715 		gdt_entry_num = low_user_desc->entry_number;
716 		printf("[NOTE]\tset_thread_area is available; will use GDT index %d\n", gdt_entry_num);
717 	} else {
718 		printf("[NOTE]\tset_thread_area is unavailable\n");
719 	}
720 
721 	low_user_desc_clear = low_user_desc + 1;
722 	low_user_desc_clear->entry_number = gdt_entry_num;
723 	low_user_desc_clear->read_exec_only = 1;
724 	low_user_desc_clear->seg_not_present = 1;
725 }
726 
727 static void test_gdt_invalidation(void)
728 {
729 	if (!gdt_entry_num)
730 		return;	/* 64-bit only system -- we can't use set_thread_area */
731 
732 	unsigned short prev_sel;
733 	unsigned short sel;
734 	unsigned int eax;
735 	const char *result;
736 #ifdef __x86_64__
737 	unsigned long saved_base;
738 	unsigned long new_base;
739 #endif
740 
741 	/* Test DS */
742 	invoke_set_thread_area();
743 	eax = 243;
744 	sel = (gdt_entry_num << 3) | 3;
745 	asm volatile ("movw %%ds, %[prev_sel]\n\t"
746 		      "movw %[sel], %%ds\n\t"
747 #ifdef __i386__
748 		      "pushl %%ebx\n\t"
749 #endif
750 		      "movl %[arg1], %%ebx\n\t"
751 		      "int $0x80\n\t"	/* Should invalidate ds */
752 #ifdef __i386__
753 		      "popl %%ebx\n\t"
754 #endif
755 		      "movw %%ds, %[sel]\n\t"
756 		      "movw %[prev_sel], %%ds"
757 		      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
758 			"+a" (eax)
759 		      : "m" (low_user_desc_clear),
760 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
761 		      : INT80_CLOBBERS);
762 
763 	if (sel != 0) {
764 		result = "FAIL";
765 		nerrs++;
766 	} else {
767 		result = "OK";
768 	}
769 	printf("[%s]\tInvalidate DS with set_thread_area: new DS = 0x%hx\n",
770 	       result, sel);
771 
772 	/* Test ES */
773 	invoke_set_thread_area();
774 	eax = 243;
775 	sel = (gdt_entry_num << 3) | 3;
776 	asm volatile ("movw %%es, %[prev_sel]\n\t"
777 		      "movw %[sel], %%es\n\t"
778 #ifdef __i386__
779 		      "pushl %%ebx\n\t"
780 #endif
781 		      "movl %[arg1], %%ebx\n\t"
782 		      "int $0x80\n\t"	/* Should invalidate es */
783 #ifdef __i386__
784 		      "popl %%ebx\n\t"
785 #endif
786 		      "movw %%es, %[sel]\n\t"
787 		      "movw %[prev_sel], %%es"
788 		      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
789 			"+a" (eax)
790 		      : "m" (low_user_desc_clear),
791 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
792 		      : INT80_CLOBBERS);
793 
794 	if (sel != 0) {
795 		result = "FAIL";
796 		nerrs++;
797 	} else {
798 		result = "OK";
799 	}
800 	printf("[%s]\tInvalidate ES with set_thread_area: new ES = 0x%hx\n",
801 	       result, sel);
802 
803 	/* Test FS */
804 	invoke_set_thread_area();
805 	eax = 243;
806 	sel = (gdt_entry_num << 3) | 3;
807 #ifdef __x86_64__
808 	syscall(SYS_arch_prctl, ARCH_GET_FS, &saved_base);
809 #endif
810 	asm volatile ("movw %%fs, %[prev_sel]\n\t"
811 		      "movw %[sel], %%fs\n\t"
812 #ifdef __i386__
813 		      "pushl %%ebx\n\t"
814 #endif
815 		      "movl %[arg1], %%ebx\n\t"
816 		      "int $0x80\n\t"	/* Should invalidate fs */
817 #ifdef __i386__
818 		      "popl %%ebx\n\t"
819 #endif
820 		      "movw %%fs, %[sel]\n\t"
821 		      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
822 			"+a" (eax)
823 		      : "m" (low_user_desc_clear),
824 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
825 		      : INT80_CLOBBERS);
826 
827 #ifdef __x86_64__
828 	syscall(SYS_arch_prctl, ARCH_GET_FS, &new_base);
829 #endif
830 
831 	/* Restore FS/BASE for glibc */
832 	asm volatile ("movw %[prev_sel], %%fs" : : [prev_sel] "rm" (prev_sel));
833 #ifdef __x86_64__
834 	if (saved_base)
835 		syscall(SYS_arch_prctl, ARCH_SET_FS, saved_base);
836 #endif
837 
838 	if (sel != 0) {
839 		result = "FAIL";
840 		nerrs++;
841 	} else {
842 		result = "OK";
843 	}
844 	printf("[%s]\tInvalidate FS with set_thread_area: new FS = 0x%hx\n",
845 	       result, sel);
846 
847 #ifdef __x86_64__
848 	if (sel == 0 && new_base != 0) {
849 		nerrs++;
850 		printf("[FAIL]\tNew FSBASE was 0x%lx\n", new_base);
851 	} else {
852 		printf("[OK]\tNew FSBASE was zero\n");
853 	}
854 #endif
855 
856 	/* Test GS */
857 	invoke_set_thread_area();
858 	eax = 243;
859 	sel = (gdt_entry_num << 3) | 3;
860 #ifdef __x86_64__
861 	syscall(SYS_arch_prctl, ARCH_GET_GS, &saved_base);
862 #endif
863 	asm volatile ("movw %%gs, %[prev_sel]\n\t"
864 		      "movw %[sel], %%gs\n\t"
865 #ifdef __i386__
866 		      "pushl %%ebx\n\t"
867 #endif
868 		      "movl %[arg1], %%ebx\n\t"
869 		      "int $0x80\n\t"	/* Should invalidate gs */
870 #ifdef __i386__
871 		      "popl %%ebx\n\t"
872 #endif
873 		      "movw %%gs, %[sel]\n\t"
874 		      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
875 			"+a" (eax)
876 		      : "m" (low_user_desc_clear),
877 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
878 		      : INT80_CLOBBERS);
879 
880 #ifdef __x86_64__
881 	syscall(SYS_arch_prctl, ARCH_GET_GS, &new_base);
882 #endif
883 
884 	/* Restore GS/BASE for glibc */
885 	asm volatile ("movw %[prev_sel], %%gs" : : [prev_sel] "rm" (prev_sel));
886 #ifdef __x86_64__
887 	if (saved_base)
888 		syscall(SYS_arch_prctl, ARCH_SET_GS, saved_base);
889 #endif
890 
891 	if (sel != 0) {
892 		result = "FAIL";
893 		nerrs++;
894 	} else {
895 		result = "OK";
896 	}
897 	printf("[%s]\tInvalidate GS with set_thread_area: new GS = 0x%hx\n",
898 	       result, sel);
899 
900 #ifdef __x86_64__
901 	if (sel == 0 && new_base != 0) {
902 		nerrs++;
903 		printf("[FAIL]\tNew GSBASE was 0x%lx\n", new_base);
904 	} else {
905 		printf("[OK]\tNew GSBASE was zero\n");
906 	}
907 #endif
908 }
909 
910 int main(int argc, char **argv)
911 {
912 	if (argc == 1 && !strcmp(argv[0], "ldt_gdt_test_exec"))
913 		return finish_exec_test();
914 
915 	setup_counter_page();
916 	setup_low_user_desc();
917 
918 	do_simple_tests();
919 
920 	do_multicpu_tests();
921 
922 	do_exec_test();
923 
924 	test_gdt_invalidation();
925 
926 	return nerrs ? 1 : 0;
927 }
928