Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright (C) 1995 Linus Torvalds
4 : : *
5 : : * Pentium III FXSR, SSE support
6 : : * Gareth Hughes <gareth@valinux.com>, May 2000
7 : : *
8 : : * X86-64 port
9 : : * Andi Kleen.
10 : : *
11 : : * CPU hotplug support - ashok.raj@intel.com
12 : : */
13 : :
14 : : /*
15 : : * This file handles the architecture-dependent parts of process handling..
16 : : */
17 : :
18 : : #include <linux/cpu.h>
19 : : #include <linux/errno.h>
20 : : #include <linux/sched.h>
21 : : #include <linux/sched/task.h>
22 : : #include <linux/sched/task_stack.h>
23 : : #include <linux/fs.h>
24 : : #include <linux/kernel.h>
25 : : #include <linux/mm.h>
26 : : #include <linux/elfcore.h>
27 : : #include <linux/smp.h>
28 : : #include <linux/slab.h>
29 : : #include <linux/user.h>
30 : : #include <linux/interrupt.h>
31 : : #include <linux/delay.h>
32 : : #include <linux/export.h>
33 : : #include <linux/ptrace.h>
34 : : #include <linux/notifier.h>
35 : : #include <linux/kprobes.h>
36 : : #include <linux/kdebug.h>
37 : : #include <linux/prctl.h>
38 : : #include <linux/uaccess.h>
39 : : #include <linux/io.h>
40 : : #include <linux/ftrace.h>
41 : : #include <linux/syscalls.h>
42 : :
43 : : #include <asm/pgtable.h>
44 : : #include <asm/processor.h>
45 : : #include <asm/fpu/internal.h>
46 : : #include <asm/mmu_context.h>
47 : : #include <asm/prctl.h>
48 : : #include <asm/desc.h>
49 : : #include <asm/proto.h>
50 : : #include <asm/ia32.h>
51 : : #include <asm/syscalls.h>
52 : : #include <asm/debugreg.h>
53 : : #include <asm/switch_to.h>
54 : : #include <asm/xen/hypervisor.h>
55 : : #include <asm/vdso.h>
56 : : #include <asm/resctrl_sched.h>
57 : : #include <asm/unistd.h>
58 : : #include <asm/fsgsbase.h>
59 : : #ifdef CONFIG_IA32_EMULATION
60 : : /* Not included via unistd.h */
61 : : #include <asm/unistd_32_ia32.h>
62 : : #endif
63 : :
64 : : #include "process.h"
65 : :
66 : : /* Prints also some state that isn't saved in the pt_regs */
67 : 0 : void __show_regs(struct pt_regs *regs, enum show_regs_mode mode)
68 : : {
69 : 0 : unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
70 : 0 : unsigned long d0, d1, d2, d3, d6, d7;
71 : 0 : unsigned int fsindex, gsindex;
72 : 0 : unsigned int ds, es;
73 : :
74 : 0 : show_iret_regs(regs);
75 : :
76 [ # # ]: 0 : if (regs->orig_ax != -1)
77 : 0 : pr_cont(" ORIG_RAX: %016lx\n", regs->orig_ax);
78 : : else
79 : 0 : pr_cont("\n");
80 : :
81 : 0 : printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
82 : : regs->ax, regs->bx, regs->cx);
83 : 0 : printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
84 : : regs->dx, regs->si, regs->di);
85 : 0 : printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
86 : : regs->bp, regs->r8, regs->r9);
87 : 0 : printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
88 : : regs->r10, regs->r11, regs->r12);
89 : 0 : printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
90 : : regs->r13, regs->r14, regs->r15);
91 : :
92 [ # # ]: 0 : if (mode == SHOW_REGS_SHORT)
93 : : return;
94 : :
95 [ # # ]: 0 : if (mode == SHOW_REGS_USER) {
96 : 0 : rdmsrl(MSR_FS_BASE, fs);
97 : 0 : rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
98 : 0 : printk(KERN_DEFAULT "FS: %016lx GS: %016lx\n",
99 : : fs, shadowgs);
100 : 0 : return;
101 : : }
102 : :
103 : 0 : asm("movl %%ds,%0" : "=r" (ds));
104 : 0 : asm("movl %%es,%0" : "=r" (es));
105 : 0 : asm("movl %%fs,%0" : "=r" (fsindex));
106 : 0 : asm("movl %%gs,%0" : "=r" (gsindex));
107 : :
108 : 0 : rdmsrl(MSR_FS_BASE, fs);
109 : 0 : rdmsrl(MSR_GS_BASE, gs);
110 : 0 : rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
111 : :
112 : 0 : cr0 = read_cr0();
113 : 0 : cr2 = read_cr2();
114 : 0 : cr3 = __read_cr3();
115 : 0 : cr4 = __read_cr4();
116 : :
117 : 0 : printk(KERN_DEFAULT "FS: %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
118 : : fs, fsindex, gs, gsindex, shadowgs);
119 : 0 : printk(KERN_DEFAULT "CS: %04lx DS: %04x ES: %04x CR0: %016lx\n", regs->cs, ds,
120 : : es, cr0);
121 : 0 : printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
122 : : cr4);
123 : :
124 [ # # ]: 0 : get_debugreg(d0, 0);
125 [ # # ]: 0 : get_debugreg(d1, 1);
126 [ # # ]: 0 : get_debugreg(d2, 2);
127 [ # # ]: 0 : get_debugreg(d3, 3);
128 [ # # ]: 0 : get_debugreg(d6, 6);
129 [ # # ]: 0 : get_debugreg(d7, 7);
130 : :
131 : : /* Only print out debug registers if they are in their non-default state. */
132 [ # # ]: 0 : if (!((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
133 [ # # ]: 0 : (d6 == DR6_RESERVED) && (d7 == 0x400))) {
134 : 0 : printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n",
135 : : d0, d1, d2);
136 : 0 : printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n",
137 : : d3, d6, d7);
138 : : }
139 : :
140 [ # # ]: 0 : if (boot_cpu_has(X86_FEATURE_OSPKE))
141 : 0 : printk(KERN_DEFAULT "PKRU: %08x\n", read_pkru());
142 : : }
143 : :
144 : 15000 : void release_thread(struct task_struct *dead_task)
145 : : {
146 [ - + ]: 15000 : WARN_ON(dead_task->mm);
147 : 15000 : }
148 : :
149 : : enum which_selector {
150 : : FS,
151 : : GS
152 : : };
153 : :
154 : : /*
155 : : * Saves the FS or GS base for an outgoing thread if FSGSBASE extensions are
156 : : * not available. The goal is to be reasonably fast on non-FSGSBASE systems.
157 : : * It's forcibly inlined because it'll generate better code and this function
158 : : * is hot.
159 : : */
160 : 168402 : static __always_inline void save_base_legacy(struct task_struct *prev_p,
161 : : unsigned short selector,
162 : : enum which_selector which)
163 : : {
164 : 168402 : if (likely(selector == 0)) {
165 : : /*
166 : : * On Intel (without X86_BUG_NULL_SEG), the segment base could
167 : : * be the pre-existing saved base or it could be zero. On AMD
168 : : * (with X86_BUG_NULL_SEG), the segment base could be almost
169 : : * anything.
170 : : *
171 : : * This branch is very hot (it's hit twice on almost every
172 : : * context switch between 64-bit programs), and avoiding
173 : : * the RDMSR helps a lot, so we just assume that whatever
174 : : * value is already saved is correct. This matches historical
175 : : * Linux behavior, so it won't break existing applications.
176 : : *
177 : : * To avoid leaking state, on non-X86_BUG_NULL_SEG CPUs, if we
178 : : * report that the base is zero, it needs to actually be zero:
179 : : * see the corresponding logic in load_seg_legacy.
180 : : */
181 : : } else {
182 : : /*
183 : : * If the selector is 1, 2, or 3, then the base is zero on
184 : : * !X86_BUG_NULL_SEG CPUs and could be anything on
185 : : * X86_BUG_NULL_SEG CPUs. In the latter case, Linux
186 : : * has never attempted to preserve the base across context
187 : : * switches.
188 : : *
189 : : * If selector > 3, then it refers to a real segment, and
190 : : * saving the base isn't necessary.
191 : : */
192 : 0 : if (which == FS)
193 : 0 : prev_p->thread.fsbase = 0;
194 : : else
195 : 0 : prev_p->thread.gsbase = 0;
196 : : }
197 : : }
198 : :
199 : 84201 : static __always_inline void save_fsgs(struct task_struct *task)
200 : : {
201 : 84201 : savesegment(fs, task->thread.fsindex);
202 : 84201 : savesegment(gs, task->thread.gsindex);
203 : 84201 : save_base_legacy(task, task->thread.fsindex, FS);
204 [ - + ]: 84201 : save_base_legacy(task, task->thread.gsindex, GS);
205 : : }
206 : :
207 : : #if IS_ENABLED(CONFIG_KVM)
208 : : /*
209 : : * While a process is running,current->thread.fsbase and current->thread.gsbase
210 : : * may not match the corresponding CPU registers (see save_base_legacy()). KVM
211 : : * wants an efficient way to save and restore FSBASE and GSBASE.
212 : : * When FSGSBASE extensions are enabled, this will have to use RD{FS,GS}BASE.
213 : : */
214 : : void save_fsgs_for_kvm(void)
215 : : {
216 : : save_fsgs(current);
217 : : }
218 : : EXPORT_SYMBOL_GPL(save_fsgs_for_kvm);
219 : : #endif
220 : :
221 : 27530 : static __always_inline void loadseg(enum which_selector which,
222 : : unsigned short sel)
223 : : {
224 : 27530 : if (which == FS)
225 : 27530 : loadsegment(fs, sel);
226 : : else
227 : 0 : load_gs_index(sel);
228 : : }
229 : :
230 : 168402 : static __always_inline void load_seg_legacy(unsigned short prev_index,
231 : : unsigned long prev_base,
232 : : unsigned short next_index,
233 : : unsigned long next_base,
234 : : enum which_selector which)
235 : : {
236 : 168402 : if (likely(next_index <= 3)) {
237 : : /*
238 : : * The next task is using 64-bit TLS, is not using this
239 : : * segment at all, or is having fun with arcane CPU features.
240 : : */
241 [ + + + - ]: 168402 : if (next_base == 0) {
242 : : /*
243 : : * Nasty case: on AMD CPUs, we need to forcibly zero
244 : : * the base.
245 : : */
246 [ - + - - : 122378 : if (static_cpu_has_bug(X86_BUG_NULL_SEG)) {
+ - ]
247 : 0 : loadseg(which, __USER_DS);
248 : 0 : loadseg(which, next_index);
249 : : } else {
250 : : /*
251 : : * We could try to exhaustively detect cases
252 : : * under which we can skip the segment load,
253 : : * but there's really only one case that matters
254 : : * for performance: if both the previous and
255 : : * next states are fully zeroed, we can skip
256 : : * the load.
257 : : *
258 : : * (This assumes that prev_base == 0 has no
259 : : * false positives. This is the case on
260 : : * Intel-style CPUs.)
261 : : */
262 [ + + - + ]: 122378 : if (likely(prev_index | next_index | prev_base))
263 : 12653 : loadseg(which, next_index);
264 : : }
265 : : } else {
266 [ - + - - ]: 46024 : if (prev_index != next_index)
267 : 0 : loadseg(which, next_index);
268 : 46024 : wrmsrl(which == FS ? MSR_FS_BASE : MSR_KERNEL_GS_BASE,
269 : : next_base);
270 : : }
271 : : } else {
272 : : /*
273 : : * The next task is using a real segment. Loading the selector
274 : : * is sufficient.
275 : : */
276 : 0 : loadseg(which, next_index);
277 : : }
278 : : }
279 : :
280 : 84201 : static __always_inline void x86_fsgsbase_load(struct thread_struct *prev,
281 : : struct thread_struct *next)
282 : : {
283 : 84201 : load_seg_legacy(prev->fsindex, prev->fsbase,
284 : 84201 : next->fsindex, next->fsbase, FS);
285 : 84201 : load_seg_legacy(prev->gsindex, prev->gsbase,
286 [ + - ]: 84201 : next->gsindex, next->gsbase, GS);
287 : : }
288 : :
289 : 0 : static unsigned long x86_fsgsbase_read_task(struct task_struct *task,
290 : : unsigned short selector)
291 : : {
292 : 0 : unsigned short idx = selector >> 3;
293 : 0 : unsigned long base;
294 : :
295 [ # # ]: 0 : if (likely((selector & SEGMENT_TI_MASK) == 0)) {
296 [ # # ]: 0 : if (unlikely(idx >= GDT_ENTRIES))
297 : : return 0;
298 : :
299 : : /*
300 : : * There are no user segments in the GDT with nonzero bases
301 : : * other than the TLS segments.
302 : : */
303 [ # # ]: 0 : if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
304 : : return 0;
305 : :
306 : 0 : idx -= GDT_ENTRY_TLS_MIN;
307 : 0 : base = get_desc_base(&task->thread.tls_array[idx]);
308 : : } else {
309 : : #ifdef CONFIG_MODIFY_LDT_SYSCALL
310 : 0 : struct ldt_struct *ldt;
311 : :
312 : : /*
313 : : * If performance here mattered, we could protect the LDT
314 : : * with RCU. This is a slow path, though, so we can just
315 : : * take the mutex.
316 : : */
317 : 0 : mutex_lock(&task->mm->context.lock);
318 : 0 : ldt = task->mm->context.ldt;
319 [ # # ]: 0 : if (unlikely(idx >= ldt->nr_entries))
320 : : base = 0;
321 : : else
322 : 0 : base = get_desc_base(ldt->entries + idx);
323 : 0 : mutex_unlock(&task->mm->context.lock);
324 : : #else
325 : : base = 0;
326 : : #endif
327 : : }
328 : :
329 : : return base;
330 : : }
331 : :
332 : 0 : unsigned long x86_fsbase_read_task(struct task_struct *task)
333 : : {
334 : 0 : unsigned long fsbase;
335 : :
336 [ # # ]: 0 : if (task == current)
337 : 0 : fsbase = x86_fsbase_read_cpu();
338 [ # # ]: 0 : else if (task->thread.fsindex == 0)
339 : 0 : fsbase = task->thread.fsbase;
340 : : else
341 : 0 : fsbase = x86_fsgsbase_read_task(task, task->thread.fsindex);
342 : :
343 : 0 : return fsbase;
344 : : }
345 : :
346 : 0 : unsigned long x86_gsbase_read_task(struct task_struct *task)
347 : : {
348 : 0 : unsigned long gsbase;
349 : :
350 [ # # ]: 0 : if (task == current)
351 : 0 : gsbase = x86_gsbase_read_cpu_inactive();
352 [ # # ]: 0 : else if (task->thread.gsindex == 0)
353 : 0 : gsbase = task->thread.gsbase;
354 : : else
355 : 0 : gsbase = x86_fsgsbase_read_task(task, task->thread.gsindex);
356 : :
357 : 0 : return gsbase;
358 : : }
359 : :
360 : 12 : void x86_fsbase_write_task(struct task_struct *task, unsigned long fsbase)
361 : : {
362 [ # # ]: 0 : WARN_ON_ONCE(task == current);
363 : :
364 : 12 : task->thread.fsbase = fsbase;
365 : 12 : }
366 : :
367 : 0 : void x86_gsbase_write_task(struct task_struct *task, unsigned long gsbase)
368 : : {
369 [ # # ]: 0 : WARN_ON_ONCE(task == current);
370 : :
371 : 0 : task->thread.gsbase = gsbase;
372 : 0 : }
373 : :
374 : : static void
375 : 14877 : start_thread_common(struct pt_regs *regs, unsigned long new_ip,
376 : : unsigned long new_sp,
377 : : unsigned int _cs, unsigned int _ss, unsigned int _ds)
378 : : {
379 [ - + ]: 14877 : WARN_ON_ONCE(regs != current_pt_regs());
380 : :
381 [ - - + ]: 14877 : if (static_cpu_has(X86_BUG_NULL_SEG)) {
382 : : /* Loading zero below won't clear the base. */
383 : 0 : loadsegment(fs, __USER_DS);
384 : 0 : load_gs_index(__USER_DS);
385 : : }
386 : :
387 : 14877 : loadsegment(fs, 0);
388 : 14877 : loadsegment(es, _ds);
389 : 14877 : loadsegment(ds, _ds);
390 : 14877 : load_gs_index(0);
391 : :
392 : 14877 : regs->ip = new_ip;
393 : 14877 : regs->sp = new_sp;
394 : 14877 : regs->cs = _cs;
395 : 14877 : regs->ss = _ss;
396 : 14877 : regs->flags = X86_EFLAGS_IF;
397 : 14877 : }
398 : :
399 : : void
400 : 14877 : start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
401 : : {
402 : 14877 : start_thread_common(regs, new_ip, new_sp,
403 : : __USER_CS, __USER_DS, 0);
404 : 14877 : }
405 : : EXPORT_SYMBOL_GPL(start_thread);
406 : :
407 : : #ifdef CONFIG_COMPAT
408 : 0 : void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp)
409 : : {
410 [ # # ]: 0 : start_thread_common(regs, new_ip, new_sp,
411 : : test_thread_flag(TIF_X32)
412 : : ? __USER_CS : __USER32_CS,
413 : : __USER_DS, __USER_DS);
414 : 0 : }
415 : : #endif
416 : :
417 : : /*
418 : : * switch_to(x,y) should switch tasks from x to y.
419 : : *
420 : : * This could still be optimized:
421 : : * - fold all the options into a flag word and test it with a single test.
422 : : * - could test fs/gs bitsliced
423 : : *
424 : : * Kprobes not supported here. Set the probe on schedule instead.
425 : : * Function graph tracer not supported too.
426 : : */
427 : : __visible __notrace_funcgraph struct task_struct *
428 : 84201 : __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
429 : : {
430 : 84201 : struct thread_struct *prev = &prev_p->thread;
431 : 84201 : struct thread_struct *next = &next_p->thread;
432 : 84201 : struct fpu *prev_fpu = &prev->fpu;
433 : 84201 : struct fpu *next_fpu = &next->fpu;
434 : 84201 : int cpu = smp_processor_id();
435 : :
436 : 84201 : WARN_ON_ONCE(IS_ENABLED(CONFIG_DEBUG_ENTRY) &&
437 : : this_cpu_read(irq_count) != -1);
438 : :
439 [ + + ]: 84201 : if (!test_thread_flag(TIF_NEED_FPU_LOAD))
440 : 46469 : switch_fpu_prepare(prev_fpu, cpu);
441 : :
442 : : /* We must save %fs and %gs before load_TLS() because
443 : : * %fs and %gs may be cleared by load_TLS().
444 : : *
445 : : * (e.g. xen_load_tls())
446 : : */
447 [ - + ]: 84201 : save_fsgs(prev_p);
448 : :
449 : : /*
450 : : * Load TLS before restoring any segments so that segment loads
451 : : * reference the correct GDT entries.
452 : : */
453 : 84201 : load_TLS(next, cpu);
454 : :
455 : : /*
456 : : * Leave lazy mode, flushing any hypercalls made here. This
457 : : * must be done after loading TLS entries in the GDT but before
458 : : * loading segments that might reference them.
459 : : */
460 : 84201 : arch_end_context_switch(next_p);
461 : :
462 : : /* Switch DS and ES.
463 : : *
464 : : * Reading them only returns the selectors, but writing them (if
465 : : * nonzero) loads the full descriptor from the GDT or LDT. The
466 : : * LDT for next is loaded in switch_mm, and the GDT is loaded
467 : : * above.
468 : : *
469 : : * We therefore need to write new values to the segment
470 : : * registers on every context switch unless both the new and old
471 : : * values are zero.
472 : : *
473 : : * Note that we don't need to do anything for CS and SS, as
474 : : * those are saved and restored as part of pt_regs.
475 : : */
476 : 84201 : savesegment(es, prev->es);
477 [ - + ]: 84201 : if (unlikely(next->es | prev->es))
478 : 0 : loadsegment(es, next->es);
479 : :
480 : 84201 : savesegment(ds, prev->ds);
481 [ - + ]: 84201 : if (unlikely(next->ds | prev->ds))
482 : 0 : loadsegment(ds, next->ds);
483 : :
484 [ + - ]: 84201 : x86_fsgsbase_load(prev, next);
485 : :
486 : : /*
487 : : * Switch the PDA and FPU contexts.
488 : : */
489 : 84201 : this_cpu_write(current_task, next_p);
490 : 84201 : this_cpu_write(cpu_current_top_of_stack, task_top_of_stack(next_p));
491 : :
492 : 84201 : switch_fpu_finish(next_fpu);
493 : :
494 : : /* Reload sp0. */
495 : 84201 : update_task_stack(next_p);
496 : :
497 : 84201 : switch_to_extra(prev_p, next_p);
498 : :
499 [ + - - ]: 84201 : if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) {
500 : : /*
501 : : * AMD CPUs have a misfeature: SYSRET sets the SS selector but
502 : : * does not update the cached descriptor. As a result, if we
503 : : * do SYSRET while SS is NULL, we'll end up in user mode with
504 : : * SS apparently equal to __USER_DS but actually unusable.
505 : : *
506 : : * The straightforward workaround would be to fix it up just
507 : : * before SYSRET, but that would slow down the system call
508 : : * fast paths. Instead, we ensure that SS is never NULL in
509 : : * system call context. We do this by replacing NULL SS
510 : : * selectors at every context switch. SYSCALL sets up a valid
511 : : * SS, so the only way to get NULL is to re-enter the kernel
512 : : * from CPL 3 through an interrupt. Since that can't happen
513 : : * in the same task as a running syscall, we are guaranteed to
514 : : * context switch between every interrupt vector entry and a
515 : : * subsequent SYSRET.
516 : : *
517 : : * We read SS first because SS reads are much faster than
518 : : * writes. Out of caution, we force SS to __KERNEL_DS even if
519 : : * it previously had a different non-NULL value.
520 : : */
521 : 84201 : unsigned short ss_sel;
522 : 84201 : savesegment(ss, ss_sel);
523 [ + + ]: 84201 : if (ss_sel != __KERNEL_DS)
524 : 5403 : loadsegment(ss, __KERNEL_DS);
525 : : }
526 : :
527 : : /* Load the Intel cache allocation PQR MSR. */
528 : 84201 : resctrl_sched_in();
529 : :
530 : 84201 : return prev_p;
531 : : }
532 : :
533 : 14877 : void set_personality_64bit(void)
534 : : {
535 : : /* inherit personality from parent */
536 : :
537 : : /* Make sure to be in 64bit mode */
538 : 14877 : clear_thread_flag(TIF_IA32);
539 : 14877 : clear_thread_flag(TIF_ADDR32);
540 : 14877 : clear_thread_flag(TIF_X32);
541 : : /* Pretend that this comes from a 64bit execve */
542 [ + - ]: 14877 : task_pt_regs(current)->orig_ax = __NR_execve;
543 : 14877 : current_thread_info()->status &= ~TS_COMPAT;
544 : :
545 : : /* Ensure the corresponding mm is not marked. */
546 [ + - ]: 14877 : if (current->mm)
547 : 14877 : current->mm->context.ia32_compat = 0;
548 : :
549 : : /* TBD: overwrites user setup. Should have two bits.
550 : : But 64bit processes have always behaved this way,
551 : : so it's not too bad. The main problem is just that
552 : : 32bit children are affected again. */
553 : 14877 : current->personality &= ~READ_IMPLIES_EXEC;
554 : 14877 : }
555 : :
556 : : static void __set_personality_x32(void)
557 : : {
558 : : #ifdef CONFIG_X86_X32
559 : : clear_thread_flag(TIF_IA32);
560 : : set_thread_flag(TIF_X32);
561 : : if (current->mm)
562 : : current->mm->context.ia32_compat = TIF_X32;
563 : : current->personality &= ~READ_IMPLIES_EXEC;
564 : : /*
565 : : * in_32bit_syscall() uses the presence of the x32 syscall bit
566 : : * flag to determine compat status. The x86 mmap() code relies on
567 : : * the syscall bitness so set x32 syscall bit right here to make
568 : : * in_32bit_syscall() work during exec().
569 : : *
570 : : * Pretend to come from a x32 execve.
571 : : */
572 : : task_pt_regs(current)->orig_ax = __NR_x32_execve | __X32_SYSCALL_BIT;
573 : : current_thread_info()->status &= ~TS_COMPAT;
574 : : #endif
575 : : }
576 : :
577 : 0 : static void __set_personality_ia32(void)
578 : : {
579 : : #ifdef CONFIG_IA32_EMULATION
580 : 0 : set_thread_flag(TIF_IA32);
581 : 0 : clear_thread_flag(TIF_X32);
582 [ # # ]: 0 : if (current->mm)
583 : 0 : current->mm->context.ia32_compat = TIF_IA32;
584 : 0 : current->personality |= force_personality32;
585 : : /* Prepare the first "return" to user space */
586 : 0 : task_pt_regs(current)->orig_ax = __NR_ia32_execve;
587 : 0 : current_thread_info()->status |= TS_COMPAT;
588 : : #endif
589 : 0 : }
590 : :
591 : 0 : void set_personality_ia32(bool x32)
592 : : {
593 : : /* Make sure to be in 32bit mode */
594 : 0 : set_thread_flag(TIF_ADDR32);
595 : :
596 [ # # ]: 0 : if (x32)
597 : : __set_personality_x32();
598 : : else
599 : 0 : __set_personality_ia32();
600 : 0 : }
601 : : EXPORT_SYMBOL_GPL(set_personality_ia32);
602 : :
603 : : #ifdef CONFIG_CHECKPOINT_RESTORE
604 : : static long prctl_map_vdso(const struct vdso_image *image, unsigned long addr)
605 : : {
606 : : int ret;
607 : :
608 : : ret = map_vdso_once(image, addr);
609 : : if (ret)
610 : : return ret;
611 : :
612 : : return (long)image->size;
613 : : }
614 : : #endif
615 : :
616 : 14889 : long do_arch_prctl_64(struct task_struct *task, int option, unsigned long arg2)
617 : : {
618 : 14889 : int ret = 0;
619 : :
620 [ - + - - : 14889 : switch (option) {
- ]
621 : : case ARCH_SET_GS: {
622 [ # # # # : 0 : if (unlikely(arg2 >= TASK_SIZE_MAX))
# ]
623 : : return -EPERM;
624 : :
625 : 0 : preempt_disable();
626 : : /*
627 : : * ARCH_SET_GS has always overwritten the index
628 : : * and the base. Zero is the most sensible value
629 : : * to put in the index, and is the only value that
630 : : * makes any sense if FSGSBASE is unavailable.
631 : : */
632 [ # # ]: 0 : if (task == current) {
633 : 0 : loadseg(GS, 0);
634 : 0 : x86_gsbase_write_cpu_inactive(arg2);
635 : :
636 : : /*
637 : : * On non-FSGSBASE systems, save_base_legacy() expects
638 : : * that we also fill in thread.gsbase.
639 : : */
640 : 0 : task->thread.gsbase = arg2;
641 : :
642 : : } else {
643 : 0 : task->thread.gsindex = 0;
644 [ # # ]: 0 : x86_gsbase_write_task(task, arg2);
645 : : }
646 : 0 : preempt_enable();
647 : 0 : break;
648 : : }
649 : : case ARCH_SET_FS: {
650 : : /*
651 : : * Not strictly needed for %fs, but do it for symmetry
652 : : * with %gs
653 : : */
654 [ - - + + : 14889 : if (unlikely(arg2 >= TASK_SIZE_MAX))
- ]
655 : : return -EPERM;
656 : :
657 : 14889 : preempt_disable();
658 : : /*
659 : : * Set the selector to 0 for the same reason
660 : : * as %gs above.
661 : : */
662 [ + + ]: 14889 : if (task == current) {
663 : 14877 : loadseg(FS, 0);
664 : 14877 : x86_fsbase_write_cpu(arg2);
665 : :
666 : : /*
667 : : * On non-FSGSBASE systems, save_base_legacy() expects
668 : : * that we also fill in thread.fsbase.
669 : : */
670 : 14877 : task->thread.fsbase = arg2;
671 : : } else {
672 : 12 : task->thread.fsindex = 0;
673 [ - + ]: 12 : x86_fsbase_write_task(task, arg2);
674 : : }
675 : 14889 : preempt_enable();
676 : 14889 : break;
677 : : }
678 : 0 : case ARCH_GET_FS: {
679 : 0 : unsigned long base = x86_fsbase_read_task(task);
680 : :
681 : 0 : ret = put_user(base, (unsigned long __user *)arg2);
682 : 0 : break;
683 : : }
684 : 0 : case ARCH_GET_GS: {
685 : 0 : unsigned long base = x86_gsbase_read_task(task);
686 : :
687 : 0 : ret = put_user(base, (unsigned long __user *)arg2);
688 : 0 : break;
689 : : }
690 : :
691 : : #ifdef CONFIG_CHECKPOINT_RESTORE
692 : : # ifdef CONFIG_X86_X32_ABI
693 : : case ARCH_MAP_VDSO_X32:
694 : : return prctl_map_vdso(&vdso_image_x32, arg2);
695 : : # endif
696 : : # if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
697 : : case ARCH_MAP_VDSO_32:
698 : : return prctl_map_vdso(&vdso_image_32, arg2);
699 : : # endif
700 : : case ARCH_MAP_VDSO_64:
701 : : return prctl_map_vdso(&vdso_image_64, arg2);
702 : : #endif
703 : :
704 : : default:
705 : : ret = -EINVAL;
706 : : break;
707 : : }
708 : :
709 : 14889 : return ret;
710 : : }
711 : :
712 : 29754 : SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
713 : : {
714 : 14877 : long ret;
715 : :
716 : 14877 : ret = do_arch_prctl_64(current, option, arg2);
717 [ - + ]: 14877 : if (ret == -EINVAL)
718 : 0 : ret = do_arch_prctl_common(current, option, arg2);
719 : :
720 : 14877 : return ret;
721 : : }
722 : :
723 : : #ifdef CONFIG_IA32_EMULATION
724 : 0 : COMPAT_SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
725 : : {
726 : 0 : return do_arch_prctl_common(current, option, arg2);
727 : : }
728 : : #endif
729 : :
730 : 0 : unsigned long KSTK_ESP(struct task_struct *task)
731 : : {
732 : 0 : return task_pt_regs(task)->sp;
733 : : }
|
