process.c (851462444d421c223965b12b836bef63da61b57f) process.c (20ecc91c3230b747cd13d9a2f43a45f6445a3906)
1/*
2 * linux/arch/m68k/kernel/process.c
3 *
4 * Copyright (C) 1995 Hamish Macdonald
5 *
6 * 68060 fixes by Jesper Skov
7 */
8

--- 122 unchanged lines hidden (view full) ---

131 if (!FPU_IS_EMU) {
132 unsigned long zero = 0;
133 asm volatile("frestore %0": :"m" (zero));
134 }
135#endif
136}
137
138/*
1/*
2 * linux/arch/m68k/kernel/process.c
3 *
4 * Copyright (C) 1995 Hamish Macdonald
5 *
6 * 68060 fixes by Jesper Skov
7 */
8

--- 122 unchanged lines hidden (view full) ---

131 if (!FPU_IS_EMU) {
132 unsigned long zero = 0;
133 asm volatile("frestore %0": :"m" (zero));
134 }
135#endif
136}
137
138/*
139 * "m68k_fork()".. By the time we get here, the
140 * non-volatile registers have also been saved on the
141 * stack. We do some ugly pointer stuff here.. (see
142 * also copy_thread)
139 * Why not generic sys_clone, you ask? m68k passes all arguments on stack.
140 * And we need all registers saved, which means a bunch of stuff pushed
141 * on top of pt_regs, which means that sys_clone() arguments would be
142 * buried. We could, of course, copy them, but it's too costly for no
143 * good reason - generic clone() would have to copy them *again* for
144 * do_fork() anyway. So in this case it's actually better to pass pt_regs *
145 * and extract arguments for do_fork() from there. Eventually we might
146 * go for calling do_fork() directly from the wrapper, but only after we
147 * are finished with do_fork() prototype conversion.
143 */
148 */
144
145asmlinkage int m68k_fork(struct pt_regs *regs)
146{
147#ifdef CONFIG_MMU
148 return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
149#else
150 return -EINVAL;
151#endif
152}
153
154asmlinkage int m68k_vfork(struct pt_regs *regs)
155{
156 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0,
157 NULL, NULL);
158}
159
160asmlinkage int m68k_clone(struct pt_regs *regs)
161{
149asmlinkage int m68k_clone(struct pt_regs *regs)
150{
162 unsigned long clone_flags;
163 unsigned long newsp;
164 int __user *parent_tidptr, *child_tidptr;
165
166 /* syscall2 puts clone_flags in d1 and usp in d2 */
167 clone_flags = regs->d1;
168 newsp = regs->d2;
169 parent_tidptr = (int __user *)regs->d3;
170 child_tidptr = (int __user *)regs->d4;
171 if (!newsp)
172 newsp = rdusp();
173 return do_fork(clone_flags, newsp, regs, 0,
174 parent_tidptr, child_tidptr);
151 /* regs will be equal to current_pt_regs() */
152 return do_fork(regs->d1, regs->d2, regs, 0,
153 (int __user *)regs->d3, (int __user *)regs->d4);
175}
176
177int copy_thread(unsigned long clone_flags, unsigned long usp,
178 unsigned long arg,
154}
155
156int copy_thread(unsigned long clone_flags, unsigned long usp,
157 unsigned long arg,
179 struct task_struct * p, struct pt_regs * regs)
158 struct task_struct * p, struct pt_regs * unused)
180{
159{
181 struct pt_regs * childregs;
182 struct switch_stack *childstack;
160 struct fork_frame {
161 struct switch_stack sw;
162 struct pt_regs regs;
163 } *frame;
183
164
184 childregs = (struct pt_regs *) (task_stack_page(p) + THREAD_SIZE) - 1;
185 childstack = ((struct switch_stack *) childregs) - 1;
165 frame = (struct fork_frame *) (task_stack_page(p) + THREAD_SIZE) - 1;
186
166
187 p->thread.usp = usp;
188 p->thread.ksp = (unsigned long)childstack;
189 p->thread.esp0 = (unsigned long)childregs;
167 p->thread.ksp = (unsigned long)frame;
168 p->thread.esp0 = (unsigned long)&frame->regs;
190
191 /*
192 * Must save the current SFC/DFC value, NOT the value when
193 * the parent was last descheduled - RGH 10-08-96
194 */
195 p->thread.fs = get_fs().seg;
196
169
170 /*
171 * Must save the current SFC/DFC value, NOT the value when
172 * the parent was last descheduled - RGH 10-08-96
173 */
174 p->thread.fs = get_fs().seg;
175
197 if (unlikely(!regs)) {
176 if (unlikely(p->flags & PF_KTHREAD)) {
198 /* kernel thread */
177 /* kernel thread */
199 memset(childstack, 0,
200 sizeof(struct switch_stack) + sizeof(struct pt_regs));
201 childregs->sr = PS_S;
202 childstack->a3 = usp; /* function */
203 childstack->d7 = arg;
204 childstack->retpc = (unsigned long)ret_from_kernel_thread;
178 memset(frame, 0, sizeof(struct fork_frame));
179 frame->regs.sr = PS_S;
180 frame->sw.a3 = usp; /* function */
181 frame->sw.d7 = arg;
182 frame->sw.retpc = (unsigned long)ret_from_kernel_thread;
205 p->thread.usp = 0;
206 return 0;
207 }
183 p->thread.usp = 0;
184 return 0;
185 }
208 *childregs = *regs;
209 childregs->d0 = 0;
186 memcpy(frame, container_of(current_pt_regs(), struct fork_frame, regs),
187 sizeof(struct fork_frame));
188 frame->regs.d0 = 0;
189 frame->sw.retpc = (unsigned long)ret_from_fork;
190 p->thread.usp = usp ?: rdusp();
210
191
211 *childstack = ((struct switch_stack *) regs)[-1];
212 childstack->retpc = (unsigned long)ret_from_fork;
213
214 if (clone_flags & CLONE_SETTLS)
192 if (clone_flags & CLONE_SETTLS)
215 task_thread_info(p)->tp_value = regs->d5;
193 task_thread_info(p)->tp_value = frame->regs.d5;
216
217#ifdef CONFIG_FPU
218 if (!FPU_IS_EMU) {
219 /* Copy the current fpu state */
220 asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory");
221
222 if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2]) {
223 if (CPU_IS_COLDFIRE) {

--- 101 unchanged lines hidden --- 		194
195#ifdef CONFIG_FPU
196 if (!FPU_IS_EMU) {
197 /* Copy the current fpu state */
198 asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory");
199
200 if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2]) {
201 if (CPU_IS_COLDFIRE) {

--- 101 unchanged lines hidden ---