2 * linux/arch/m68k/kernel/process.c
4 * Copyright (C) 1995 Hamish Macdonald
6 * 68060 fixes by Jesper Skov
10 * This file handles the architecture-dependent parts of process handling..
13 #include <linux/errno.h>
14 #include <linux/module.h>
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
18 #include <linux/slab.h>
20 #include <linux/smp.h>
21 #include <linux/stddef.h>
22 #include <linux/unistd.h>
23 #include <linux/ptrace.h>
24 #include <linux/user.h>
25 #include <linux/reboot.h>
26 #include <linux/init_task.h>
27 #include <linux/mqueue.h>
28 #include <linux/rcupdate.h>
30 #include <asm/uaccess.h>
31 #include <asm/traps.h>
32 #include <asm/machdep.h>
33 #include <asm/setup.h>
34 #include <asm/pgtable.h>
37 asmlinkage
void ret_from_fork(void);
38 asmlinkage
void ret_from_kernel_thread(void);
42 * Return saved PC from a blocked thread
44 unsigned long thread_saved_pc(struct task_struct
*tsk
)
46 struct switch_stack
*sw
= (struct switch_stack
*)tsk
->thread
.ksp
;
47 /* Check whether the thread is blocked in resume() */
48 if (in_sched_functions(sw
->retpc
))
49 return ((unsigned long *)sw
->a6
)[1];
55 * The idle loop on an m68k..
57 static void default_idle(void)
60 #if defined(MACH_ATARI_ONLY)
61 /* block out HSYNC on the atari (falcon) */
62 __asm__("stop #0x2200" : : : "cc");
64 __asm__("stop #0x2000" : : : "cc");
68 void (*idle
)(void) = default_idle
;
71 * The idle thread. There's no useful work to be
72 * done, so just try to conserve power and have a
73 * low exit latency (ie sit in a loop waiting for
74 * somebody to say that they'd like to reschedule)
78 /* endless idle loop with no priority at all */
81 while (!need_resched())
84 schedule_preempt_disabled();
88 void machine_restart(char * __unused
)
95 void machine_halt(void)
102 void machine_power_off(void)
109 void (*pm_power_off
)(void) = machine_power_off
;
110 EXPORT_SYMBOL(pm_power_off
);
112 void show_regs(struct pt_regs
* regs
)
115 printk("Format %02x Vector: %04x PC: %08lx Status: %04x %s\n",
116 regs
->format
, regs
->vector
, regs
->pc
, regs
->sr
, print_tainted());
117 printk("ORIG_D0: %08lx D0: %08lx A2: %08lx A1: %08lx\n",
118 regs
->orig_d0
, regs
->d0
, regs
->a2
, regs
->a1
);
119 printk("A0: %08lx D5: %08lx D4: %08lx\n",
120 regs
->a0
, regs
->d5
, regs
->d4
);
121 printk("D3: %08lx D2: %08lx D1: %08lx\n",
122 regs
->d3
, regs
->d2
, regs
->d1
);
123 if (!(regs
->sr
& PS_S
))
124 printk("USP: %08lx\n", rdusp());
127 void flush_thread(void)
129 current
->thread
.fs
= __USER_DS
;
132 unsigned long zero
= 0;
133 asm volatile("frestore %0": :"m" (zero
));
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.
149 asmlinkage
int m68k_clone(struct pt_regs
*regs
)
151 /* regs will be equal to current_pt_regs() */
152 return do_fork(regs
->d1
, regs
->d2
, 0,
153 (int __user
*)regs
->d3
, (int __user
*)regs
->d4
);
156 int copy_thread(unsigned long clone_flags
, unsigned long usp
,
157 unsigned long arg
, struct task_struct
*p
)
160 struct switch_stack sw
;
164 frame
= (struct fork_frame
*) (task_stack_page(p
) + THREAD_SIZE
) - 1;
166 p
->thread
.ksp
= (unsigned long)frame
;
167 p
->thread
.esp0
= (unsigned long)&frame
->regs
;
170 * Must save the current SFC/DFC value, NOT the value when
171 * the parent was last descheduled - RGH 10-08-96
173 p
->thread
.fs
= get_fs().seg
;
175 if (unlikely(p
->flags
& PF_KTHREAD
)) {
177 memset(frame
, 0, sizeof(struct fork_frame
));
178 frame
->regs
.sr
= PS_S
;
179 frame
->sw
.a3
= usp
; /* function */
181 frame
->sw
.retpc
= (unsigned long)ret_from_kernel_thread
;
185 memcpy(frame
, container_of(current_pt_regs(), struct fork_frame
, regs
),
186 sizeof(struct fork_frame
));
188 frame
->sw
.retpc
= (unsigned long)ret_from_fork
;
189 p
->thread
.usp
= usp
?: rdusp();
191 if (clone_flags
& CLONE_SETTLS
)
192 task_thread_info(p
)->tp_value
= frame
->regs
.d5
;
196 /* Copy the current fpu state */
197 asm volatile ("fsave %0" : : "m" (p
->thread
.fpstate
[0]) : "memory");
199 if (!CPU_IS_060
? p
->thread
.fpstate
[0] : p
->thread
.fpstate
[2]) {
200 if (CPU_IS_COLDFIRE
) {
201 asm volatile ("fmovemd %/fp0-%/fp7,%0\n\t"
202 "fmovel %/fpiar,%1\n\t"
203 "fmovel %/fpcr,%2\n\t"
206 : "m" (p
->thread
.fp
[0]),
207 "m" (p
->thread
.fpcntl
[0]),
208 "m" (p
->thread
.fpcntl
[1]),
209 "m" (p
->thread
.fpcntl
[2])
212 asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t"
213 "fmoveml %/fpiar/%/fpcr/%/fpsr,%1"
215 : "m" (p
->thread
.fp
[0]),
216 "m" (p
->thread
.fpcntl
[0])
221 /* Restore the state in case the fpu was busy */
222 asm volatile ("frestore %0" : : "m" (p
->thread
.fpstate
[0]));
224 #endif /* CONFIG_FPU */
229 /* Fill in the fpu structure for a core dump. */
231 int dump_fpu (struct pt_regs
*regs
, struct user_m68kfp_struct
*fpu
)
238 memcpy(fpu
->fpcntl
, current
->thread
.fpcntl
, 12);
239 memcpy(fpu
->fpregs
, current
->thread
.fp
, 96);
240 /* Convert internal fpu reg representation
241 * into long double format
243 for (i
= 0; i
< 24; i
+= 3)
244 fpu
->fpregs
[i
] = ((fpu
->fpregs
[i
] & 0xffff0000) << 15) |
245 ((fpu
->fpregs
[i
] & 0x0000ffff) << 16);
249 /* First dump the fpu context to avoid protocol violation. */
250 asm volatile ("fsave %0" :: "m" (fpustate
[0]) : "memory");
251 if (!CPU_IS_060
? !fpustate
[0] : !fpustate
[2])
254 if (CPU_IS_COLDFIRE
) {
255 asm volatile ("fmovel %/fpiar,%0\n\t"
256 "fmovel %/fpcr,%1\n\t"
257 "fmovel %/fpsr,%2\n\t"
258 "fmovemd %/fp0-%/fp7,%3"
260 : "m" (fpu
->fpcntl
[0]),
261 "m" (fpu
->fpcntl
[1]),
262 "m" (fpu
->fpcntl
[2]),
266 asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0"
268 : "m" (fpu
->fpcntl
[0])
270 asm volatile ("fmovemx %/fp0-%/fp7,%0"
272 : "m" (fpu
->fpregs
[0])
278 EXPORT_SYMBOL(dump_fpu
);
279 #endif /* CONFIG_FPU */
281 unsigned long get_wchan(struct task_struct
*p
)
283 unsigned long fp
, pc
;
284 unsigned long stack_page
;
286 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
289 stack_page
= (unsigned long)task_stack_page(p
);
290 fp
= ((struct switch_stack
*)p
->thread
.ksp
)->a6
;
292 if (fp
< stack_page
+sizeof(struct thread_info
) ||
293 fp
>= 8184+stack_page
)
295 pc
= ((unsigned long *)fp
)[1];
296 if (!in_sched_functions(pc
))
298 fp
= *(unsigned long *) fp
;
299 } while (count
++ < 16);
This page took 0.03946 seconds and 5 git commands to generate.