2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1995 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Pentium III FXSR, SSE support
|
|
|
|
* Gareth Hughes <gareth@valinux.com>, May 2000
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This file handles the architecture-dependent parts of process handling..
|
|
|
|
*/
|
|
|
|
|
2005-06-26 04:54:50 +07:00
|
|
|
#include <linux/cpu.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/sched.h>
|
2017-02-09 00:51:36 +07:00
|
|
|
#include <linux/sched/task.h>
|
2017-02-09 00:51:37 +07:00
|
|
|
#include <linux/sched/task_stack.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/elfcore.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/user.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/mc146818rtc.h>
|
2016-07-14 07:18:56 +07:00
|
|
|
#include <linux/export.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/kallsyms.h>
|
|
|
|
#include <linux/ptrace.h>
|
2006-09-26 15:52:28 +07:00
|
|
|
#include <linux/personality.h>
|
2007-05-03 00:27:16 +07:00
|
|
|
#include <linux/percpu.h>
|
2008-04-14 05:24:18 +07:00
|
|
|
#include <linux/prctl.h>
|
2008-12-06 09:40:00 +07:00
|
|
|
#include <linux/ftrace.h>
|
2009-01-04 17:48:56 +07:00
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/kdebug.h>
|
2017-03-20 15:16:24 +07:00
|
|
|
#include <linux/syscalls.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/ldt.h>
|
|
|
|
#include <asm/processor.h>
|
2015-04-24 07:54:44 +07:00
|
|
|
#include <asm/fpu/internal.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/desc.h>
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
2005-06-26 04:54:50 +07:00
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/cpu.h>
|
2008-07-21 23:04:13 +07:00
|
|
|
#include <asm/syscalls.h>
|
2009-06-02 01:14:55 +07:00
|
|
|
#include <asm/debugreg.h>
|
2012-03-29 00:11:12 +07:00
|
|
|
#include <asm/switch_to.h>
|
2015-07-29 12:41:21 +07:00
|
|
|
#include <asm/vm86.h>
|
2018-11-22 03:28:25 +07:00
|
|
|
#include <asm/resctrl_sched.h>
|
2017-03-20 15:16:24 +07:00
|
|
|
#include <asm/proto.h>
|
2005-06-26 04:54:50 +07:00
|
|
|
|
2018-11-26 01:33:47 +07:00
|
|
|
#include "process.h"
|
|
|
|
|
2018-09-01 02:41:51 +07:00
|
|
|
void __show_regs(struct pt_regs *regs, enum show_regs_mode mode)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
|
2007-07-21 22:10:42 +07:00
|
|
|
unsigned long d0, d1, d2, d3, d6, d7;
|
2008-01-30 19:30:56 +07:00
|
|
|
unsigned long sp;
|
2007-10-20 01:35:03 +07:00
|
|
|
unsigned short ss, gs;
|
|
|
|
|
2015-03-19 08:33:33 +07:00
|
|
|
if (user_mode(regs)) {
|
2008-01-30 19:30:56 +07:00
|
|
|
sp = regs->sp;
|
2017-07-28 20:00:32 +07:00
|
|
|
ss = regs->ss;
|
2009-02-09 20:17:40 +07:00
|
|
|
gs = get_user_gs(regs);
|
2007-10-20 01:35:03 +07:00
|
|
|
} else {
|
2009-10-13 04:09:07 +07:00
|
|
|
sp = kernel_stack_pointer(regs);
|
2007-10-20 01:35:03 +07:00
|
|
|
savesegment(ss, ss);
|
|
|
|
savesegment(gs, gs);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2018-04-17 23:11:22 +07:00
|
|
|
show_ip(regs, KERN_DEFAULT);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-28 15:26:59 +07:00
|
|
|
printk(KERN_DEFAULT "EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
|
2008-01-30 19:30:56 +07:00
|
|
|
regs->ax, regs->bx, regs->cx, regs->dx);
|
2009-12-28 15:26:59 +07:00
|
|
|
printk(KERN_DEFAULT "ESI: %08lx EDI: %08lx EBP: %08lx ESP: %08lx\n",
|
2008-01-30 19:30:56 +07:00
|
|
|
regs->si, regs->di, regs->bp, sp);
|
2018-04-17 23:11:22 +07:00
|
|
|
printk(KERN_DEFAULT "DS: %04x ES: %04x FS: %04x GS: %04x SS: %04x EFLAGS: %08lx\n",
|
|
|
|
(u16)regs->ds, (u16)regs->es, (u16)regs->fs, gs, ss, regs->flags);
|
2007-10-20 01:35:03 +07:00
|
|
|
|
2018-09-01 02:41:51 +07:00
|
|
|
if (mode != SHOW_REGS_ALL)
|
2007-10-20 01:35:03 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-04 05:56:36 +07:00
|
|
|
cr0 = read_cr0();
|
|
|
|
cr2 = read_cr2();
|
2017-06-13 00:26:14 +07:00
|
|
|
cr3 = __read_cr3();
|
2016-09-30 02:48:12 +07:00
|
|
|
cr4 = __read_cr4();
|
2009-12-28 15:26:59 +07:00
|
|
|
printk(KERN_DEFAULT "CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n",
|
2007-10-20 01:35:03 +07:00
|
|
|
cr0, cr2, cr3, cr4);
|
2007-07-21 22:10:42 +07:00
|
|
|
|
|
|
|
get_debugreg(d0, 0);
|
|
|
|
get_debugreg(d1, 1);
|
|
|
|
get_debugreg(d2, 2);
|
|
|
|
get_debugreg(d3, 3);
|
|
|
|
get_debugreg(d6, 6);
|
|
|
|
get_debugreg(d7, 7);
|
2013-06-18 23:09:11 +07:00
|
|
|
|
|
|
|
/* Only print out debug registers if they are in their non-default state. */
|
|
|
|
if ((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
|
|
|
|
(d6 == DR6_RESERVED) && (d7 == 0x400))
|
|
|
|
return;
|
|
|
|
|
|
|
|
printk(KERN_DEFAULT "DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n",
|
|
|
|
d0, d1, d2, d3);
|
2009-12-28 15:26:59 +07:00
|
|
|
printk(KERN_DEFAULT "DR6: %08lx DR7: %08lx\n",
|
2007-10-20 01:35:03 +07:00
|
|
|
d6, d7);
|
|
|
|
}
|
2007-07-21 22:10:42 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void release_thread(struct task_struct *dead_task)
|
|
|
|
{
|
2006-01-06 15:11:59 +07:00
|
|
|
BUG_ON(dead_task->mm);
|
2005-04-17 05:20:36 +07:00
|
|
|
release_vm86_irqs(dead_task);
|
|
|
|
}
|
|
|
|
|
2015-07-01 05:00:00 +07:00
|
|
|
int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
|
|
|
|
unsigned long arg, struct task_struct *p, unsigned long tls)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-09-11 03:44:54 +07:00
|
|
|
struct pt_regs *childregs = task_pt_regs(p);
|
2016-08-13 23:38:19 +07:00
|
|
|
struct fork_frame *fork_frame = container_of(childregs, struct fork_frame, regs);
|
|
|
|
struct inactive_task_frame *frame = &fork_frame->frame;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct task_struct *tsk;
|
|
|
|
int err;
|
|
|
|
|
2019-02-14 16:30:52 +07:00
|
|
|
/*
|
|
|
|
* For a new task use the RESET flags value since there is no before.
|
|
|
|
* All the status flags are zero; DF and all the system flags must also
|
|
|
|
* be 0, specifically IF must be 0 because we context switch to the new
|
|
|
|
* task with interrupts disabled.
|
|
|
|
*/
|
|
|
|
frame->flags = X86_EFLAGS_FIXED;
|
2016-08-13 23:38:19 +07:00
|
|
|
frame->bp = 0;
|
2016-08-13 23:38:20 +07:00
|
|
|
frame->ret_addr = (unsigned long) ret_from_fork;
|
2016-08-13 23:38:19 +07:00
|
|
|
p->thread.sp = (unsigned long) fork_frame;
|
2012-09-11 03:44:54 +07:00
|
|
|
p->thread.sp0 = (unsigned long) (childregs+1);
|
2014-09-03 00:57:33 +07:00
|
|
|
memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
|
2012-09-11 03:44:54 +07:00
|
|
|
|
2012-10-23 09:34:11 +07:00
|
|
|
if (unlikely(p->flags & PF_KTHREAD)) {
|
2012-09-11 03:44:54 +07:00
|
|
|
/* kernel thread */
|
|
|
|
memset(childregs, 0, sizeof(struct pt_regs));
|
2016-08-13 23:38:20 +07:00
|
|
|
frame->bx = sp; /* function */
|
|
|
|
frame->di = arg;
|
2012-09-11 03:44:54 +07:00
|
|
|
p->thread.io_bitmap_ptr = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
2016-08-13 23:38:20 +07:00
|
|
|
frame->bx = 0;
|
2012-10-23 09:34:11 +07:00
|
|
|
*childregs = *current_pt_regs();
|
2008-01-30 19:30:56 +07:00
|
|
|
childregs->ax = 0;
|
2012-10-23 09:34:11 +07:00
|
|
|
if (sp)
|
|
|
|
childregs->sp = sp;
|
2005-05-06 06:15:03 +07:00
|
|
|
|
2012-10-23 09:34:11 +07:00
|
|
|
task_user_gs(p) = get_user_gs(current_pt_regs());
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-06-02 01:14:55 +07:00
|
|
|
p->thread.io_bitmap_ptr = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
tsk = current;
|
2009-06-02 01:14:55 +07:00
|
|
|
err = -ENOMEM;
|
2009-09-10 00:22:48 +07:00
|
|
|
|
2006-07-10 08:12:39 +07:00
|
|
|
if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
|
2006-10-01 13:27:21 +07:00
|
|
|
p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
|
|
|
|
IO_BITMAP_BYTES, GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!p->thread.io_bitmap_ptr) {
|
|
|
|
p->thread.io_bitmap_max = 0;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2006-07-10 08:12:39 +07:00
|
|
|
set_tsk_thread_flag(p, TIF_IO_BITMAP);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-30 19:30:46 +07:00
|
|
|
err = 0;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Set a new TLS for the child thread?
|
|
|
|
*/
|
2008-01-30 19:30:46 +07:00
|
|
|
if (clone_flags & CLONE_SETTLS)
|
|
|
|
err = do_set_thread_area(p, -1,
|
2015-07-01 05:00:00 +07:00
|
|
|
(struct user_desc __user *)tls, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (err && p->thread.io_bitmap_ptr) {
|
|
|
|
kfree(p->thread.io_bitmap_ptr);
|
|
|
|
p->thread.io_bitmap_max = 0;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-02-21 11:18:40 +07:00
|
|
|
void
|
|
|
|
start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
|
|
|
|
{
|
2009-02-09 20:17:40 +07:00
|
|
|
set_user_gs(regs, 0);
|
2008-02-21 11:18:40 +07:00
|
|
|
regs->fs = 0;
|
|
|
|
regs->ds = __USER_DS;
|
|
|
|
regs->es = __USER_DS;
|
|
|
|
regs->ss = __USER_DS;
|
|
|
|
regs->cs = __USER_CS;
|
|
|
|
regs->ip = new_ip;
|
|
|
|
regs->sp = new_sp;
|
2012-08-03 02:05:11 +07:00
|
|
|
regs->flags = X86_EFLAGS_IF;
|
2015-03-22 05:54:21 +07:00
|
|
|
force_iret();
|
2008-02-21 11:18:40 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(start_thread);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2011-04-28 16:02:08 +07:00
|
|
|
* switch_to(x,y) should switch tasks from x to y.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* We fsave/fwait so that an exception goes off at the right time
|
|
|
|
* (as a call from the fsave or fwait in effect) rather than to
|
|
|
|
* the wrong process. Lazy FP saving no longer makes any sense
|
|
|
|
* with modern CPU's, and this simplifies a lot of things (SMP
|
|
|
|
* and UP become the same).
|
|
|
|
*
|
|
|
|
* NOTE! We used to use the x86 hardware context switching. The
|
|
|
|
* reason for not using it any more becomes apparent when you
|
|
|
|
* try to recover gracefully from saved state that is no longer
|
|
|
|
* valid (stale segment register values in particular). With the
|
|
|
|
* hardware task-switch, there is no way to fix up bad state in
|
|
|
|
* a reasonable manner.
|
|
|
|
*
|
|
|
|
* The fact that Intel documents the hardware task-switching to
|
|
|
|
* be slow is a fairly red herring - this code is not noticeably
|
|
|
|
* faster. However, there _is_ some room for improvement here,
|
|
|
|
* so the performance issues may eventually be a valid point.
|
|
|
|
* More important, however, is the fact that this allows us much
|
|
|
|
* more flexibility.
|
|
|
|
*
|
2008-01-30 19:30:56 +07:00
|
|
|
* The return value (in %ax) will be the "prev" task after
|
2005-04-17 05:20:36 +07:00
|
|
|
* the task-switch, and shows up in ret_from_fork in entry.S,
|
|
|
|
* for example.
|
|
|
|
*/
|
2013-08-06 05:02:39 +07:00
|
|
|
__visible __notrace_funcgraph struct task_struct *
|
2008-12-06 09:40:00 +07:00
|
|
|
__switch_to(struct task_struct *prev_p, struct task_struct *next_p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct thread_struct *prev = &prev_p->thread,
|
2015-04-23 22:43:27 +07:00
|
|
|
*next = &next_p->thread;
|
|
|
|
struct fpu *prev_fpu = &prev->fpu;
|
|
|
|
struct fpu *next_fpu = &next->fpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
/* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
|
|
|
|
|
2016-10-14 19:15:31 +07:00
|
|
|
switch_fpu_prepare(prev_fpu, cpu);
|
2006-12-07 08:14:01 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2007-02-13 19:26:20 +07:00
|
|
|
* Save away %gs. No need to save %fs, as it was saved on the
|
[PATCH] i386: Use %gs as the PDA base-segment in the kernel
This patch is the meat of the PDA change. This patch makes several related
changes:
1: Most significantly, %gs is now used in the kernel. This means that on
entry, the old value of %gs is saved away, and it is reloaded with
__KERNEL_PDA.
2: entry.S constructs the stack in the shape of struct pt_regs, and this
is passed around the kernel so that the process's saved register
state can be accessed.
Unfortunately struct pt_regs doesn't currently have space for %gs
(or %fs). This patch extends pt_regs to add space for gs (no space
is allocated for %fs, since it won't be used, and it would just
complicate the code in entry.S to work around the space).
3: Because %gs is now saved on the stack like %ds, %es and the integer
registers, there are a number of places where it no longer needs to
be handled specially; namely context switch, and saving/restoring the
register state in a signal context.
4: And since kernel threads run in kernel space and call normal kernel
code, they need to be created with their %gs == __KERNEL_PDA.
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Cc: Chuck Ebbert <76306.1226@compuserve.com>
Cc: Zachary Amsden <zach@vmware.com>
Cc: Jan Beulich <jbeulich@novell.com>
Cc: Andi Kleen <ak@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
2006-12-07 08:14:02 +07:00
|
|
|
* stack on entry. No need to save %es and %ds, as those are
|
|
|
|
* always kernel segments while inside the kernel. Doing this
|
|
|
|
* before setting the new TLS descriptors avoids the situation
|
|
|
|
* where we temporarily have non-reloadable segments in %fs
|
|
|
|
* and %gs. This could be an issue if the NMI handler ever
|
|
|
|
* used %fs or %gs (it does not today), or if the kernel is
|
|
|
|
* running inside of a hypervisor layer.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-02-09 20:17:40 +07:00
|
|
|
lazy_save_gs(prev->gs);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2005-09-04 05:56:39 +07:00
|
|
|
* Load the per-thread Thread-Local Storage descriptor.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2005-09-04 05:56:39 +07:00
|
|
|
load_TLS(next, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-02-13 19:26:21 +07:00
|
|
|
/*
|
|
|
|
* Restore IOPL if needed. In normal use, the flags restore
|
|
|
|
* in the switch assembly will handle this. But if the kernel
|
|
|
|
* is running virtualized at a non-zero CPL, the popf will
|
|
|
|
* not restore flags, so it must be done in a separate step.
|
|
|
|
*/
|
|
|
|
if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
|
|
|
|
set_iopl_mask(next->iopl);
|
|
|
|
|
2018-11-26 01:33:47 +07:00
|
|
|
switch_to_extra(prev_p, next_p);
|
2005-06-28 04:36:36 +07:00
|
|
|
|
2007-02-13 19:26:21 +07:00
|
|
|
/*
|
|
|
|
* Leave lazy mode, flushing any hypercalls made here.
|
|
|
|
* This must be done before restoring TLS segments so
|
|
|
|
* the GDT and LDT are properly updated, and must be
|
2015-04-22 18:16:47 +07:00
|
|
|
* done before fpu__restore(), so the TS bit is up
|
2007-02-13 19:26:21 +07:00
|
|
|
* to date.
|
|
|
|
*/
|
2009-02-19 02:18:57 +07:00
|
|
|
arch_end_context_switch(next_p);
|
2007-02-13 19:26:21 +07:00
|
|
|
|
2015-03-07 08:50:18 +07:00
|
|
|
/*
|
2015-04-24 22:31:34 +07:00
|
|
|
* Reload esp0 and cpu_current_top_of_stack. This changes
|
2017-11-02 14:59:09 +07:00
|
|
|
* current_thread_info(). Refresh the SYSENTER configuration in
|
|
|
|
* case prev or next is vm86.
|
2015-03-07 08:50:18 +07:00
|
|
|
*/
|
2018-07-18 16:40:51 +07:00
|
|
|
update_task_stack(next_p);
|
2017-11-02 14:59:09 +07:00
|
|
|
refresh_sysenter_cs(next);
|
2015-03-07 08:50:19 +07:00
|
|
|
this_cpu_write(cpu_current_top_of_stack,
|
|
|
|
(unsigned long)task_stack_page(next_p) +
|
|
|
|
THREAD_SIZE);
|
2014-02-06 21:41:31 +07:00
|
|
|
|
2007-02-13 19:26:21 +07:00
|
|
|
/*
|
|
|
|
* Restore %gs if needed (which is common)
|
|
|
|
*/
|
|
|
|
if (prev->gs | next->gs)
|
2009-02-09 20:17:40 +07:00
|
|
|
lazy_load_gs(next->gs);
|
2007-02-13 19:26:21 +07:00
|
|
|
|
2016-10-14 19:15:31 +07:00
|
|
|
switch_fpu_finish(next_fpu, cpu);
|
i387: re-introduce FPU state preloading at context switch time
After all the FPU state cleanups and finally finding the problem that
caused all our FPU save/restore problems, this re-introduces the
preloading of FPU state that was removed in commit b3b0870ef3ff ("i387:
do not preload FPU state at task switch time").
However, instead of simply reverting the removal, this reimplements
preloading with several fixes, most notably
- properly abstracted as a true FPU state switch, rather than as
open-coded save and restore with various hacks.
In particular, implementing it as a proper FPU state switch allows us
to optimize the CR0.TS flag accesses: there is no reason to set the
TS bit only to then almost immediately clear it again. CR0 accesses
are quite slow and expensive, don't flip the bit back and forth for
no good reason.
- Make sure that the same model works for both x86-32 and x86-64, so
that there are no gratuitous differences between the two due to the
way they save and restore segment state differently due to
architectural differences that really don't matter to the FPU state.
- Avoid exposing the "preload" state to the context switch routines,
and in particular allow the concept of lazy state restore: if nothing
else has used the FPU in the meantime, and the process is still on
the same CPU, we can avoid restoring state from memory entirely, just
re-expose the state that is still in the FPU unit.
That optimized lazy restore isn't actually implemented here, but the
infrastructure is set up for it. Of course, older CPU's that use
'fnsave' to save the state cannot take advantage of this, since the
state saving also trashes the state.
In other words, there is now an actual _design_ to the FPU state saving,
rather than just random historical baggage. Hopefully it's easier to
follow as a result.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-02-19 03:56:35 +07:00
|
|
|
|
2012-05-11 14:35:27 +07:00
|
|
|
this_cpu_write(current_task, next_p);
|
2007-02-13 19:26:21 +07:00
|
|
|
|
2016-10-29 05:04:48 +07:00
|
|
|
/* Load the Intel cache allocation PQR MSR. */
|
2018-11-22 03:28:27 +07:00
|
|
|
resctrl_sched_in();
|
2016-10-29 05:04:48 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return prev_p;
|
|
|
|
}
|
2017-03-20 15:16:24 +07:00
|
|
|
|
|
|
|
SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
|
|
|
|
{
|
|
|
|
return do_arch_prctl_common(current, option, arg2);
|
|
|
|
}
|