Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : #include <linux/compat.h>
3 : : #include <linux/errno.h>
4 : : #include <linux/sched.h>
5 : : #include <linux/sched/mm.h>
6 : : #include <linux/syscalls.h>
7 : : #include <linux/mm.h>
8 : : #include <linux/fs.h>
9 : : #include <linux/smp.h>
10 : : #include <linux/sem.h>
11 : : #include <linux/msg.h>
12 : : #include <linux/shm.h>
13 : : #include <linux/stat.h>
14 : : #include <linux/mman.h>
15 : : #include <linux/file.h>
16 : : #include <linux/utsname.h>
17 : : #include <linux/personality.h>
18 : : #include <linux/random.h>
19 : : #include <linux/uaccess.h>
20 : : #include <linux/elf.h>
21 : :
22 : : #include <asm/elf.h>
23 : : #include <asm/ia32.h>
24 : : #include <asm/syscalls.h>
25 : :
26 : : /*
27 : : * Align a virtual address to avoid aliasing in the I$ on AMD F15h.
28 : : */
29 : 8749332 : static unsigned long get_align_mask(void)
30 : : {
31 : : /* handle 32- and 64-bit case with a single conditional */
32 [ - + - - ]: 8749332 : if (va_align.flags < 0 || !(va_align.flags & (2 - mmap_is_ia32())))
33 : 8749332 : return 0;
34 : :
35 [ # # ]: 0 : if (!(current->flags & PF_RANDOMIZE))
36 : : return 0;
37 : :
38 : 0 : return va_align.mask;
39 : : }
40 : :
41 : : /*
42 : : * To avoid aliasing in the I$ on AMD F15h, the bits defined by the
43 : : * va_align.bits, [12:upper_bit), are set to a random value instead of
44 : : * zeroing them. This random value is computed once per boot. This form
45 : : * of ASLR is known as "per-boot ASLR".
46 : : *
47 : : * To achieve this, the random value is added to the info.align_offset
48 : : * value before calling vm_unmapped_area() or ORed directly to the
49 : : * address.
50 : : */
51 : 4374666 : static unsigned long get_align_bits(void)
52 : : {
53 : 8749332 : return va_align.bits & get_align_mask();
54 : : }
55 : :
56 : 392094 : unsigned long align_vdso_addr(unsigned long addr)
57 : : {
58 : 392094 : unsigned long align_mask = get_align_mask();
59 : 392094 : addr = (addr + align_mask) & ~align_mask;
60 : 392094 : return addr | get_align_bits();
61 : : }
62 : :
63 : 0 : static int __init control_va_addr_alignment(char *str)
64 : : {
65 : : /* guard against enabling this on other CPU families */
66 [ # # ]: 0 : if (va_align.flags < 0)
67 : : return 1;
68 : :
69 [ # # ]: 0 : if (*str == 0)
70 : : return 1;
71 : :
72 [ # # ]: 0 : if (*str == '=')
73 : 0 : str++;
74 : :
75 [ # # ]: 0 : if (!strcmp(str, "32"))
76 : 0 : va_align.flags = ALIGN_VA_32;
77 [ # # ]: 0 : else if (!strcmp(str, "64"))
78 : 0 : va_align.flags = ALIGN_VA_64;
79 [ # # ]: 0 : else if (!strcmp(str, "off"))
80 : 0 : va_align.flags = 0;
81 [ # # ]: 0 : else if (!strcmp(str, "on"))
82 : 0 : va_align.flags = ALIGN_VA_32 | ALIGN_VA_64;
83 : : else
84 : : return 0;
85 : :
86 : : return 1;
87 : : }
88 : : __setup("align_va_addr", control_va_addr_alignment);
89 : :
90 : 12508796 : SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
91 : : unsigned long, prot, unsigned long, flags,
92 : : unsigned long, fd, unsigned long, off)
93 : : {
94 : 6254398 : long error;
95 : 6254398 : error = -EINVAL;
96 [ - - - + ]: 6254398 : if (off & ~PAGE_MASK)
97 : 0 : goto out;
98 : :
99 : 6254398 : error = ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
100 : 6254398 : out:
101 : 6254398 : return error;
102 : : }
103 : :
104 : 0 : static void find_start_end(unsigned long addr, unsigned long flags,
105 : : unsigned long *begin, unsigned long *end)
106 : : {
107 [ # # # # : 0 : if (!in_32bit_syscall() && (flags & MAP_32BIT)) {
# # ]
108 : : /* This is usually used needed to map code in small
109 : : model, so it needs to be in the first 31bit. Limit
110 : : it to that. This means we need to move the
111 : : unmapped base down for this case. This can give
112 : : conflicts with the heap, but we assume that glibc
113 : : malloc knows how to fall back to mmap. Give it 1GB
114 : : of playground for now. -AK */
115 : 0 : *begin = 0x40000000;
116 : 0 : *end = 0x80000000;
117 [ # # ]: 0 : if (current->flags & PF_RANDOMIZE) {
118 : 0 : *begin = randomize_page(*begin, 0x02000000);
119 : : }
120 : 0 : return;
121 : : }
122 : :
123 : 0 : *begin = get_mmap_base(1);
124 [ # # # # ]: 0 : if (in_32bit_syscall())
125 : 0 : *end = task_size_32bit();
126 : : else
127 : 0 : *end = task_size_64bit(addr > DEFAULT_MAP_WINDOW);
128 : : }
129 : :
130 : : unsigned long
131 : 0 : arch_get_unmapped_area(struct file *filp, unsigned long addr,
132 : : unsigned long len, unsigned long pgoff, unsigned long flags)
133 : : {
134 [ # # ]: 0 : struct mm_struct *mm = current->mm;
135 : 0 : struct vm_area_struct *vma;
136 : 0 : struct vm_unmapped_area_info info;
137 : 0 : unsigned long begin, end;
138 : :
139 [ # # ]: 0 : if (flags & MAP_FIXED)
140 : : return addr;
141 : :
142 : 0 : find_start_end(addr, flags, &begin, &end);
143 : :
144 [ # # ]: 0 : if (len > end)
145 : : return -ENOMEM;
146 : :
147 [ # # ]: 0 : if (addr) {
148 : 0 : addr = PAGE_ALIGN(addr);
149 : 0 : vma = find_vma(mm, addr);
150 [ # # # # ]: 0 : if (end - len >= addr &&
151 [ # # # # ]: 0 : (!vma || addr + len <= vm_start_gap(vma)))
152 : : return addr;
153 : : }
154 : :
155 : 0 : info.flags = 0;
156 : 0 : info.length = len;
157 : 0 : info.low_limit = begin;
158 : 0 : info.high_limit = end;
159 : 0 : info.align_mask = 0;
160 : 0 : info.align_offset = pgoff << PAGE_SHIFT;
161 [ # # ]: 0 : if (filp) {
162 : 0 : info.align_mask = get_align_mask();
163 : 0 : info.align_offset += get_align_bits();
164 : : }
165 : 0 : return vm_unmapped_area(&info);
166 : : }
167 : :
168 : : unsigned long
169 : 10754342 : arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
170 : : const unsigned long len, const unsigned long pgoff,
171 : : const unsigned long flags)
172 : : {
173 : 10754342 : struct vm_area_struct *vma;
174 : 10754342 : struct mm_struct *mm = current->mm;
175 : 10754342 : unsigned long addr = addr0;
176 : 10754342 : struct vm_unmapped_area_info info;
177 : :
178 : : /* requested length too big for entire address space */
179 [ - + - - : 21508684 : if (len > TASK_SIZE)
+ - ]
180 : : return -ENOMEM;
181 : :
182 : : /* No address checking. See comment at mmap_address_hint_valid() */
183 [ + + ]: 10754342 : if (flags & MAP_FIXED)
184 : : return addr;
185 : :
186 : : /* for MAP_32BIT mappings we force the legacy mmap base */
187 [ - + + - : 4995211 : if (!in_32bit_syscall() && (flags & MAP_32BIT))
- + ]
188 : 0 : goto bottomup;
189 : :
190 : : /* requesting a specific address */
191 [ + + ]: 4995211 : if (addr) {
192 : 392164 : addr &= PAGE_MASK;
193 [ + + ]: 392164 : if (!mmap_address_hint_valid(addr, len))
194 : 1 : goto get_unmapped_area;
195 : :
196 : 392163 : vma = find_vma(mm, addr);
197 [ + + - + : 392163 : if (!vma || addr + len <= vm_start_gap(vma))
- + ]
198 : : return addr;
199 : : }
200 : 4603047 : get_unmapped_area:
201 : :
202 : 4603048 : info.flags = VM_UNMAPPED_AREA_TOPDOWN;
203 : 4603048 : info.length = len;
204 : 4603048 : info.low_limit = PAGE_SIZE;
205 : 4603048 : info.high_limit = get_mmap_base(0);
206 : :
207 : : /*
208 : : * If hint address is above DEFAULT_MAP_WINDOW, look for unmapped area
209 : : * in the full address space.
210 : : *
211 : : * !in_32bit_syscall() check to avoid high addresses for x32
212 : : * (and make it no op on native i386).
213 : : */
214 [ - + - - ]: 4603048 : if (addr > DEFAULT_MAP_WINDOW && !in_32bit_syscall())
215 [ # # # ]: 0 : info.high_limit += TASK_SIZE_MAX - DEFAULT_MAP_WINDOW;
216 : :
217 : 4603048 : info.align_mask = 0;
218 : 4603048 : info.align_offset = pgoff << PAGE_SHIFT;
219 [ + + ]: 4603048 : if (filp) {
220 : 3982572 : info.align_mask = get_align_mask();
221 : 3982572 : info.align_offset += get_align_bits();
222 : : }
223 : 4603048 : addr = vm_unmapped_area(&info);
224 [ - + ]: 4603048 : if (!(addr & ~PAGE_MASK))
225 : : return addr;
226 : 0 : VM_BUG_ON(addr != -ENOMEM);
227 : :
228 : 0 : bottomup:
229 : : /*
230 : : * A failed mmap() very likely causes application failure,
231 : : * so fall back to the bottom-up function here. This scenario
232 : : * can happen with large stack limits and large mmap()
233 : : * allocations.
234 : : */
235 : 0 : return arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
236 : : }
|
