diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/m68k/kernel/process.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'arch/m68k/kernel/process.c')
-rw-r--r-- | arch/m68k/kernel/process.c | 405 |
1 files changed, 405 insertions, 0 deletions
diff --git a/arch/m68k/kernel/process.c b/arch/m68k/kernel/process.c new file mode 100644 index 000000000000..93b043e2a435 --- /dev/null +++ b/arch/m68k/kernel/process.c | |||
@@ -0,0 +1,405 @@ | |||
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 | |||
13 | #include <linux/config.h> | ||
14 | #include <linux/errno.h> | ||
15 | #include <linux/module.h> | ||
16 | #include <linux/sched.h> | ||
17 | #include <linux/kernel.h> | ||
18 | #include <linux/mm.h> | ||
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 | */ | ||
80 | void default_idle(void) | ||
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(); | ||
105 | schedule(); | ||
106 | } | ||
107 | } | ||
108 | |||
109 | void machine_restart(char * __unused) | ||
110 | { | ||
111 | if (mach_reset) | ||
112 | mach_reset(); | ||
113 | for (;;); | ||
114 | } | ||
115 | |||
116 | EXPORT_SYMBOL(machine_restart); | ||
117 | |||
118 | void machine_halt(void) | ||
119 | { | ||
120 | if (mach_halt) | ||
121 | mach_halt(); | ||
122 | for (;;); | ||
123 | } | ||
124 | |||
125 | EXPORT_SYMBOL(machine_halt); | ||
126 | |||
127 | void machine_power_off(void) | ||
128 | { | ||
129 | if (mach_power_off) | ||
130 | mach_power_off(); | ||
131 | for (;;); | ||
132 | } | ||
133 | |||
134 | EXPORT_SYMBOL(machine_power_off); | ||
135 | |||
136 | void show_regs(struct pt_regs * regs) | ||
137 | { | ||
138 | printk("\n"); | ||
139 | printk("Format %02x Vector: %04x PC: %08lx Status: %04x %s\n", | ||
140 | regs->format, regs->vector, regs->pc, regs->sr, print_tainted()); | ||
141 | printk("ORIG_D0: %08lx D0: %08lx A2: %08lx A1: %08lx\n", | ||
142 | regs->orig_d0, regs->d0, regs->a2, regs->a1); | ||
143 | printk("A0: %08lx D5: %08lx D4: %08lx\n", | ||
144 | regs->a0, regs->d5, regs->d4); | ||
145 | printk("D3: %08lx D2: %08lx D1: %08lx\n", | ||
146 | regs->d3, regs->d2, regs->d1); | ||
147 | if (!(regs->sr & PS_S)) | ||
148 | printk("USP: %08lx\n", rdusp()); | ||
149 | } | ||
150 | |||
151 | /* | ||
152 | * Create a kernel thread | ||
153 | */ | ||
154 | int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) | ||
155 | { | ||
156 | int pid; | ||
157 | mm_segment_t fs; | ||
158 | |||
159 | fs = get_fs(); | ||
160 | set_fs (KERNEL_DS); | ||
161 | |||
162 | { | ||
163 | register long retval __asm__ ("d0"); | ||
164 | register long clone_arg __asm__ ("d1") = flags | CLONE_VM | CLONE_UNTRACED; | ||
165 | |||
166 | retval = __NR_clone; | ||
167 | __asm__ __volatile__ | ||
168 | ("clrl %%d2\n\t" | ||
169 | "trap #0\n\t" /* Linux/m68k system call */ | ||
170 | "tstl %0\n\t" /* child or parent */ | ||
171 | "jne 1f\n\t" /* parent - jump */ | ||
172 | "lea %%sp@(%c7),%6\n\t" /* reload current */ | ||
173 | "movel %6@,%6\n\t" | ||
174 | "movel %3,%%sp@-\n\t" /* push argument */ | ||
175 | "jsr %4@\n\t" /* call fn */ | ||
176 | "movel %0,%%d1\n\t" /* pass exit value */ | ||
177 | "movel %2,%%d0\n\t" /* exit */ | ||
178 | "trap #0\n" | ||
179 | "1:" | ||
180 | : "+d" (retval) | ||
181 | : "i" (__NR_clone), "i" (__NR_exit), | ||
182 | "r" (arg), "a" (fn), "d" (clone_arg), "r" (current), | ||
183 | "i" (-THREAD_SIZE) | ||
184 | : "d2"); | ||
185 | |||
186 | pid = retval; | ||
187 | } | ||
188 | |||
189 | set_fs (fs); | ||
190 | return pid; | ||
191 | } | ||
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; | ||
226 | int *parent_tidptr, *child_tidptr; | ||
227 | |||
228 | /* syscall2 puts clone_flags in d1 and usp in d2 */ | ||
229 | clone_flags = regs->d1; | ||
230 | newsp = regs->d2; | ||
231 | parent_tidptr = (int *)regs->d3; | ||
232 | child_tidptr = (int *)regs->d4; | ||
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; | ||
245 | unsigned long stack_offset, *retp; | ||
246 | |||
247 | stack_offset = THREAD_SIZE - sizeof(struct pt_regs); | ||
248 | childregs = (struct pt_regs *) ((unsigned long) (p->thread_info) + stack_offset); | ||
249 | |||
250 | *childregs = *regs; | ||
251 | childregs->d0 = 0; | ||
252 | |||
253 | retp = ((unsigned long *) regs); | ||
254 | stack = ((struct switch_stack *) retp) - 1; | ||
255 | |||
256 | childstack = ((struct switch_stack *) childregs) - 1; | ||
257 | *childstack = *stack; | ||
258 | childstack->retpc = (unsigned long)ret_from_fork; | ||
259 | |||
260 | p->thread.usp = usp; | ||
261 | p->thread.ksp = (unsigned long)childstack; | ||
262 | /* | ||
263 | * Must save the current SFC/DFC value, NOT the value when | ||
264 | * the parent was last descheduled - RGH 10-08-96 | ||
265 | */ | ||
266 | p->thread.fs = get_fs().seg; | ||
267 | |||
268 | if (!FPU_IS_EMU) { | ||
269 | /* Copy the current fpu state */ | ||
270 | asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory"); | ||
271 | |||
272 | if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2]) | ||
273 | asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t" | ||
274 | "fmoveml %/fpiar/%/fpcr/%/fpsr,%1" | ||
275 | : : "m" (p->thread.fp[0]), "m" (p->thread.fpcntl[0]) | ||
276 | : "memory"); | ||
277 | /* Restore the state in case the fpu was busy */ | ||
278 | asm volatile ("frestore %0" : : "m" (p->thread.fpstate[0])); | ||
279 | } | ||
280 | |||
281 | return 0; | ||
282 | } | ||
283 | |||
284 | /* Fill in the fpu structure for a core dump. */ | ||
285 | |||
286 | int dump_fpu (struct pt_regs *regs, struct user_m68kfp_struct *fpu) | ||
287 | { | ||
288 | char fpustate[216]; | ||
289 | |||
290 | if (FPU_IS_EMU) { | ||
291 | int i; | ||
292 | |||
293 | memcpy(fpu->fpcntl, current->thread.fpcntl, 12); | ||
294 | memcpy(fpu->fpregs, current->thread.fp, 96); | ||
295 | /* Convert internal fpu reg representation | ||
296 | * into long double format | ||
297 | */ | ||
298 | for (i = 0; i < 24; i += 3) | ||
299 | fpu->fpregs[i] = ((fpu->fpregs[i] & 0xffff0000) << 15) | | ||
300 | ((fpu->fpregs[i] & 0x0000ffff) << 16); | ||
301 | return 1; | ||
302 | } | ||
303 | |||
304 | /* First dump the fpu context to avoid protocol violation. */ | ||
305 | asm volatile ("fsave %0" :: "m" (fpustate[0]) : "memory"); | ||
306 | if (!CPU_IS_060 ? !fpustate[0] : !fpustate[2]) | ||
307 | return 0; | ||
308 | |||
309 | asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0" | ||
310 | :: "m" (fpu->fpcntl[0]) | ||
311 | : "memory"); | ||
312 | asm volatile ("fmovemx %/fp0-%/fp7,%0" | ||
313 | :: "m" (fpu->fpregs[0]) | ||
314 | : "memory"); | ||
315 | return 1; | ||
316 | } | ||
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 | } | ||
363 | |||
364 | /* | ||
365 | * sys_execve() executes a new program. | ||
366 | */ | ||
367 | asmlinkage int sys_execve(char *name, char **argv, char **envp) | ||
368 | { | ||
369 | int error; | ||
370 | char * filename; | ||
371 | struct pt_regs *regs = (struct pt_regs *) &name; | ||
372 | |||
373 | lock_kernel(); | ||
374 | filename = getname(name); | ||
375 | error = PTR_ERR(filename); | ||
376 | if (IS_ERR(filename)) | ||
377 | goto out; | ||
378 | error = do_execve(filename, argv, envp, regs); | ||
379 | putname(filename); | ||
380 | out: | ||
381 | unlock_kernel(); | ||
382 | return error; | ||
383 | } | ||
384 | |||
385 | unsigned long get_wchan(struct task_struct *p) | ||
386 | { | ||
387 | unsigned long fp, pc; | ||
388 | unsigned long stack_page; | ||
389 | int count = 0; | ||
390 | if (!p || p == current || p->state == TASK_RUNNING) | ||
391 | return 0; | ||
392 | |||
393 | stack_page = (unsigned long)(p->thread_info); | ||
394 | fp = ((struct switch_stack *)p->thread.ksp)->a6; | ||
395 | do { | ||
396 | if (fp < stack_page+sizeof(struct thread_info) || | ||
397 | fp >= 8184+stack_page) | ||
398 | return 0; | ||
399 | pc = ((unsigned long *)fp)[1]; | ||
400 | if (!in_sched_functions(pc)) | ||
401 | return pc; | ||
402 | fp = *(unsigned long *) fp; | ||
403 | } while (count++ < 16); | ||
404 | return 0; | ||
405 | } | ||