2 * arch/sh/kernel/process_64.c
4 * This file handles the architecture-dependent parts of process handling..
6 * Copyright (C) 2000, 2001 Paolo Alberelli
7 * Copyright (C) 2003 - 2007 Paul Mundt
8 * Copyright (C) 2003, 2004 Richard Curnow
10 * Started from SH3/4 version:
11 * Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima
13 * In turn started from i386 version:
14 * Copyright (C) 1995 Linus Torvalds
16 * This file is subject to the terms and conditions of the GNU General Public
17 * License. See the file "COPYING" in the main directory of this archive
22 #include <linux/ptrace.h>
23 #include <linux/reboot.h>
24 #include <linux/slab.h>
25 #include <linux/init.h>
26 #include <linux/module.h>
28 #include <asm/syscalls.h>
29 #include <asm/uaccess.h>
30 #include <asm/pgtable.h>
31 #include <asm/mmu_context.h>
33 #include <asm/switch_to.h>
35 struct task_struct
*last_task_used_math
= NULL
;
36 struct pt_regs fake_swapper_regs
= { 0, };
38 void show_regs(struct pt_regs
*regs
)
40 unsigned long long ah
, al
, bh
, bl
, ch
, cl
;
44 ah
= (regs
->pc
) >> 32;
45 al
= (regs
->pc
) & 0xffffffff;
46 bh
= (regs
->regs
[18]) >> 32;
47 bl
= (regs
->regs
[18]) & 0xffffffff;
48 ch
= (regs
->regs
[15]) >> 32;
49 cl
= (regs
->regs
[15]) & 0xffffffff;
50 printk("PC : %08Lx%08Lx LINK: %08Lx%08Lx SP : %08Lx%08Lx\n",
51 ah
, al
, bh
, bl
, ch
, cl
);
53 ah
= (regs
->sr
) >> 32;
54 al
= (regs
->sr
) & 0xffffffff;
55 asm volatile ("getcon " __TEA
", %0" : "=r" (bh
));
56 asm volatile ("getcon " __TEA
", %0" : "=r" (bl
));
58 bl
= (bl
) & 0xffffffff;
59 asm volatile ("getcon " __KCR0
", %0" : "=r" (ch
));
60 asm volatile ("getcon " __KCR0
", %0" : "=r" (cl
));
62 cl
= (cl
) & 0xffffffff;
63 printk("SR : %08Lx%08Lx TEA : %08Lx%08Lx KCR0: %08Lx%08Lx\n",
64 ah
, al
, bh
, bl
, ch
, cl
);
66 ah
= (regs
->regs
[0]) >> 32;
67 al
= (regs
->regs
[0]) & 0xffffffff;
68 bh
= (regs
->regs
[1]) >> 32;
69 bl
= (regs
->regs
[1]) & 0xffffffff;
70 ch
= (regs
->regs
[2]) >> 32;
71 cl
= (regs
->regs
[2]) & 0xffffffff;
72 printk("R0 : %08Lx%08Lx R1 : %08Lx%08Lx R2 : %08Lx%08Lx\n",
73 ah
, al
, bh
, bl
, ch
, cl
);
75 ah
= (regs
->regs
[3]) >> 32;
76 al
= (regs
->regs
[3]) & 0xffffffff;
77 bh
= (regs
->regs
[4]) >> 32;
78 bl
= (regs
->regs
[4]) & 0xffffffff;
79 ch
= (regs
->regs
[5]) >> 32;
80 cl
= (regs
->regs
[5]) & 0xffffffff;
81 printk("R3 : %08Lx%08Lx R4 : %08Lx%08Lx R5 : %08Lx%08Lx\n",
82 ah
, al
, bh
, bl
, ch
, cl
);
84 ah
= (regs
->regs
[6]) >> 32;
85 al
= (regs
->regs
[6]) & 0xffffffff;
86 bh
= (regs
->regs
[7]) >> 32;
87 bl
= (regs
->regs
[7]) & 0xffffffff;
88 ch
= (regs
->regs
[8]) >> 32;
89 cl
= (regs
->regs
[8]) & 0xffffffff;
90 printk("R6 : %08Lx%08Lx R7 : %08Lx%08Lx R8 : %08Lx%08Lx\n",
91 ah
, al
, bh
, bl
, ch
, cl
);
93 ah
= (regs
->regs
[9]) >> 32;
94 al
= (regs
->regs
[9]) & 0xffffffff;
95 bh
= (regs
->regs
[10]) >> 32;
96 bl
= (regs
->regs
[10]) & 0xffffffff;
97 ch
= (regs
->regs
[11]) >> 32;
98 cl
= (regs
->regs
[11]) & 0xffffffff;
99 printk("R9 : %08Lx%08Lx R10 : %08Lx%08Lx R11 : %08Lx%08Lx\n",
100 ah
, al
, bh
, bl
, ch
, cl
);
102 ah
= (regs
->regs
[12]) >> 32;
103 al
= (regs
->regs
[12]) & 0xffffffff;
104 bh
= (regs
->regs
[13]) >> 32;
105 bl
= (regs
->regs
[13]) & 0xffffffff;
106 ch
= (regs
->regs
[14]) >> 32;
107 cl
= (regs
->regs
[14]) & 0xffffffff;
108 printk("R12 : %08Lx%08Lx R13 : %08Lx%08Lx R14 : %08Lx%08Lx\n",
109 ah
, al
, bh
, bl
, ch
, cl
);
111 ah
= (regs
->regs
[16]) >> 32;
112 al
= (regs
->regs
[16]) & 0xffffffff;
113 bh
= (regs
->regs
[17]) >> 32;
114 bl
= (regs
->regs
[17]) & 0xffffffff;
115 ch
= (regs
->regs
[19]) >> 32;
116 cl
= (regs
->regs
[19]) & 0xffffffff;
117 printk("R16 : %08Lx%08Lx R17 : %08Lx%08Lx R19 : %08Lx%08Lx\n",
118 ah
, al
, bh
, bl
, ch
, cl
);
120 ah
= (regs
->regs
[20]) >> 32;
121 al
= (regs
->regs
[20]) & 0xffffffff;
122 bh
= (regs
->regs
[21]) >> 32;
123 bl
= (regs
->regs
[21]) & 0xffffffff;
124 ch
= (regs
->regs
[22]) >> 32;
125 cl
= (regs
->regs
[22]) & 0xffffffff;
126 printk("R20 : %08Lx%08Lx R21 : %08Lx%08Lx R22 : %08Lx%08Lx\n",
127 ah
, al
, bh
, bl
, ch
, cl
);
129 ah
= (regs
->regs
[23]) >> 32;
130 al
= (regs
->regs
[23]) & 0xffffffff;
131 bh
= (regs
->regs
[24]) >> 32;
132 bl
= (regs
->regs
[24]) & 0xffffffff;
133 ch
= (regs
->regs
[25]) >> 32;
134 cl
= (regs
->regs
[25]) & 0xffffffff;
135 printk("R23 : %08Lx%08Lx R24 : %08Lx%08Lx R25 : %08Lx%08Lx\n",
136 ah
, al
, bh
, bl
, ch
, cl
);
138 ah
= (regs
->regs
[26]) >> 32;
139 al
= (regs
->regs
[26]) & 0xffffffff;
140 bh
= (regs
->regs
[27]) >> 32;
141 bl
= (regs
->regs
[27]) & 0xffffffff;
142 ch
= (regs
->regs
[28]) >> 32;
143 cl
= (regs
->regs
[28]) & 0xffffffff;
144 printk("R26 : %08Lx%08Lx R27 : %08Lx%08Lx R28 : %08Lx%08Lx\n",
145 ah
, al
, bh
, bl
, ch
, cl
);
147 ah
= (regs
->regs
[29]) >> 32;
148 al
= (regs
->regs
[29]) & 0xffffffff;
149 bh
= (regs
->regs
[30]) >> 32;
150 bl
= (regs
->regs
[30]) & 0xffffffff;
151 ch
= (regs
->regs
[31]) >> 32;
152 cl
= (regs
->regs
[31]) & 0xffffffff;
153 printk("R29 : %08Lx%08Lx R30 : %08Lx%08Lx R31 : %08Lx%08Lx\n",
154 ah
, al
, bh
, bl
, ch
, cl
);
156 ah
= (regs
->regs
[32]) >> 32;
157 al
= (regs
->regs
[32]) & 0xffffffff;
158 bh
= (regs
->regs
[33]) >> 32;
159 bl
= (regs
->regs
[33]) & 0xffffffff;
160 ch
= (regs
->regs
[34]) >> 32;
161 cl
= (regs
->regs
[34]) & 0xffffffff;
162 printk("R32 : %08Lx%08Lx R33 : %08Lx%08Lx R34 : %08Lx%08Lx\n",
163 ah
, al
, bh
, bl
, ch
, cl
);
165 ah
= (regs
->regs
[35]) >> 32;
166 al
= (regs
->regs
[35]) & 0xffffffff;
167 bh
= (regs
->regs
[36]) >> 32;
168 bl
= (regs
->regs
[36]) & 0xffffffff;
169 ch
= (regs
->regs
[37]) >> 32;
170 cl
= (regs
->regs
[37]) & 0xffffffff;
171 printk("R35 : %08Lx%08Lx R36 : %08Lx%08Lx R37 : %08Lx%08Lx\n",
172 ah
, al
, bh
, bl
, ch
, cl
);
174 ah
= (regs
->regs
[38]) >> 32;
175 al
= (regs
->regs
[38]) & 0xffffffff;
176 bh
= (regs
->regs
[39]) >> 32;
177 bl
= (regs
->regs
[39]) & 0xffffffff;
178 ch
= (regs
->regs
[40]) >> 32;
179 cl
= (regs
->regs
[40]) & 0xffffffff;
180 printk("R38 : %08Lx%08Lx R39 : %08Lx%08Lx R40 : %08Lx%08Lx\n",
181 ah
, al
, bh
, bl
, ch
, cl
);
183 ah
= (regs
->regs
[41]) >> 32;
184 al
= (regs
->regs
[41]) & 0xffffffff;
185 bh
= (regs
->regs
[42]) >> 32;
186 bl
= (regs
->regs
[42]) & 0xffffffff;
187 ch
= (regs
->regs
[43]) >> 32;
188 cl
= (regs
->regs
[43]) & 0xffffffff;
189 printk("R41 : %08Lx%08Lx R42 : %08Lx%08Lx R43 : %08Lx%08Lx\n",
190 ah
, al
, bh
, bl
, ch
, cl
);
192 ah
= (regs
->regs
[44]) >> 32;
193 al
= (regs
->regs
[44]) & 0xffffffff;
194 bh
= (regs
->regs
[45]) >> 32;
195 bl
= (regs
->regs
[45]) & 0xffffffff;
196 ch
= (regs
->regs
[46]) >> 32;
197 cl
= (regs
->regs
[46]) & 0xffffffff;
198 printk("R44 : %08Lx%08Lx R45 : %08Lx%08Lx R46 : %08Lx%08Lx\n",
199 ah
, al
, bh
, bl
, ch
, cl
);
201 ah
= (regs
->regs
[47]) >> 32;
202 al
= (regs
->regs
[47]) & 0xffffffff;
203 bh
= (regs
->regs
[48]) >> 32;
204 bl
= (regs
->regs
[48]) & 0xffffffff;
205 ch
= (regs
->regs
[49]) >> 32;
206 cl
= (regs
->regs
[49]) & 0xffffffff;
207 printk("R47 : %08Lx%08Lx R48 : %08Lx%08Lx R49 : %08Lx%08Lx\n",
208 ah
, al
, bh
, bl
, ch
, cl
);
210 ah
= (regs
->regs
[50]) >> 32;
211 al
= (regs
->regs
[50]) & 0xffffffff;
212 bh
= (regs
->regs
[51]) >> 32;
213 bl
= (regs
->regs
[51]) & 0xffffffff;
214 ch
= (regs
->regs
[52]) >> 32;
215 cl
= (regs
->regs
[52]) & 0xffffffff;
216 printk("R50 : %08Lx%08Lx R51 : %08Lx%08Lx R52 : %08Lx%08Lx\n",
217 ah
, al
, bh
, bl
, ch
, cl
);
219 ah
= (regs
->regs
[53]) >> 32;
220 al
= (regs
->regs
[53]) & 0xffffffff;
221 bh
= (regs
->regs
[54]) >> 32;
222 bl
= (regs
->regs
[54]) & 0xffffffff;
223 ch
= (regs
->regs
[55]) >> 32;
224 cl
= (regs
->regs
[55]) & 0xffffffff;
225 printk("R53 : %08Lx%08Lx R54 : %08Lx%08Lx R55 : %08Lx%08Lx\n",
226 ah
, al
, bh
, bl
, ch
, cl
);
228 ah
= (regs
->regs
[56]) >> 32;
229 al
= (regs
->regs
[56]) & 0xffffffff;
230 bh
= (regs
->regs
[57]) >> 32;
231 bl
= (regs
->regs
[57]) & 0xffffffff;
232 ch
= (regs
->regs
[58]) >> 32;
233 cl
= (regs
->regs
[58]) & 0xffffffff;
234 printk("R56 : %08Lx%08Lx R57 : %08Lx%08Lx R58 : %08Lx%08Lx\n",
235 ah
, al
, bh
, bl
, ch
, cl
);
237 ah
= (regs
->regs
[59]) >> 32;
238 al
= (regs
->regs
[59]) & 0xffffffff;
239 bh
= (regs
->regs
[60]) >> 32;
240 bl
= (regs
->regs
[60]) & 0xffffffff;
241 ch
= (regs
->regs
[61]) >> 32;
242 cl
= (regs
->regs
[61]) & 0xffffffff;
243 printk("R59 : %08Lx%08Lx R60 : %08Lx%08Lx R61 : %08Lx%08Lx\n",
244 ah
, al
, bh
, bl
, ch
, cl
);
246 ah
= (regs
->regs
[62]) >> 32;
247 al
= (regs
->regs
[62]) & 0xffffffff;
248 bh
= (regs
->tregs
[0]) >> 32;
249 bl
= (regs
->tregs
[0]) & 0xffffffff;
250 ch
= (regs
->tregs
[1]) >> 32;
251 cl
= (regs
->tregs
[1]) & 0xffffffff;
252 printk("R62 : %08Lx%08Lx T0 : %08Lx%08Lx T1 : %08Lx%08Lx\n",
253 ah
, al
, bh
, bl
, ch
, cl
);
255 ah
= (regs
->tregs
[2]) >> 32;
256 al
= (regs
->tregs
[2]) & 0xffffffff;
257 bh
= (regs
->tregs
[3]) >> 32;
258 bl
= (regs
->tregs
[3]) & 0xffffffff;
259 ch
= (regs
->tregs
[4]) >> 32;
260 cl
= (regs
->tregs
[4]) & 0xffffffff;
261 printk("T2 : %08Lx%08Lx T3 : %08Lx%08Lx T4 : %08Lx%08Lx\n",
262 ah
, al
, bh
, bl
, ch
, cl
);
264 ah
= (regs
->tregs
[5]) >> 32;
265 al
= (regs
->tregs
[5]) & 0xffffffff;
266 bh
= (regs
->tregs
[6]) >> 32;
267 bl
= (regs
->tregs
[6]) & 0xffffffff;
268 ch
= (regs
->tregs
[7]) >> 32;
269 cl
= (regs
->tregs
[7]) & 0xffffffff;
270 printk("T5 : %08Lx%08Lx T6 : %08Lx%08Lx T7 : %08Lx%08Lx\n",
271 ah
, al
, bh
, bl
, ch
, cl
);
274 * If we're in kernel mode, dump the stack too..
276 if (!user_mode(regs
)) {
277 void show_stack(struct task_struct
*tsk
, unsigned long *sp
);
278 unsigned long sp
= regs
->regs
[15] & 0xffffffff;
279 struct task_struct
*tsk
= get_current();
281 tsk
->thread
.kregs
= regs
;
283 show_stack(tsk
, (unsigned long *)sp
);
288 * Create a kernel thread
290 __noreturn
void kernel_thread_helper(void *arg
, int (*fn
)(void *))
296 * This is the mechanism for creating a new kernel thread.
298 * NOTE! Only a kernel-only process(ie the swapper or direct descendants
299 * who haven't done an "execve()") should use this: it will work within
300 * a system call from a "real" process, but the process memory space will
301 * not be freed until both the parent and the child have exited.
303 int kernel_thread(int (*fn
)(void *), void * arg
, unsigned long flags
)
307 memset(®s
, 0, sizeof(regs
));
308 regs
.regs
[2] = (unsigned long)arg
;
309 regs
.regs
[3] = (unsigned long)fn
;
311 regs
.pc
= (unsigned long)kernel_thread_helper
;
314 /* Ok, create the new process.. */
315 return do_fork(flags
| CLONE_VM
| CLONE_UNTRACED
, 0,
316 ®s
, 0, NULL
, NULL
);
318 EXPORT_SYMBOL(kernel_thread
);
321 * Free current thread data structures etc..
323 void exit_thread(void)
326 * See arch/sparc/kernel/process.c for the precedent for doing
329 * The SH-5 FPU save/restore approach relies on
330 * last_task_used_math pointing to a live task_struct. When
331 * another task tries to use the FPU for the 1st time, the FPUDIS
332 * trap handling (see arch/sh/kernel/cpu/sh5/fpu.c) will save the
333 * existing FPU state to the FP regs field within
334 * last_task_used_math before re-loading the new task's FPU state
335 * (or initialising it if the FPU has been used before). So if
336 * last_task_used_math is stale, and its page has already been
337 * re-allocated for another use, the consequences are rather
338 * grim. Unless we null it here, there is no other path through
339 * which it would get safely nulled.
342 if (last_task_used_math
== current
) {
343 last_task_used_math
= NULL
;
348 void flush_thread(void)
351 /* Called by fs/exec.c (setup_new_exec) to remove traces of a
352 * previously running executable. */
354 if (last_task_used_math
== current
) {
355 last_task_used_math
= NULL
;
357 /* Force FPU state to be reinitialised after exec */
361 /* if we are a kernel thread, about to change to user thread,
364 if(current
->thread
.kregs
==&fake_swapper_regs
) {
365 current
->thread
.kregs
=
366 ((struct pt_regs
*)(THREAD_SIZE
+ (unsigned long) current
) - 1);
367 current
->thread
.uregs
= current
->thread
.kregs
;
371 void release_thread(struct task_struct
*dead_task
)
376 /* Fill in the fpu structure for a core dump.. */
377 int dump_fpu(struct pt_regs
*regs
, elf_fpregset_t
*fpu
)
381 struct task_struct
*tsk
= current
;
383 fpvalid
= !!tsk_used_math(tsk
);
385 if (current
== last_task_used_math
) {
389 last_task_used_math
= 0;
393 memcpy(fpu
, &tsk
->thread
.xstate
->hardfpu
, sizeof(*fpu
));
398 return 0; /* Task didn't use the fpu at all. */
401 EXPORT_SYMBOL(dump_fpu
);
403 asmlinkage
void ret_from_fork(void);
405 int copy_thread(unsigned long clone_flags
, unsigned long usp
,
406 unsigned long unused
,
407 struct task_struct
*p
, struct pt_regs
*regs
)
409 struct pt_regs
*childregs
;
412 if(last_task_used_math
== current
) {
416 last_task_used_math
= NULL
;
420 /* Copy from sh version */
421 childregs
= (struct pt_regs
*)(THREAD_SIZE
+ task_stack_page(p
)) - 1;
426 * Sign extend the edited stack.
427 * Note that thread.pc and thread.pc will stay
428 * 32-bit wide and context switch must take care
429 * of NEFF sign extension.
431 if (user_mode(regs
)) {
432 childregs
->regs
[15] = neff_sign_extend(usp
);
433 p
->thread
.uregs
= childregs
;
435 childregs
->regs
[15] =
436 neff_sign_extend((unsigned long)task_stack_page(p
) +
440 childregs
->regs
[9] = 0; /* Set return value for child */
441 childregs
->sr
|= SR_FD
; /* Invalidate FPU flag */
443 p
->thread
.sp
= (unsigned long) childregs
;
444 p
->thread
.pc
= (unsigned long) ret_from_fork
;
449 asmlinkage
int sys_fork(unsigned long r2
, unsigned long r3
,
450 unsigned long r4
, unsigned long r5
,
451 unsigned long r6
, unsigned long r7
,
452 struct pt_regs
*pregs
)
454 return do_fork(SIGCHLD
, pregs
->regs
[15], pregs
, 0, 0, 0);
457 asmlinkage
int sys_clone(unsigned long clone_flags
, unsigned long newsp
,
458 unsigned long r4
, unsigned long r5
,
459 unsigned long r6
, unsigned long r7
,
460 struct pt_regs
*pregs
)
463 newsp
= pregs
->regs
[15];
464 return do_fork(clone_flags
, newsp
, pregs
, 0, 0, 0);
468 * This is trivial, and on the face of it looks like it
469 * could equally well be done in user mode.
471 * Not so, for quite unobvious reasons - register pressure.
472 * In user mode vfork() cannot have a stack frame, and if
473 * done by calling the "clone()" system call directly, you
474 * do not have enough call-clobbered registers to hold all
475 * the information you need.
477 asmlinkage
int sys_vfork(unsigned long r2
, unsigned long r3
,
478 unsigned long r4
, unsigned long r5
,
479 unsigned long r6
, unsigned long r7
,
480 struct pt_regs
*pregs
)
482 return do_fork(CLONE_VFORK
| CLONE_VM
| SIGCHLD
, pregs
->regs
[15], pregs
, 0, 0, 0);
486 * sys_execve() executes a new program.
488 asmlinkage
int sys_execve(const char *ufilename
, char **uargv
,
489 char **uenvp
, unsigned long r5
,
490 unsigned long r6
, unsigned long r7
,
491 struct pt_regs
*pregs
)
496 filename
= getname((char __user
*)ufilename
);
497 error
= PTR_ERR(filename
);
498 if (IS_ERR(filename
))
501 error
= do_execve(filename
,
502 (const char __user
*const __user
*)uargv
,
503 (const char __user
*const __user
*)uenvp
,
510 #ifdef CONFIG_FRAME_POINTER
511 static int in_sh64_switch_to(unsigned long pc
)
513 extern char __sh64_switch_to_end
;
514 /* For a sleeping task, the PC is somewhere in the middle of the function,
515 so we don't have to worry about masking the LSB off */
516 return (pc
>= (unsigned long) sh64_switch_to
) &&
517 (pc
< (unsigned long) &__sh64_switch_to_end
);
521 unsigned long get_wchan(struct task_struct
*p
)
525 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
529 * The same comment as on the Alpha applies here, too ...
531 pc
= thread_saved_pc(p
);
533 #ifdef CONFIG_FRAME_POINTER
534 if (in_sh64_switch_to(pc
)) {
535 unsigned long schedule_fp
;
536 unsigned long sh64_switch_to_fp
;
537 unsigned long schedule_caller_pc
;
539 sh64_switch_to_fp
= (long) p
->thread
.sp
;
540 /* r14 is saved at offset 4 in the sh64_switch_to frame */
541 schedule_fp
= *(unsigned long *) (long)(sh64_switch_to_fp
+ 4);
543 /* and the caller of 'schedule' is (currently!) saved at offset 24
544 in the frame of schedule (from disasm) */
545 schedule_caller_pc
= *(unsigned long *) (long)(schedule_fp
+ 24);
546 return schedule_caller_pc
;