fork: move the real prepare_to_copy() users to arch_dup_task_struct()
authorSuresh Siddha <suresh.b.siddha@intel.com>
Wed, 16 May 2012 22:03:51 +0000 (15:03 -0700)
committerH. Peter Anvin <hpa@linux.intel.com>
Wed, 16 May 2012 22:16:26 +0000 (15:16 -0700)
Historical prepare_to_copy() is mostly a no-op, duplicated for majority of
the architectures and the rest following the x86 model of flushing the extended
register state like fpu there.

Remove it and use the arch_dup_task_struct() instead.

Suggested-by: Oleg Nesterov <oleg@redhat.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Link: http://lkml.kernel.org/r/1336692811-30576-1-git-send-email-suresh.b.siddha@intel.com
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Koichi Yasutake <yasutake.koichi@jp.panasonic.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Chris Zankel <chris@zankel.net>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Haavard Skinnemoen <hskinnemoen@gmail.com>
Cc: Mike Frysinger <vapier@gentoo.org>
Cc: Mark Salter <msalter@redhat.com>
Cc: Aurelien Jacquiot <a-jacquiot@ti.com>
Cc: Mikael Starvik <starvik@axis.com>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Cc: Richard Kuo <rkuo@codeaurora.org>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: James E.J. Bottomley <jejb@parisc-linux.org>
Cc: Helge Deller <deller@gmx.de>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Chen Liqin <liqin.chen@sunplusct.com>
Cc: Lennox Wu <lennox.wu@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Chris Metcalf <cmetcalf@tilera.com>
Cc: Jeff Dike <jdike@addtoit.com>
Cc: Richard Weinberger <richard@nod.at>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
39 files changed:
arch/alpha/include/asm/processor.h
arch/arm/include/asm/processor.h
arch/avr32/include/asm/processor.h
arch/blackfin/include/asm/processor.h
arch/c6x/include/asm/processor.h
arch/cris/include/asm/processor.h
arch/frv/include/asm/processor.h
arch/frv/kernel/process.c
arch/h8300/include/asm/processor.h
arch/hexagon/include/asm/processor.h
arch/ia64/include/asm/processor.h
arch/m32r/include/asm/processor.h
arch/m68k/include/asm/processor.h
arch/microblaze/include/asm/processor.h
arch/mips/include/asm/processor.h
arch/mn10300/include/asm/processor.h
arch/mn10300/kernel/process.c
arch/openrisc/include/asm/processor.h
arch/parisc/include/asm/processor.h
arch/powerpc/include/asm/processor.h
arch/powerpc/kernel/process.c
arch/s390/include/asm/processor.h
arch/score/include/asm/processor.h
arch/sh/include/asm/processor_32.h
arch/sh/include/asm/processor_64.h
arch/sh/kernel/process.c
arch/sh/kernel/process_32.c
arch/sparc/include/asm/processor_32.h
arch/sparc/include/asm/processor_64.h
arch/tile/include/asm/processor.h
arch/um/include/asm/processor-generic.h
arch/unicore32/include/asm/processor.h
arch/x86/include/asm/processor.h
arch/x86/kernel/process.c
arch/x86/kernel/process_32.c
arch/x86/kernel/process_64.c
arch/xtensa/include/asm/processor.h
arch/xtensa/kernel/process.c
kernel/fork.c

index 94afe5859301f272eb6dedf7343f6e877f8fd77c..e37b887b3d9f636fdcb0b4615a8c648dfc3d364f 100644 (file)
@@ -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);
 
index 5ac8d3d3e0259cc8ceaa16b7ac7caa6facf177f7..6354224f980dd14f227382acfc827bad24a16e47 100644 (file)
@@ -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)
index 108502bc67706786d3125dff42be43f6a1d9b7d2..87d8baccc60e908c475c72dff993e4f5ec79a817 100644 (file)
@@ -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)
 
index 8af7772e84ccfdcfbba38d1b11eca4cad1926d45..4ef7cfe43cebce8441a88c5dc876f980760e65ef 100644 (file)
@@ -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);
 
 /*
index 3ff7fab956ba1c2158f087a59050f8c45006f25a..c50af7ef1c96a5538252474e6ab37681141583a5 100644 (file)
@@ -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)
index 4210d72a6667417075e3c7f9e31674aefb8e1d9e..37f522feabc1125162bfb41ded5a2f71974b8678 100644 (file)
@@ -50,10 +50,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);
index 81c2e271d620d90af8f55b9199ac3f1de773f850..9c768170b304026ffd4fade2003b0a0ef64cc16a 100644 (file)
@@ -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)
 {
index d4de48bd5efe4211990ec7530e25ad95e97819ad..9f3dfadee09e29ee4e18f0fc2b096e9c95855474 100644 (file)
@@ -180,17 +180,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
  */
index 61fabf1788c6b4e1a9c006d29a070b2b1bfb5904..4c9f6f87b6179f1c493ee3f2ed289dcda0a46bdc 100644 (file)
@@ -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..
  */
index 20c5ddabbd8b4297e224a0557f5ca89b6a50e4d7..e8ea459002a4cf6adfc824092c87b94a5cacc891 100644 (file)
@@ -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.
index 483f6c6a4238d176eb449953ce0f157c2232cb12..efcca1b601c57654521718b57eaeeb751d1451a9 100644 (file)
@@ -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.
  *
index e1f46d7574602aa5ca4f3934097fed74c94cb005..da17253b5735ba2d81b37e929f59126628449da7 100644 (file)
@@ -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
  */
index 46460fa15d5cc66cbc68f39a3016b596c03af2ad..f17c42aff7ffb9aa592aebf2e118d99309d8e699 100644 (file)
@@ -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);
 
 /*
index bffb545272997b54c2a0090b398618f83320662a..af2bb9652392e9ecb80980c51a0ebf2b3390e526 100644 (file)
@@ -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)
index 20e9dcf42b27461f0584f01f79cfc3c1bb385edc..5e33fabe354de7e12e11dc4f64aa5d0be7464090 100644 (file)
@@ -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);
index f7b3c9ab2cb581fed5a838dfed13b916f9abbf4f..247928c9f549ec239e1e5556a1c7157674833bba 100644 (file)
@@ -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
  */
index 14707f25153b15f46e97a4ad68ca5dc521bc1984..7dab0cd364663e9ab9b6c8418cf9da51a28525c3 100644 (file)
@@ -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;
 }
 
 /*
index f7516fa78b58a2e2311433f63a1a401d7de9d044..30462f1fe959298cdf492bd8c18e3879fce7a50f 100644 (file)
@@ -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  { }
index acdf4cad6125ae78203c60ce06337e6a9e0354cb..0e8b7b8ce8a25046830f28367b4d4eb84d9e0813 100644 (file)
@@ -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);
index 8e2d0371fe1e71f0460dc1e28f7ba2d2a193aec0..854f899d0c3484a9093e01a7760e45205c53075d 100644 (file)
@@ -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);
 
index 4937c9690090d0e9bf3809b7ae923ae24d181d93..bc129f24e11f1972112c6e738e9ea526adfde2d1 100644 (file)
@@ -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;
 }
 
 /*
index d499b30ea487107b339c252dff39bf3ae5c9dfe9..6cbf31311673a37bc83de2be5add15bbc42ece5e 100644 (file)
@@ -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.
  */
index 7e22f216d771ac93749ff5c1e876bd93c275eaf7..ab3aceb542094e7a80eda7158c96665ace799214 100644 (file)
@@ -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,
index 900f8d72ffe2d86e902e590d53b180d73871da7a..b6311fd2d066a1db774409f1dac29f2b856290e4 100644 (file)
@@ -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
  */
index e25c4c7d6b63171221e247cea5f6ee45136efaf7..fe99afecfbc57fed2044b6c8d4641dcc319e279b 100644 (file)
@@ -172,7 +172,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.
  */
index 325f98b1736d4a1ab8fdc93f54bcd7cb3674d298..2bde59eae10d70c698d11857fbfecb03243e3be8 100644 (file)
@@ -6,8 +6,15 @@
 struct kmem_cache *task_xstate_cachep = NULL;
 unsigned int xstate_size;
 
+/*
+ * 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) {
index 94273aaf78c1605da62d82ea61dc14a746ec5dff..dee596113cc154341092542ba1109e5f6698a481 100644 (file)
@@ -155,15 +155,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,
index 09521c6a5edb4ccd9ba320bf80b3fc497814f4e2..c9c760fdc71353cb4cad700382e6df0500aa4c8e 100644 (file)
@@ -109,9 +109,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)
index e713db249931fb3895cfcd842176187b8d948f71..67df5cc1001126cbc3fddaaabebc9e7e53e556f8 100644 (file)
@@ -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);
index 34c1e01ffb5e24648c4171fccedcd3257ef5e0da..15cd8a4a06ce1dc62170444629edc7c17d9da2ab 100644 (file)
@@ -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);
index 98d01bc4fa92f1267062645e31c9b632f74e2339..63b716052d20b74378adc542626aac66b2cfb928 100644 (file)
@@ -76,11 +76,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,
index f0d780a51f9b5dec74a5310fe0f1fd2c4fdc7b28..14382cb09657f67333f5a32f4d95910ae10e0b1d 100644 (file)
@@ -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()
index 4fa7dcceb6c084816346562bacdac4aa7098a9ee..97fe04318e95cad931f7b1f34869458509f66def 100644 (file)
@@ -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);
 
 /*
index 1d92a5ab6e8b939613d6bfd7221133df2496b482..b7e1e0e5398756a61bbad2d79b0a30e14ba64bfa 100644 (file)
@@ -47,10 +47,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));
index ae6847303e265c80c2199ab18884ee16e25bf386..2aa57dc909d66743d7ee6d8d7db8a41837c52fd4 100644 (file)
@@ -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)
index 43d8b48b23e61dc20afb3ddc0aed3308e7d92f2b..c4c0645a40110fd8e9bd302a0cae9e7e093d0d23 100644 (file)
@@ -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)
index 3acb26e8dead4d2336e1313333027b6e74461ed3..5c371d8d45284a1c35808d2b9e4928db03cc7652 100644 (file)
@@ -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);
 
index 6a2d6edf8f728af36bf4da4fc1587e79057bdf46..9b306e550e3f06ddfa342c041c7793543702c4b3 100644 (file)
@@ -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;
 }
 
 /*
index 687a15d562433ee60c5b19bf02f2e8652c6e4338..7aed746ff47c82a5532e73244a3c33e027cfe7ae 100644 (file)
@@ -261,8 +261,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;