Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/m68k/kernel/process.c | |
3 | * | |
4 | * Copyright (C) 1995 Hamish Macdonald | |
5 | * | |
6 | * 68060 fixes by Jesper Skov | |
7 | */ | |
8 | ||
9 | /* | |
10 | * This file handles the architecture-dependent parts of process handling.. | |
11 | */ | |
12 | ||
1da177e4 LT |
13 | #include <linux/errno.h> |
14 | #include <linux/module.h> | |
15 | #include <linux/sched.h> | |
16 | #include <linux/kernel.h> | |
17 | #include <linux/mm.h> | |
4e950f6f | 18 | #include <linux/fs.h> |
1da177e4 LT |
19 | #include <linux/smp.h> |
20 | #include <linux/smp_lock.h> | |
21 | #include <linux/stddef.h> | |
22 | #include <linux/unistd.h> | |
23 | #include <linux/ptrace.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/user.h> | |
26 | #include <linux/a.out.h> | |
27 | #include <linux/reboot.h> | |
28 | #include <linux/init_task.h> | |
29 | #include <linux/mqueue.h> | |
30 | ||
31 | #include <asm/uaccess.h> | |
32 | #include <asm/system.h> | |
33 | #include <asm/traps.h> | |
34 | #include <asm/machdep.h> | |
35 | #include <asm/setup.h> | |
36 | #include <asm/pgtable.h> | |
37 | ||
38 | /* | |
39 | * Initial task/thread structure. Make this a per-architecture thing, | |
40 | * because different architectures tend to have different | |
41 | * alignment requirements and potentially different initial | |
42 | * setup. | |
43 | */ | |
44 | static struct fs_struct init_fs = INIT_FS; | |
45 | static struct files_struct init_files = INIT_FILES; | |
46 | static struct signal_struct init_signals = INIT_SIGNALS(init_signals); | |
47 | static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand); | |
48 | struct mm_struct init_mm = INIT_MM(init_mm); | |
49 | ||
50 | EXPORT_SYMBOL(init_mm); | |
51 | ||
52 | union thread_union init_thread_union | |
53 | __attribute__((section(".data.init_task"), aligned(THREAD_SIZE))) | |
54 | = { INIT_THREAD_INFO(init_task) }; | |
55 | ||
56 | /* initial task structure */ | |
57 | struct task_struct init_task = INIT_TASK(init_task); | |
58 | ||
59 | EXPORT_SYMBOL(init_task); | |
60 | ||
61 | asmlinkage void ret_from_fork(void); | |
62 | ||
63 | ||
64 | /* | |
65 | * Return saved PC from a blocked thread | |
66 | */ | |
67 | unsigned long thread_saved_pc(struct task_struct *tsk) | |
68 | { | |
69 | struct switch_stack *sw = (struct switch_stack *)tsk->thread.ksp; | |
70 | /* Check whether the thread is blocked in resume() */ | |
71 | if (in_sched_functions(sw->retpc)) | |
72 | return ((unsigned long *)sw->a6)[1]; | |
73 | else | |
74 | return sw->retpc; | |
75 | } | |
76 | ||
77 | /* | |
78 | * The idle loop on an m68k.. | |
79 | */ | |
cdb04527 | 80 | static void default_idle(void) |
1da177e4 LT |
81 | { |
82 | if (!need_resched()) | |
83 | #if defined(MACH_ATARI_ONLY) && !defined(CONFIG_HADES) | |
84 | /* block out HSYNC on the atari (falcon) */ | |
85 | __asm__("stop #0x2200" : : : "cc"); | |
86 | #else | |
87 | __asm__("stop #0x2000" : : : "cc"); | |
88 | #endif | |
89 | } | |
90 | ||
91 | void (*idle)(void) = default_idle; | |
92 | ||
93 | /* | |
94 | * The idle thread. There's no useful work to be | |
95 | * done, so just try to conserve power and have a | |
96 | * low exit latency (ie sit in a loop waiting for | |
97 | * somebody to say that they'd like to reschedule) | |
98 | */ | |
99 | void cpu_idle(void) | |
100 | { | |
101 | /* endless idle loop with no priority at all */ | |
102 | while (1) { | |
103 | while (!need_resched()) | |
104 | idle(); | |
5bfb5d69 | 105 | preempt_enable_no_resched(); |
1da177e4 | 106 | schedule(); |
5bfb5d69 | 107 | preempt_disable(); |
1da177e4 LT |
108 | } |
109 | } | |
110 | ||
111 | void machine_restart(char * __unused) | |
112 | { | |
113 | if (mach_reset) | |
114 | mach_reset(); | |
115 | for (;;); | |
116 | } | |
117 | ||
1da177e4 LT |
118 | void machine_halt(void) |
119 | { | |
120 | if (mach_halt) | |
121 | mach_halt(); | |
122 | for (;;); | |
123 | } | |
124 | ||
1da177e4 LT |
125 | void machine_power_off(void) |
126 | { | |
127 | if (mach_power_off) | |
128 | mach_power_off(); | |
129 | for (;;); | |
130 | } | |
131 | ||
cead14da AV |
132 | void (*pm_power_off)(void) = machine_power_off; |
133 | EXPORT_SYMBOL(pm_power_off); | |
134 | ||
1da177e4 LT |
135 | void show_regs(struct pt_regs * regs) |
136 | { | |
137 | printk("\n"); | |
138 | printk("Format %02x Vector: %04x PC: %08lx Status: %04x %s\n", | |
139 | regs->format, regs->vector, regs->pc, regs->sr, print_tainted()); | |
140 | printk("ORIG_D0: %08lx D0: %08lx A2: %08lx A1: %08lx\n", | |
141 | regs->orig_d0, regs->d0, regs->a2, regs->a1); | |
142 | printk("A0: %08lx D5: %08lx D4: %08lx\n", | |
143 | regs->a0, regs->d5, regs->d4); | |
144 | printk("D3: %08lx D2: %08lx D1: %08lx\n", | |
145 | regs->d3, regs->d2, regs->d1); | |
146 | if (!(regs->sr & PS_S)) | |
147 | printk("USP: %08lx\n", rdusp()); | |
148 | } | |
149 | ||
150 | /* | |
151 | * Create a kernel thread | |
152 | */ | |
153 | int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) | |
154 | { | |
155 | int pid; | |
156 | mm_segment_t fs; | |
157 | ||
158 | fs = get_fs(); | |
159 | set_fs (KERNEL_DS); | |
160 | ||
161 | { | |
162 | register long retval __asm__ ("d0"); | |
163 | register long clone_arg __asm__ ("d1") = flags | CLONE_VM | CLONE_UNTRACED; | |
164 | ||
165 | retval = __NR_clone; | |
166 | __asm__ __volatile__ | |
167 | ("clrl %%d2\n\t" | |
168 | "trap #0\n\t" /* Linux/m68k system call */ | |
169 | "tstl %0\n\t" /* child or parent */ | |
170 | "jne 1f\n\t" /* parent - jump */ | |
171 | "lea %%sp@(%c7),%6\n\t" /* reload current */ | |
172 | "movel %6@,%6\n\t" | |
173 | "movel %3,%%sp@-\n\t" /* push argument */ | |
174 | "jsr %4@\n\t" /* call fn */ | |
175 | "movel %0,%%d1\n\t" /* pass exit value */ | |
176 | "movel %2,%%d0\n\t" /* exit */ | |
177 | "trap #0\n" | |
178 | "1:" | |
179 | : "+d" (retval) | |
180 | : "i" (__NR_clone), "i" (__NR_exit), | |
181 | "r" (arg), "a" (fn), "d" (clone_arg), "r" (current), | |
182 | "i" (-THREAD_SIZE) | |
183 | : "d2"); | |
184 | ||
185 | pid = retval; | |
186 | } | |
187 | ||
188 | set_fs (fs); | |
189 | return pid; | |
190 | } | |
2e811488 | 191 | EXPORT_SYMBOL(kernel_thread); |
1da177e4 LT |
192 | |
193 | void flush_thread(void) | |
194 | { | |
195 | unsigned long zero = 0; | |
196 | set_fs(USER_DS); | |
197 | current->thread.fs = __USER_DS; | |
198 | if (!FPU_IS_EMU) | |
199 | asm volatile (".chip 68k/68881\n\t" | |
200 | "frestore %0@\n\t" | |
201 | ".chip 68k" : : "a" (&zero)); | |
202 | } | |
203 | ||
204 | /* | |
205 | * "m68k_fork()".. By the time we get here, the | |
206 | * non-volatile registers have also been saved on the | |
207 | * stack. We do some ugly pointer stuff here.. (see | |
208 | * also copy_thread) | |
209 | */ | |
210 | ||
211 | asmlinkage int m68k_fork(struct pt_regs *regs) | |
212 | { | |
213 | return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL); | |
214 | } | |
215 | ||
216 | asmlinkage int m68k_vfork(struct pt_regs *regs) | |
217 | { | |
218 | return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, | |
219 | NULL, NULL); | |
220 | } | |
221 | ||
222 | asmlinkage int m68k_clone(struct pt_regs *regs) | |
223 | { | |
224 | unsigned long clone_flags; | |
225 | unsigned long newsp; | |
1e5c374d | 226 | int __user *parent_tidptr, *child_tidptr; |
1da177e4 LT |
227 | |
228 | /* syscall2 puts clone_flags in d1 and usp in d2 */ | |
229 | clone_flags = regs->d1; | |
230 | newsp = regs->d2; | |
1e5c374d AV |
231 | parent_tidptr = (int __user *)regs->d3; |
232 | child_tidptr = (int __user *)regs->d4; | |
1da177e4 LT |
233 | if (!newsp) |
234 | newsp = rdusp(); | |
235 | return do_fork(clone_flags, newsp, regs, 0, | |
236 | parent_tidptr, child_tidptr); | |
237 | } | |
238 | ||
239 | int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, | |
240 | unsigned long unused, | |
241 | struct task_struct * p, struct pt_regs * regs) | |
242 | { | |
243 | struct pt_regs * childregs; | |
244 | struct switch_stack * childstack, *stack; | |
768595ff | 245 | unsigned long *retp; |
1da177e4 | 246 | |
768595ff | 247 | childregs = (struct pt_regs *) (task_stack_page(p) + THREAD_SIZE) - 1; |
1da177e4 LT |
248 | |
249 | *childregs = *regs; | |
250 | childregs->d0 = 0; | |
251 | ||
252 | retp = ((unsigned long *) regs); | |
253 | stack = ((struct switch_stack *) retp) - 1; | |
254 | ||
255 | childstack = ((struct switch_stack *) childregs) - 1; | |
256 | *childstack = *stack; | |
257 | childstack->retpc = (unsigned long)ret_from_fork; | |
258 | ||
259 | p->thread.usp = usp; | |
260 | p->thread.ksp = (unsigned long)childstack; | |
261 | /* | |
262 | * Must save the current SFC/DFC value, NOT the value when | |
263 | * the parent was last descheduled - RGH 10-08-96 | |
264 | */ | |
265 | p->thread.fs = get_fs().seg; | |
266 | ||
267 | if (!FPU_IS_EMU) { | |
268 | /* Copy the current fpu state */ | |
269 | asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory"); | |
270 | ||
271 | if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2]) | |
272 | asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t" | |
273 | "fmoveml %/fpiar/%/fpcr/%/fpsr,%1" | |
274 | : : "m" (p->thread.fp[0]), "m" (p->thread.fpcntl[0]) | |
275 | : "memory"); | |
276 | /* Restore the state in case the fpu was busy */ | |
277 | asm volatile ("frestore %0" : : "m" (p->thread.fpstate[0])); | |
278 | } | |
279 | ||
280 | return 0; | |
281 | } | |
282 | ||
283 | /* Fill in the fpu structure for a core dump. */ | |
284 | ||
285 | int dump_fpu (struct pt_regs *regs, struct user_m68kfp_struct *fpu) | |
286 | { | |
287 | char fpustate[216]; | |
288 | ||
289 | if (FPU_IS_EMU) { | |
290 | int i; | |
291 | ||
292 | memcpy(fpu->fpcntl, current->thread.fpcntl, 12); | |
293 | memcpy(fpu->fpregs, current->thread.fp, 96); | |
294 | /* Convert internal fpu reg representation | |
295 | * into long double format | |
296 | */ | |
297 | for (i = 0; i < 24; i += 3) | |
298 | fpu->fpregs[i] = ((fpu->fpregs[i] & 0xffff0000) << 15) | | |
299 | ((fpu->fpregs[i] & 0x0000ffff) << 16); | |
300 | return 1; | |
301 | } | |
302 | ||
303 | /* First dump the fpu context to avoid protocol violation. */ | |
304 | asm volatile ("fsave %0" :: "m" (fpustate[0]) : "memory"); | |
305 | if (!CPU_IS_060 ? !fpustate[0] : !fpustate[2]) | |
306 | return 0; | |
307 | ||
308 | asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0" | |
309 | :: "m" (fpu->fpcntl[0]) | |
310 | : "memory"); | |
311 | asm volatile ("fmovemx %/fp0-%/fp7,%0" | |
312 | :: "m" (fpu->fpregs[0]) | |
313 | : "memory"); | |
314 | return 1; | |
315 | } | |
2e811488 | 316 | EXPORT_SYMBOL(dump_fpu); |
1da177e4 LT |
317 | |
318 | /* | |
319 | * fill in the user structure for a core dump.. | |
320 | */ | |
321 | void dump_thread(struct pt_regs * regs, struct user * dump) | |
322 | { | |
323 | struct switch_stack *sw; | |
324 | ||
325 | /* changed the size calculations - should hopefully work better. lbt */ | |
326 | dump->magic = CMAGIC; | |
327 | dump->start_code = 0; | |
328 | dump->start_stack = rdusp() & ~(PAGE_SIZE - 1); | |
329 | dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT; | |
330 | dump->u_dsize = ((unsigned long) (current->mm->brk + | |
331 | (PAGE_SIZE-1))) >> PAGE_SHIFT; | |
332 | dump->u_dsize -= dump->u_tsize; | |
333 | dump->u_ssize = 0; | |
334 | ||
335 | if (dump->start_stack < TASK_SIZE) | |
336 | dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT; | |
337 | ||
338 | dump->u_ar0 = (struct user_regs_struct *)((int)&dump->regs - (int)dump); | |
339 | sw = ((struct switch_stack *)regs) - 1; | |
340 | dump->regs.d1 = regs->d1; | |
341 | dump->regs.d2 = regs->d2; | |
342 | dump->regs.d3 = regs->d3; | |
343 | dump->regs.d4 = regs->d4; | |
344 | dump->regs.d5 = regs->d5; | |
345 | dump->regs.d6 = sw->d6; | |
346 | dump->regs.d7 = sw->d7; | |
347 | dump->regs.a0 = regs->a0; | |
348 | dump->regs.a1 = regs->a1; | |
349 | dump->regs.a2 = regs->a2; | |
350 | dump->regs.a3 = sw->a3; | |
351 | dump->regs.a4 = sw->a4; | |
352 | dump->regs.a5 = sw->a5; | |
353 | dump->regs.a6 = sw->a6; | |
354 | dump->regs.d0 = regs->d0; | |
355 | dump->regs.orig_d0 = regs->orig_d0; | |
356 | dump->regs.stkadj = regs->stkadj; | |
357 | dump->regs.sr = regs->sr; | |
358 | dump->regs.pc = regs->pc; | |
359 | dump->regs.fmtvec = (regs->format << 12) | regs->vector; | |
360 | /* dump floating point stuff */ | |
361 | dump->u_fpvalid = dump_fpu (regs, &dump->m68kfp); | |
362 | } | |
2e811488 | 363 | EXPORT_SYMBOL(dump_thread); |
1da177e4 LT |
364 | |
365 | /* | |
366 | * sys_execve() executes a new program. | |
367 | */ | |
1e5c374d | 368 | asmlinkage int sys_execve(char __user *name, char __user * __user *argv, char __user * __user *envp) |
1da177e4 LT |
369 | { |
370 | int error; | |
371 | char * filename; | |
372 | struct pt_regs *regs = (struct pt_regs *) &name; | |
373 | ||
374 | lock_kernel(); | |
375 | filename = getname(name); | |
376 | error = PTR_ERR(filename); | |
377 | if (IS_ERR(filename)) | |
378 | goto out; | |
379 | error = do_execve(filename, argv, envp, regs); | |
380 | putname(filename); | |
381 | out: | |
382 | unlock_kernel(); | |
383 | return error; | |
384 | } | |
385 | ||
386 | unsigned long get_wchan(struct task_struct *p) | |
387 | { | |
388 | unsigned long fp, pc; | |
389 | unsigned long stack_page; | |
390 | int count = 0; | |
391 | if (!p || p == current || p->state == TASK_RUNNING) | |
392 | return 0; | |
393 | ||
768595ff | 394 | stack_page = (unsigned long)task_stack_page(p); |
1da177e4 LT |
395 | fp = ((struct switch_stack *)p->thread.ksp)->a6; |
396 | do { | |
397 | if (fp < stack_page+sizeof(struct thread_info) || | |
398 | fp >= 8184+stack_page) | |
399 | return 0; | |
400 | pc = ((unsigned long *)fp)[1]; | |
401 | if (!in_sched_functions(pc)) | |
402 | return pc; | |
403 | fp = *(unsigned long *) fp; | |
404 | } while (count++ < 16); | |
405 | return 0; | |
406 | } |