1 // SPDX-License-Identifier: GPL-2.0
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <signal.h>
5 #include <sys/mman.h>
6 #include <longjmp.h>
7 
8 #ifdef __i386__
9 
10 static jmp_buf buf;
11 
segfault(int sig)12 static void segfault(int sig)
13 {
14 	longjmp(buf, 1);
15 }
16 
page_ok(unsigned long page)17 static int page_ok(unsigned long page)
18 {
19 	unsigned long *address = (unsigned long *) (page << UM_KERN_PAGE_SHIFT);
20 	unsigned long n = ~0UL;
21 	void *mapped = NULL;
22 	int ok = 0;
23 
24 	/*
25 	 * First see if the page is readable.  If it is, it may still
26 	 * be a VDSO, so we go on to see if it's writable.  If not
27 	 * then try mapping memory there.  If that fails, then we're
28 	 * still in the kernel area.  As a sanity check, we'll fail if
29 	 * the mmap succeeds, but gives us an address different from
30 	 * what we wanted.
31 	 */
32 	if (setjmp(buf) == 0)
33 		n = *address;
34 	else {
35 		mapped = mmap(address, UM_KERN_PAGE_SIZE,
36 			      PROT_READ | PROT_WRITE,
37 			      MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
38 		if (mapped == MAP_FAILED)
39 			return 0;
40 		if (mapped != address)
41 			goto out;
42 	}
43 
44 	/*
45 	 * Now, is it writeable?  If so, then we're in user address
46 	 * space.  If not, then try mprotecting it and try the write
47 	 * again.
48 	 */
49 	if (setjmp(buf) == 0) {
50 		*address = n;
51 		ok = 1;
52 		goto out;
53 	} else if (mprotect(address, UM_KERN_PAGE_SIZE,
54 			    PROT_READ | PROT_WRITE) != 0)
55 		goto out;
56 
57 	if (setjmp(buf) == 0) {
58 		*address = n;
59 		ok = 1;
60 	}
61 
62  out:
63 	if (mapped != NULL)
64 		munmap(mapped, UM_KERN_PAGE_SIZE);
65 	return ok;
66 }
67 
os_get_top_address(void)68 unsigned long os_get_top_address(void)
69 {
70 	struct sigaction sa, old;
71 	unsigned long bottom = 0;
72 	/*
73 	 * A 32-bit UML on a 64-bit host gets confused about the VDSO at
74 	 * 0xffffe000.  It is mapped, is readable, can be reprotected writeable
75 	 * and written.  However, exec discovers later that it can't be
76 	 * unmapped.  So, just set the highest address to be checked to just
77 	 * below it.  This might waste some address space on 4G/4G 32-bit
78 	 * hosts, but shouldn't hurt otherwise.
79 	 */
80 	unsigned long top = 0xffffd000 >> UM_KERN_PAGE_SHIFT;
81 	unsigned long test, original;
82 
83 	printf("Locating the bottom of the address space ... ");
84 	fflush(stdout);
85 
86 	/*
87 	 * We're going to be longjmping out of the signal handler, so
88 	 * SA_DEFER needs to be set.
89 	 */
90 	sa.sa_handler = segfault;
91 	sigemptyset(&sa.sa_mask);
92 	sa.sa_flags = SA_NODEFER;
93 	if (sigaction(SIGSEGV, &sa, &old)) {
94 		perror("os_get_top_address");
95 		exit(1);
96 	}
97 
98 	/* Manually scan the address space, bottom-up, until we find
99 	 * the first valid page (or run out of them).
100 	 */
101 	for (bottom = 0; bottom < top; bottom++) {
102 		if (page_ok(bottom))
103 			break;
104 	}
105 
106 	/* If we've got this far, we ran out of pages. */
107 	if (bottom == top) {
108 		fprintf(stderr, "Unable to determine bottom of address "
109 			"space.\n");
110 		exit(1);
111 	}
112 
113 	printf("0x%lx\n", bottom << UM_KERN_PAGE_SHIFT);
114 	printf("Locating the top of the address space ... ");
115 	fflush(stdout);
116 
117 	original = bottom;
118 
119 	/* This could happen with a 4G/4G split */
120 	if (page_ok(top))
121 		goto out;
122 
123 	do {
124 		test = bottom + (top - bottom) / 2;
125 		if (page_ok(test))
126 			bottom = test;
127 		else
128 			top = test;
129 	} while (top - bottom > 1);
130 
131 out:
132 	/* Restore the old SIGSEGV handling */
133 	if (sigaction(SIGSEGV, &old, NULL)) {
134 		perror("os_get_top_address");
135 		exit(1);
136 	}
137 	top <<= UM_KERN_PAGE_SHIFT;
138 	printf("0x%lx\n", top);
139 
140 	return top;
141 }
142 
143 #else
144 
os_get_top_address(void)145 unsigned long os_get_top_address(void)
146 {
147 	/* The old value of CONFIG_TOP_ADDR */
148 	return 0x7fc0002000;
149 }
150 
151 #endif
152