Merge branch 'x86-fpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull fpu state cleanups from Ingo Molnar: "This tree streamlines further aspects of FPU handling by eliminating the prepare_to_copy() complication and moving that logic to arch_dup_task_struct(). It also fixes the FPU dumps in threaded core dumps, removes and old (and now invalid) assumption plus micro-optimizes the exit path by avoiding an FPU save for dead tasks." Fixed up trivial add-add conflict in arch/sh/kernel/process.c that came in because we now do the FPU handling in arch_dup_task_struct() rather than the legacy (and now gone) prepare_to_copy(). * 'x86-fpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: x86, fpu: drop the fpu state during thread exit x86, xsave: remove thread_has_fpu() bug check in __sanitize_i387_state() coredump: ensure the fpu state is flushed for proper multi-threaded core dump fork: move the real prepare_to_copy() users to arch_dup_task_struct()
This commit is contained in:
Коммит
ec0d7f18ab
|
@ -49,9 +49,6 @@ extern void start_thread(struct pt_regs *, unsigned long, unsigned long);
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
/* Create a kernel thread without removing it from tasklists. */
|
||||
extern long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
|
||||
|
||||
|
|
|
@ -77,9 +77,6 @@ struct task_struct;
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
unsigned long get_wchan(struct task_struct *p);
|
||||
|
||||
#if __LINUX_ARM_ARCH__ == 6 || defined(CONFIG_ARM_ERRATA_754327)
|
||||
|
|
|
@ -145,9 +145,6 @@ extern void release_thread(struct task_struct *);
|
|||
/* Create a kernel thread without removing it from tasklists */
|
||||
extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while(0)
|
||||
|
||||
/* Return saved PC of a blocked thread */
|
||||
#define thread_saved_pc(tsk) ((tsk)->thread.cpu_context.pc)
|
||||
|
||||
|
|
|
@ -75,8 +75,6 @@ static inline void release_thread(struct task_struct *dead_task)
|
|||
{
|
||||
}
|
||||
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern int kernel_thread(int (*fn) (void *), void *arg, unsigned long flags);
|
||||
|
||||
/*
|
||||
|
|
|
@ -92,9 +92,6 @@ static inline void release_thread(struct task_struct *dead_task)
|
|||
{
|
||||
}
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
#define copy_segments(tsk, mm) do { } while (0)
|
||||
|
|
|
@ -49,10 +49,6 @@ struct task_struct;
|
|||
#define task_pt_regs(task) user_regs(task_thread_info(task))
|
||||
#define current_regs() task_pt_regs(current)
|
||||
|
||||
static inline void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
}
|
||||
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
unsigned long get_wchan(struct task_struct *p);
|
||||
|
|
|
@ -103,8 +103,6 @@ do { \
|
|||
__frame->sp = (_usp); \
|
||||
} while(0)
|
||||
|
||||
extern void prepare_to_copy(struct task_struct *tsk);
|
||||
|
||||
/* Free all resources held by a thread. */
|
||||
static inline void release_thread(struct task_struct *dead_task)
|
||||
{
|
||||
|
|
|
@ -165,17 +165,6 @@ asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
|
|||
return do_fork(clone_flags, newsp, __frame, 0, parent_tidptr, child_tidptr);
|
||||
} /* end sys_clone() */
|
||||
|
||||
/*****************************************************************************/
|
||||
/*
|
||||
* This gets called before we allocate a new thread and copy
|
||||
* the current task into it.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
//unlazy_fpu(tsk);
|
||||
} /* end prepare_to_copy() */
|
||||
|
||||
/*****************************************************************************/
|
||||
/*
|
||||
* set up the kernel stack and exception frames for a new process
|
||||
*/
|
||||
|
|
|
@ -109,8 +109,6 @@ static inline void release_thread(struct task_struct *dead_task)
|
|||
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
/*
|
||||
* Free current thread data structures etc..
|
||||
*/
|
||||
|
|
|
@ -58,13 +58,6 @@ struct thread_struct {
|
|||
|
||||
#define cpu_relax() __vmyield()
|
||||
|
||||
/*
|
||||
* "Unlazying all lazy status" occurs here.
|
||||
*/
|
||||
static inline void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Decides where the kernel will search for a free chunk of vm space during
|
||||
* mmaps.
|
||||
|
|
|
@ -343,9 +343,6 @@ struct task_struct;
|
|||
*/
|
||||
#define release_thread(dead_task)
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
/*
|
||||
* This is the mechanism for creating a new kernel thread.
|
||||
*
|
||||
|
|
|
@ -118,8 +118,6 @@ struct mm_struct;
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
/*
|
||||
* create a kernel thread without removing it from tasklists
|
||||
*/
|
||||
|
|
|
@ -153,9 +153,6 @@ static inline void release_thread(struct task_struct *dead_task)
|
|||
{
|
||||
}
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
/*
|
||||
|
|
|
@ -23,7 +23,6 @@ extern const struct seq_operations cpuinfo_op;
|
|||
|
||||
# define cpu_relax() barrier()
|
||||
# define cpu_sleep() do {} while (0)
|
||||
# define prepare_to_copy(tsk) do {} while (0)
|
||||
|
||||
#define task_pt_regs(tsk) \
|
||||
(((struct pt_regs *)(THREAD_SIZE + task_stack_page(tsk))) - 1)
|
||||
|
|
|
@ -310,9 +310,6 @@ struct task_struct;
|
|||
/* Free all resources held by a thread. */
|
||||
#define release_thread(thread) do { } while(0)
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
extern unsigned long thread_saved_pc(struct task_struct *tsk);
|
||||
|
|
|
@ -139,9 +139,6 @@ static inline void start_thread(struct pt_regs *regs,
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
extern void prepare_to_copy(struct task_struct *tsk);
|
||||
|
||||
/*
|
||||
* create a kernel thread without removing it from tasklists
|
||||
*/
|
||||
|
|
|
@ -208,12 +208,14 @@ void copy_segments(struct task_struct *p, struct mm_struct *new_mm)
|
|||
}
|
||||
|
||||
/*
|
||||
* this gets called before we allocate a new thread and copy the current task
|
||||
* into it so that we can store lazy state into memory
|
||||
* this gets called so that we can store lazy state into memory and copy the
|
||||
* current task into the new thread.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
unlazy_fpu(tsk);
|
||||
unlazy_fpu(src);
|
||||
*dst = *src;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -72,10 +72,6 @@ struct thread_struct {
|
|||
#define task_pt_regs(task) user_regs(task_thread_info(task))
|
||||
#define current_regs() user_regs(current_thread_info())
|
||||
|
||||
extern inline void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
}
|
||||
|
||||
#define INIT_SP (sizeof(init_stack) + (unsigned long) &init_stack)
|
||||
|
||||
#define INIT_THREAD { }
|
||||
|
|
|
@ -328,9 +328,6 @@ struct mm_struct;
|
|||
extern void release_thread(struct task_struct *);
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern void map_hpux_gateway_page(struct task_struct *tsk, struct mm_struct *mm);
|
||||
|
||||
extern unsigned long get_wchan(struct task_struct *p);
|
||||
|
|
|
@ -74,9 +74,6 @@ struct task_struct;
|
|||
void start_thread(struct pt_regs *regs, unsigned long fdptr, unsigned long sp);
|
||||
void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
extern void prepare_to_copy(struct task_struct *tsk);
|
||||
|
||||
/* Create a new kernel thread. */
|
||||
extern long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
|
||||
|
||||
|
|
|
@ -711,18 +711,21 @@ release_thread(struct task_struct *t)
|
|||
}
|
||||
|
||||
/*
|
||||
* This gets called before we allocate a new thread and copy
|
||||
* the current task into it.
|
||||
* this gets called so that we can store coprocessor state into memory and
|
||||
* copy the current task into the new thread.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
flush_fp_to_thread(current);
|
||||
flush_altivec_to_thread(current);
|
||||
flush_vsx_to_thread(current);
|
||||
flush_spe_to_thread(current);
|
||||
flush_fp_to_thread(src);
|
||||
flush_altivec_to_thread(src);
|
||||
flush_vsx_to_thread(src);
|
||||
flush_spe_to_thread(src);
|
||||
#ifdef CONFIG_HAVE_HW_BREAKPOINT
|
||||
flush_ptrace_hw_breakpoint(tsk);
|
||||
flush_ptrace_hw_breakpoint(src);
|
||||
#endif /* CONFIG_HAVE_HW_BREAKPOINT */
|
||||
|
||||
*dst = *src;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -141,9 +141,6 @@ struct seq_file;
|
|||
extern void release_thread(struct task_struct *);
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
/*
|
||||
* Return saved PC of a blocked thread.
|
||||
*/
|
||||
|
|
|
@ -26,7 +26,6 @@ extern unsigned long get_wchan(struct task_struct *p);
|
|||
|
||||
#define cpu_relax() barrier()
|
||||
#define release_thread(thread) do {} while (0)
|
||||
#define prepare_to_copy(tsk) do {} while (0)
|
||||
|
||||
/*
|
||||
* User space process size: 2GB. This is hardcoded into a few places,
|
||||
|
|
|
@ -126,9 +126,6 @@ extern void start_thread(struct pt_regs *regs, unsigned long new_pc, unsigned lo
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
void prepare_to_copy(struct task_struct *tsk);
|
||||
|
||||
/*
|
||||
* create a kernel thread without removing it from tasklists
|
||||
*/
|
||||
|
|
|
@ -169,7 +169,6 @@ extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
|||
#define copy_segments(p, mm) do { } while (0)
|
||||
#define release_segments(mm) do { } while (0)
|
||||
#define forget_segments() do { } while (0)
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
/*
|
||||
* FPU lazy state save handling.
|
||||
*/
|
||||
|
|
|
@ -13,8 +13,15 @@ unsigned long __stack_chk_guard __read_mostly;
|
|||
EXPORT_SYMBOL(__stack_chk_guard);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* this gets called so that we can store lazy state into memory and copy the
|
||||
* current task into the new thread.
|
||||
*/
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
#ifdef CONFIG_SUPERH32
|
||||
unlazy_fpu(src, task_pt_regs(src));
|
||||
#endif
|
||||
*dst = *src;
|
||||
|
||||
if (src->thread.xstate) {
|
||||
|
|
|
@ -156,15 +156,6 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
|
|||
}
|
||||
EXPORT_SYMBOL(dump_fpu);
|
||||
|
||||
/*
|
||||
* This gets called before we allocate a new thread and copy
|
||||
* the current task into it.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
unlazy_fpu(tsk, task_pt_regs(tsk));
|
||||
}
|
||||
|
||||
asmlinkage void ret_from_fork(void);
|
||||
|
||||
int copy_thread(unsigned long clone_flags, unsigned long usp,
|
||||
|
|
|
@ -108,9 +108,6 @@ static inline void start_thread(struct pt_regs * regs, unsigned long pc,
|
|||
#define release_thread(tsk) do { } while(0)
|
||||
extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern unsigned long get_wchan(struct task_struct *);
|
||||
|
||||
#define task_pt_regs(tsk) ((tsk)->thread.kregs)
|
||||
|
|
|
@ -186,9 +186,6 @@ do { \
|
|||
/* Free all resources held by a thread. */
|
||||
#define release_thread(tsk) do { } while (0)
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
extern unsigned long get_wchan(struct task_struct *task);
|
||||
|
|
|
@ -210,9 +210,6 @@ static inline void release_thread(struct task_struct *dead_task)
|
|||
/* Nothing for now */
|
||||
}
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status. */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
|
||||
|
||||
extern int do_work_pending(struct pt_regs *regs, u32 flags);
|
||||
|
|
|
@ -74,11 +74,6 @@ static inline void release_thread(struct task_struct *task)
|
|||
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
static inline void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
extern unsigned long thread_saved_pc(struct task_struct *t);
|
||||
|
||||
static inline void mm_copy_segments(struct mm_struct *from_mm,
|
||||
|
|
|
@ -68,9 +68,6 @@ struct task_struct;
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
#define prepare_to_copy(tsk) do { } while (0)
|
||||
|
||||
unsigned long get_wchan(struct task_struct *p);
|
||||
|
||||
#define cpu_relax() barrier()
|
||||
|
|
|
@ -579,9 +579,6 @@ extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
|
|||
/* Free all resources held by a thread. */
|
||||
extern void release_thread(struct task_struct *);
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy state */
|
||||
extern void prepare_to_copy(struct task_struct *tsk);
|
||||
|
||||
unsigned long get_wchan(struct task_struct *p);
|
||||
|
||||
/*
|
||||
|
|
|
@ -56,10 +56,16 @@ EXPORT_SYMBOL_GPL(idle_notifier_unregister);
|
|||
struct kmem_cache *task_xstate_cachep;
|
||||
EXPORT_SYMBOL_GPL(task_xstate_cachep);
|
||||
|
||||
/*
|
||||
* this gets called so that we can store lazy state into memory and copy the
|
||||
* current task into the new thread.
|
||||
*/
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
int ret;
|
||||
|
||||
unlazy_fpu(src);
|
||||
|
||||
*dst = *src;
|
||||
if (fpu_allocated(&src->thread.fpu)) {
|
||||
memset(&dst->thread.fpu, 0, sizeof(dst->thread.fpu));
|
||||
|
@ -89,6 +95,16 @@ void arch_task_cache_init(void)
|
|||
SLAB_PANIC | SLAB_NOTRACK, NULL);
|
||||
}
|
||||
|
||||
static inline void drop_fpu(struct task_struct *tsk)
|
||||
{
|
||||
/*
|
||||
* Forget coprocessor state..
|
||||
*/
|
||||
tsk->fpu_counter = 0;
|
||||
clear_fpu(tsk);
|
||||
clear_used_math();
|
||||
}
|
||||
|
||||
/*
|
||||
* Free current thread data structures etc..
|
||||
*/
|
||||
|
@ -111,6 +127,8 @@ void exit_thread(void)
|
|||
put_cpu();
|
||||
kfree(bp);
|
||||
}
|
||||
|
||||
drop_fpu(me);
|
||||
}
|
||||
|
||||
void show_regs_common(void)
|
||||
|
@ -145,12 +163,7 @@ void flush_thread(void)
|
|||
|
||||
flush_ptrace_hw_breakpoint(tsk);
|
||||
memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
|
||||
/*
|
||||
* Forget coprocessor state..
|
||||
*/
|
||||
tsk->fpu_counter = 0;
|
||||
clear_fpu(tsk);
|
||||
clear_used_math();
|
||||
drop_fpu(tsk);
|
||||
}
|
||||
|
||||
static void hard_disable_TSC(void)
|
||||
|
|
|
@ -126,15 +126,6 @@ void release_thread(struct task_struct *dead_task)
|
|||
release_vm86_irqs(dead_task);
|
||||
}
|
||||
|
||||
/*
|
||||
* This gets called before we allocate a new thread and copy
|
||||
* the current task into it.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
unlazy_fpu(tsk);
|
||||
}
|
||||
|
||||
int copy_thread(unsigned long clone_flags, unsigned long sp,
|
||||
unsigned long unused,
|
||||
struct task_struct *p, struct pt_regs *regs)
|
||||
|
|
|
@ -145,15 +145,6 @@ static inline u32 read_32bit_tls(struct task_struct *t, int tls)
|
|||
return get_desc_base(&t->thread.tls_array[tls]);
|
||||
}
|
||||
|
||||
/*
|
||||
* This gets called before we allocate a new thread and copy
|
||||
* the current task into it.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
{
|
||||
unlazy_fpu(tsk);
|
||||
}
|
||||
|
||||
int copy_thread(unsigned long clone_flags, unsigned long sp,
|
||||
unsigned long unused,
|
||||
struct task_struct *p, struct pt_regs *regs)
|
||||
|
|
|
@ -48,8 +48,6 @@ void __sanitize_i387_state(struct task_struct *tsk)
|
|||
if (!fx)
|
||||
return;
|
||||
|
||||
BUG_ON(__thread_has_fpu(tsk));
|
||||
|
||||
xstate_bv = tsk->thread.fpu.state->xsave.xsave_hdr.xstate_bv;
|
||||
|
||||
/*
|
||||
|
|
|
@ -168,9 +168,6 @@ struct mm_struct;
|
|||
/* Free all resources held by a thread. */
|
||||
#define release_thread(thread) do { } while(0)
|
||||
|
||||
/* Prepare to copy thread state - unlazy all lazy status */
|
||||
extern void prepare_to_copy(struct task_struct*);
|
||||
|
||||
/* Create a kernel thread without removing it from tasklists */
|
||||
extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
|
||||
|
||||
|
|
|
@ -140,13 +140,16 @@ void flush_thread(void)
|
|||
}
|
||||
|
||||
/*
|
||||
* This is called before the thread is copied.
|
||||
* this gets called so that we can store coprocessor state into memory and
|
||||
* copy the current task into the new thread.
|
||||
*/
|
||||
void prepare_to_copy(struct task_struct *tsk)
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
#if XTENSA_HAVE_COPROCESSORS
|
||||
coprocessor_flush_all(task_thread_info(tsk));
|
||||
coprocessor_flush_all(task_thread_info(src));
|
||||
#endif
|
||||
*dst = *src;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
15
fs/exec.c
15
fs/exec.c
|
@ -1938,8 +1938,21 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
|
|||
core_waiters = zap_threads(tsk, mm, core_state, exit_code);
|
||||
up_write(&mm->mmap_sem);
|
||||
|
||||
if (core_waiters > 0)
|
||||
if (core_waiters > 0) {
|
||||
struct core_thread *ptr;
|
||||
|
||||
wait_for_completion(&core_state->startup);
|
||||
/*
|
||||
* Wait for all the threads to become inactive, so that
|
||||
* all the thread context (extended register state, like
|
||||
* fpu etc) gets copied to the memory.
|
||||
*/
|
||||
ptr = core_state->dumper.next;
|
||||
while (ptr != NULL) {
|
||||
wait_task_inactive(ptr->task, 0);
|
||||
ptr = ptr->next;
|
||||
}
|
||||
}
|
||||
|
||||
return core_waiters;
|
||||
}
|
||||
|
|
|
@ -292,8 +292,6 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
|
|||
int node = tsk_fork_get_node(orig);
|
||||
int err;
|
||||
|
||||
prepare_to_copy(orig);
|
||||
|
||||
tsk = alloc_task_struct_node(node);
|
||||
if (!tsk)
|
||||
return NULL;
|
||||
|
|
Загрузка…
Ссылка в новой задаче