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
;
43 show_regs_print_info(KERN_DEFAULT
);
45 ah
= (regs
->pc
) >> 32;
46 al
= (regs
->pc
) & 0xffffffff;
47 bh
= (regs
->regs
[18]) >> 32;
48 bl
= (regs
->regs
[18]) & 0xffffffff;
49 ch
= (regs
->regs
[15]) >> 32;
50 cl
= (regs
->regs
[15]) & 0xffffffff;
51 printk("PC : %08Lx%08Lx LINK: %08Lx%08Lx SP : %08Lx%08Lx\n",
52 ah
, al
, bh
, bl
, ch
, cl
);
54 ah
= (regs
->sr
) >> 32;
55 al
= (regs
->sr
) & 0xffffffff;
56 asm volatile ("getcon " __TEA
", %0" : "=r" (bh
));
57 asm volatile ("getcon " __TEA
", %0" : "=r" (bl
));
59 bl
= (bl
) & 0xffffffff;
60 asm volatile ("getcon " __KCR0
", %0" : "=r" (ch
));
61 asm volatile ("getcon " __KCR0
", %0" : "=r" (cl
));
63 cl
= (cl
) & 0xffffffff;
64 printk("SR : %08Lx%08Lx TEA : %08Lx%08Lx KCR0: %08Lx%08Lx\n",
65 ah
, al
, bh
, bl
, ch
, cl
);
67 ah
= (regs
->regs
[0]) >> 32;
68 al
= (regs
->regs
[0]) & 0xffffffff;
69 bh
= (regs
->regs
[1]) >> 32;
70 bl
= (regs
->regs
[1]) & 0xffffffff;
71 ch
= (regs
->regs
[2]) >> 32;
72 cl
= (regs
->regs
[2]) & 0xffffffff;
73 printk("R0 : %08Lx%08Lx R1 : %08Lx%08Lx R2 : %08Lx%08Lx\n",
74 ah
, al
, bh
, bl
, ch
, cl
);
76 ah
= (regs
->regs
[3]) >> 32;
77 al
= (regs
->regs
[3]) & 0xffffffff;
78 bh
= (regs
->regs
[4]) >> 32;
79 bl
= (regs
->regs
[4]) & 0xffffffff;
80 ch
= (regs
->regs
[5]) >> 32;
81 cl
= (regs
->regs
[5]) & 0xffffffff;
82 printk("R3 : %08Lx%08Lx R4 : %08Lx%08Lx R5 : %08Lx%08Lx\n",
83 ah
, al
, bh
, bl
, ch
, cl
);
85 ah
= (regs
->regs
[6]) >> 32;
86 al
= (regs
->regs
[6]) & 0xffffffff;
87 bh
= (regs
->regs
[7]) >> 32;
88 bl
= (regs
->regs
[7]) & 0xffffffff;
89 ch
= (regs
->regs
[8]) >> 32;
90 cl
= (regs
->regs
[8]) & 0xffffffff;
91 printk("R6 : %08Lx%08Lx R7 : %08Lx%08Lx R8 : %08Lx%08Lx\n",
92 ah
, al
, bh
, bl
, ch
, cl
);
94 ah
= (regs
->regs
[9]) >> 32;
95 al
= (regs
->regs
[9]) & 0xffffffff;
96 bh
= (regs
->regs
[10]) >> 32;
97 bl
= (regs
->regs
[10]) & 0xffffffff;
98 ch
= (regs
->regs
[11]) >> 32;
99 cl
= (regs
->regs
[11]) & 0xffffffff;
100 printk("R9 : %08Lx%08Lx R10 : %08Lx%08Lx R11 : %08Lx%08Lx\n",
101 ah
, al
, bh
, bl
, ch
, cl
);
103 ah
= (regs
->regs
[12]) >> 32;
104 al
= (regs
->regs
[12]) & 0xffffffff;
105 bh
= (regs
->regs
[13]) >> 32;
106 bl
= (regs
->regs
[13]) & 0xffffffff;
107 ch
= (regs
->regs
[14]) >> 32;
108 cl
= (regs
->regs
[14]) & 0xffffffff;
109 printk("R12 : %08Lx%08Lx R13 : %08Lx%08Lx R14 : %08Lx%08Lx\n",
110 ah
, al
, bh
, bl
, ch
, cl
);
112 ah
= (regs
->regs
[16]) >> 32;
113 al
= (regs
->regs
[16]) & 0xffffffff;
114 bh
= (regs
->regs
[17]) >> 32;
115 bl
= (regs
->regs
[17]) & 0xffffffff;
116 ch
= (regs
->regs
[19]) >> 32;
117 cl
= (regs
->regs
[19]) & 0xffffffff;
118 printk("R16 : %08Lx%08Lx R17 : %08Lx%08Lx R19 : %08Lx%08Lx\n",
119 ah
, al
, bh
, bl
, ch
, cl
);
121 ah
= (regs
->regs
[20]) >> 32;
122 al
= (regs
->regs
[20]) & 0xffffffff;
123 bh
= (regs
->regs
[21]) >> 32;
124 bl
= (regs
->regs
[21]) & 0xffffffff;
125 ch
= (regs
->regs
[22]) >> 32;
126 cl
= (regs
->regs
[22]) & 0xffffffff;
127 printk("R20 : %08Lx%08Lx R21 : %08Lx%08Lx R22 : %08Lx%08Lx\n",
128 ah
, al
, bh
, bl
, ch
, cl
);
130 ah
= (regs
->regs
[23]) >> 32;
131 al
= (regs
->regs
[23]) & 0xffffffff;
132 bh
= (regs
->regs
[24]) >> 32;
133 bl
= (regs
->regs
[24]) & 0xffffffff;
134 ch
= (regs
->regs
[25]) >> 32;
135 cl
= (regs
->regs
[25]) & 0xffffffff;
136 printk("R23 : %08Lx%08Lx R24 : %08Lx%08Lx R25 : %08Lx%08Lx\n",
137 ah
, al
, bh
, bl
, ch
, cl
);
139 ah
= (regs
->regs
[26]) >> 32;
140 al
= (regs
->regs
[26]) & 0xffffffff;
141 bh
= (regs
->regs
[27]) >> 32;
142 bl
= (regs
->regs
[27]) & 0xffffffff;
143 ch
= (regs
->regs
[28]) >> 32;
144 cl
= (regs
->regs
[28]) & 0xffffffff;
145 printk("R26 : %08Lx%08Lx R27 : %08Lx%08Lx R28 : %08Lx%08Lx\n",
146 ah
, al
, bh
, bl
, ch
, cl
);
148 ah
= (regs
->regs
[29]) >> 32;
149 al
= (regs
->regs
[29]) & 0xffffffff;
150 bh
= (regs
->regs
[30]) >> 32;
151 bl
= (regs
->regs
[30]) & 0xffffffff;
152 ch
= (regs
->regs
[31]) >> 32;
153 cl
= (regs
->regs
[31]) & 0xffffffff;
154 printk("R29 : %08Lx%08Lx R30 : %08Lx%08Lx R31 : %08Lx%08Lx\n",
155 ah
, al
, bh
, bl
, ch
, cl
);
157 ah
= (regs
->regs
[32]) >> 32;
158 al
= (regs
->regs
[32]) & 0xffffffff;
159 bh
= (regs
->regs
[33]) >> 32;
160 bl
= (regs
->regs
[33]) & 0xffffffff;
161 ch
= (regs
->regs
[34]) >> 32;
162 cl
= (regs
->regs
[34]) & 0xffffffff;
163 printk("R32 : %08Lx%08Lx R33 : %08Lx%08Lx R34 : %08Lx%08Lx\n",
164 ah
, al
, bh
, bl
, ch
, cl
);
166 ah
= (regs
->regs
[35]) >> 32;
167 al
= (regs
->regs
[35]) & 0xffffffff;
168 bh
= (regs
->regs
[36]) >> 32;
169 bl
= (regs
->regs
[36]) & 0xffffffff;
170 ch
= (regs
->regs
[37]) >> 32;
171 cl
= (regs
->regs
[37]) & 0xffffffff;
172 printk("R35 : %08Lx%08Lx R36 : %08Lx%08Lx R37 : %08Lx%08Lx\n",
173 ah
, al
, bh
, bl
, ch
, cl
);
175 ah
= (regs
->regs
[38]) >> 32;
176 al
= (regs
->regs
[38]) & 0xffffffff;
177 bh
= (regs
->regs
[39]) >> 32;
178 bl
= (regs
->regs
[39]) & 0xffffffff;
179 ch
= (regs
->regs
[40]) >> 32;
180 cl
= (regs
->regs
[40]) & 0xffffffff;
181 printk("R38 : %08Lx%08Lx R39 : %08Lx%08Lx R40 : %08Lx%08Lx\n",
182 ah
, al
, bh
, bl
, ch
, cl
);
184 ah
= (regs
->regs
[41]) >> 32;
185 al
= (regs
->regs
[41]) & 0xffffffff;
186 bh
= (regs
->regs
[42]) >> 32;
187 bl
= (regs
->regs
[42]) & 0xffffffff;
188 ch
= (regs
->regs
[43]) >> 32;
189 cl
= (regs
->regs
[43]) & 0xffffffff;
190 printk("R41 : %08Lx%08Lx R42 : %08Lx%08Lx R43 : %08Lx%08Lx\n",
191 ah
, al
, bh
, bl
, ch
, cl
);
193 ah
= (regs
->regs
[44]) >> 32;
194 al
= (regs
->regs
[44]) & 0xffffffff;
195 bh
= (regs
->regs
[45]) >> 32;
196 bl
= (regs
->regs
[45]) & 0xffffffff;
197 ch
= (regs
->regs
[46]) >> 32;
198 cl
= (regs
->regs
[46]) & 0xffffffff;
199 printk("R44 : %08Lx%08Lx R45 : %08Lx%08Lx R46 : %08Lx%08Lx\n",
200 ah
, al
, bh
, bl
, ch
, cl
);
202 ah
= (regs
->regs
[47]) >> 32;
203 al
= (regs
->regs
[47]) & 0xffffffff;
204 bh
= (regs
->regs
[48]) >> 32;
205 bl
= (regs
->regs
[48]) & 0xffffffff;
206 ch
= (regs
->regs
[49]) >> 32;
207 cl
= (regs
->regs
[49]) & 0xffffffff;
208 printk("R47 : %08Lx%08Lx R48 : %08Lx%08Lx R49 : %08Lx%08Lx\n",
209 ah
, al
, bh
, bl
, ch
, cl
);
211 ah
= (regs
->regs
[50]) >> 32;
212 al
= (regs
->regs
[50]) & 0xffffffff;
213 bh
= (regs
->regs
[51]) >> 32;
214 bl
= (regs
->regs
[51]) & 0xffffffff;
215 ch
= (regs
->regs
[52]) >> 32;
216 cl
= (regs
->regs
[52]) & 0xffffffff;
217 printk("R50 : %08Lx%08Lx R51 : %08Lx%08Lx R52 : %08Lx%08Lx\n",
218 ah
, al
, bh
, bl
, ch
, cl
);
220 ah
= (regs
->regs
[53]) >> 32;
221 al
= (regs
->regs
[53]) & 0xffffffff;
222 bh
= (regs
->regs
[54]) >> 32;
223 bl
= (regs
->regs
[54]) & 0xffffffff;
224 ch
= (regs
->regs
[55]) >> 32;
225 cl
= (regs
->regs
[55]) & 0xffffffff;
226 printk("R53 : %08Lx%08Lx R54 : %08Lx%08Lx R55 : %08Lx%08Lx\n",
227 ah
, al
, bh
, bl
, ch
, cl
);
229 ah
= (regs
->regs
[56]) >> 32;
230 al
= (regs
->regs
[56]) & 0xffffffff;
231 bh
= (regs
->regs
[57]) >> 32;
232 bl
= (regs
->regs
[57]) & 0xffffffff;
233 ch
= (regs
->regs
[58]) >> 32;
234 cl
= (regs
->regs
[58]) & 0xffffffff;
235 printk("R56 : %08Lx%08Lx R57 : %08Lx%08Lx R58 : %08Lx%08Lx\n",
236 ah
, al
, bh
, bl
, ch
, cl
);
238 ah
= (regs
->regs
[59]) >> 32;
239 al
= (regs
->regs
[59]) & 0xffffffff;
240 bh
= (regs
->regs
[60]) >> 32;
241 bl
= (regs
->regs
[60]) & 0xffffffff;
242 ch
= (regs
->regs
[61]) >> 32;
243 cl
= (regs
->regs
[61]) & 0xffffffff;
244 printk("R59 : %08Lx%08Lx R60 : %08Lx%08Lx R61 : %08Lx%08Lx\n",
245 ah
, al
, bh
, bl
, ch
, cl
);
247 ah
= (regs
->regs
[62]) >> 32;
248 al
= (regs
->regs
[62]) & 0xffffffff;
249 bh
= (regs
->tregs
[0]) >> 32;
250 bl
= (regs
->tregs
[0]) & 0xffffffff;
251 ch
= (regs
->tregs
[1]) >> 32;
252 cl
= (regs
->tregs
[1]) & 0xffffffff;
253 printk("R62 : %08Lx%08Lx T0 : %08Lx%08Lx T1 : %08Lx%08Lx\n",
254 ah
, al
, bh
, bl
, ch
, cl
);
256 ah
= (regs
->tregs
[2]) >> 32;
257 al
= (regs
->tregs
[2]) & 0xffffffff;
258 bh
= (regs
->tregs
[3]) >> 32;
259 bl
= (regs
->tregs
[3]) & 0xffffffff;
260 ch
= (regs
->tregs
[4]) >> 32;
261 cl
= (regs
->tregs
[4]) & 0xffffffff;
262 printk("T2 : %08Lx%08Lx T3 : %08Lx%08Lx T4 : %08Lx%08Lx\n",
263 ah
, al
, bh
, bl
, ch
, cl
);
265 ah
= (regs
->tregs
[5]) >> 32;
266 al
= (regs
->tregs
[5]) & 0xffffffff;
267 bh
= (regs
->tregs
[6]) >> 32;
268 bl
= (regs
->tregs
[6]) & 0xffffffff;
269 ch
= (regs
->tregs
[7]) >> 32;
270 cl
= (regs
->tregs
[7]) & 0xffffffff;
271 printk("T5 : %08Lx%08Lx T6 : %08Lx%08Lx T7 : %08Lx%08Lx\n",
272 ah
, al
, bh
, bl
, ch
, cl
);
275 * If we're in kernel mode, dump the stack too..
277 if (!user_mode(regs
)) {
278 void show_stack(struct task_struct
*tsk
, unsigned long *sp
);
279 unsigned long sp
= regs
->regs
[15] & 0xffffffff;
280 struct task_struct
*tsk
= get_current();
282 tsk
->thread
.kregs
= regs
;
284 show_stack(tsk
, (unsigned long *)sp
);
289 * Free current thread data structures etc..
291 void exit_thread(void)
294 * See arch/sparc/kernel/process.c for the precedent for doing
297 * The SH-5 FPU save/restore approach relies on
298 * last_task_used_math pointing to a live task_struct. When
299 * another task tries to use the FPU for the 1st time, the FPUDIS
300 * trap handling (see arch/sh/kernel/cpu/sh5/fpu.c) will save the
301 * existing FPU state to the FP regs field within
302 * last_task_used_math before re-loading the new task's FPU state
303 * (or initialising it if the FPU has been used before). So if
304 * last_task_used_math is stale, and its page has already been
305 * re-allocated for another use, the consequences are rather
306 * grim. Unless we null it here, there is no other path through
307 * which it would get safely nulled.
310 if (last_task_used_math
== current
) {
311 last_task_used_math
= NULL
;
316 void flush_thread(void)
319 /* Called by fs/exec.c (setup_new_exec) to remove traces of a
320 * previously running executable. */
322 if (last_task_used_math
== current
) {
323 last_task_used_math
= NULL
;
325 /* Force FPU state to be reinitialised after exec */
329 /* if we are a kernel thread, about to change to user thread,
332 if(current
->thread
.kregs
==&fake_swapper_regs
) {
333 current
->thread
.kregs
=
334 ((struct pt_regs
*)(THREAD_SIZE
+ (unsigned long) current
) - 1);
335 current
->thread
.uregs
= current
->thread
.kregs
;
339 void release_thread(struct task_struct
*dead_task
)
344 /* Fill in the fpu structure for a core dump.. */
345 int dump_fpu(struct pt_regs
*regs
, elf_fpregset_t
*fpu
)
349 struct task_struct
*tsk
= current
;
351 fpvalid
= !!tsk_used_math(tsk
);
353 if (current
== last_task_used_math
) {
357 last_task_used_math
= 0;
361 memcpy(fpu
, &tsk
->thread
.xstate
->hardfpu
, sizeof(*fpu
));
366 return 0; /* Task didn't use the fpu at all. */
369 EXPORT_SYMBOL(dump_fpu
);
371 asmlinkage
void ret_from_fork(void);
372 asmlinkage
void ret_from_kernel_thread(void);
374 int copy_thread(unsigned long clone_flags
, unsigned long usp
,
375 unsigned long arg
, struct task_struct
*p
)
377 struct pt_regs
*childregs
, *regs
= current_pt_regs();
380 /* can't happen for a kernel thread */
381 if (last_task_used_math
== current
) {
385 last_task_used_math
= NULL
;
386 current_pt_regs()->sr
|= SR_FD
;
389 /* Copy from sh version */
390 childregs
= (struct pt_regs
*)(THREAD_SIZE
+ task_stack_page(p
)) - 1;
391 p
->thread
.sp
= (unsigned long) childregs
;
393 if (unlikely(p
->flags
& PF_KTHREAD
)) {
394 memset(childregs
, 0, sizeof(struct pt_regs
));
395 childregs
->regs
[2] = (unsigned long)arg
;
396 childregs
->regs
[3] = (unsigned long)fn
;
397 childregs
->sr
= (1 << 30); /* not user_mode */
398 childregs
->sr
|= SR_FD
; /* Invalidate FPU flag */
399 p
->thread
.pc
= (unsigned long) ret_from_kernel_thread
;
402 *childregs
= *current_pt_regs();
405 * Sign extend the edited stack.
406 * Note that thread.pc and thread.pc will stay
407 * 32-bit wide and context switch must take care
408 * of NEFF sign extension.
411 childregs
->regs
[15] = neff_sign_extend(usp
);
412 p
->thread
.uregs
= childregs
;
414 childregs
->regs
[9] = 0; /* Set return value for child */
415 childregs
->sr
|= SR_FD
; /* Invalidate FPU flag */
417 p
->thread
.pc
= (unsigned long) ret_from_fork
;
422 #ifdef CONFIG_FRAME_POINTER
423 static int in_sh64_switch_to(unsigned long pc
)
425 extern char __sh64_switch_to_end
;
426 /* For a sleeping task, the PC is somewhere in the middle of the function,
427 so we don't have to worry about masking the LSB off */
428 return (pc
>= (unsigned long) sh64_switch_to
) &&
429 (pc
< (unsigned long) &__sh64_switch_to_end
);
433 unsigned long get_wchan(struct task_struct
*p
)
437 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
441 * The same comment as on the Alpha applies here, too ...
443 pc
= thread_saved_pc(p
);
445 #ifdef CONFIG_FRAME_POINTER
446 if (in_sh64_switch_to(pc
)) {
447 unsigned long schedule_fp
;
448 unsigned long sh64_switch_to_fp
;
449 unsigned long schedule_caller_pc
;
451 sh64_switch_to_fp
= (long) p
->thread
.sp
;
452 /* r14 is saved at offset 4 in the sh64_switch_to frame */
453 schedule_fp
= *(unsigned long *) (long)(sh64_switch_to_fp
+ 4);
455 /* and the caller of 'schedule' is (currently!) saved at offset 24
456 in the frame of schedule (from disasm) */
457 schedule_caller_pc
= *(unsigned long *) (long)(schedule_fp
+ 24);
458 return schedule_caller_pc
;