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 <linux/sched/debug.h>
29 #include <asm/syscalls.h>
30 #include <linux/uaccess.h>
31 #include <asm/pgtable.h>
32 #include <asm/mmu_context.h>
34 #include <asm/switch_to.h>
36 struct task_struct
*last_task_used_math
= NULL
;
37 struct pt_regs fake_swapper_regs
= { 0, };
39 void show_regs(struct pt_regs
*regs
)
41 unsigned long long ah
, al
, bh
, bl
, ch
, cl
;
44 show_regs_print_info(KERN_DEFAULT
);
46 ah
= (regs
->pc
) >> 32;
47 al
= (regs
->pc
) & 0xffffffff;
48 bh
= (regs
->regs
[18]) >> 32;
49 bl
= (regs
->regs
[18]) & 0xffffffff;
50 ch
= (regs
->regs
[15]) >> 32;
51 cl
= (regs
->regs
[15]) & 0xffffffff;
52 printk("PC : %08Lx%08Lx LINK: %08Lx%08Lx SP : %08Lx%08Lx\n",
53 ah
, al
, bh
, bl
, ch
, cl
);
55 ah
= (regs
->sr
) >> 32;
56 al
= (regs
->sr
) & 0xffffffff;
57 asm volatile ("getcon " __TEA
", %0" : "=r" (bh
));
58 asm volatile ("getcon " __TEA
", %0" : "=r" (bl
));
60 bl
= (bl
) & 0xffffffff;
61 asm volatile ("getcon " __KCR0
", %0" : "=r" (ch
));
62 asm volatile ("getcon " __KCR0
", %0" : "=r" (cl
));
64 cl
= (cl
) & 0xffffffff;
65 printk("SR : %08Lx%08Lx TEA : %08Lx%08Lx KCR0: %08Lx%08Lx\n",
66 ah
, al
, bh
, bl
, ch
, cl
);
68 ah
= (regs
->regs
[0]) >> 32;
69 al
= (regs
->regs
[0]) & 0xffffffff;
70 bh
= (regs
->regs
[1]) >> 32;
71 bl
= (regs
->regs
[1]) & 0xffffffff;
72 ch
= (regs
->regs
[2]) >> 32;
73 cl
= (regs
->regs
[2]) & 0xffffffff;
74 printk("R0 : %08Lx%08Lx R1 : %08Lx%08Lx R2 : %08Lx%08Lx\n",
75 ah
, al
, bh
, bl
, ch
, cl
);
77 ah
= (regs
->regs
[3]) >> 32;
78 al
= (regs
->regs
[3]) & 0xffffffff;
79 bh
= (regs
->regs
[4]) >> 32;
80 bl
= (regs
->regs
[4]) & 0xffffffff;
81 ch
= (regs
->regs
[5]) >> 32;
82 cl
= (regs
->regs
[5]) & 0xffffffff;
83 printk("R3 : %08Lx%08Lx R4 : %08Lx%08Lx R5 : %08Lx%08Lx\n",
84 ah
, al
, bh
, bl
, ch
, cl
);
86 ah
= (regs
->regs
[6]) >> 32;
87 al
= (regs
->regs
[6]) & 0xffffffff;
88 bh
= (regs
->regs
[7]) >> 32;
89 bl
= (regs
->regs
[7]) & 0xffffffff;
90 ch
= (regs
->regs
[8]) >> 32;
91 cl
= (regs
->regs
[8]) & 0xffffffff;
92 printk("R6 : %08Lx%08Lx R7 : %08Lx%08Lx R8 : %08Lx%08Lx\n",
93 ah
, al
, bh
, bl
, ch
, cl
);
95 ah
= (regs
->regs
[9]) >> 32;
96 al
= (regs
->regs
[9]) & 0xffffffff;
97 bh
= (regs
->regs
[10]) >> 32;
98 bl
= (regs
->regs
[10]) & 0xffffffff;
99 ch
= (regs
->regs
[11]) >> 32;
100 cl
= (regs
->regs
[11]) & 0xffffffff;
101 printk("R9 : %08Lx%08Lx R10 : %08Lx%08Lx R11 : %08Lx%08Lx\n",
102 ah
, al
, bh
, bl
, ch
, cl
);
104 ah
= (regs
->regs
[12]) >> 32;
105 al
= (regs
->regs
[12]) & 0xffffffff;
106 bh
= (regs
->regs
[13]) >> 32;
107 bl
= (regs
->regs
[13]) & 0xffffffff;
108 ch
= (regs
->regs
[14]) >> 32;
109 cl
= (regs
->regs
[14]) & 0xffffffff;
110 printk("R12 : %08Lx%08Lx R13 : %08Lx%08Lx R14 : %08Lx%08Lx\n",
111 ah
, al
, bh
, bl
, ch
, cl
);
113 ah
= (regs
->regs
[16]) >> 32;
114 al
= (regs
->regs
[16]) & 0xffffffff;
115 bh
= (regs
->regs
[17]) >> 32;
116 bl
= (regs
->regs
[17]) & 0xffffffff;
117 ch
= (regs
->regs
[19]) >> 32;
118 cl
= (regs
->regs
[19]) & 0xffffffff;
119 printk("R16 : %08Lx%08Lx R17 : %08Lx%08Lx R19 : %08Lx%08Lx\n",
120 ah
, al
, bh
, bl
, ch
, cl
);
122 ah
= (regs
->regs
[20]) >> 32;
123 al
= (regs
->regs
[20]) & 0xffffffff;
124 bh
= (regs
->regs
[21]) >> 32;
125 bl
= (regs
->regs
[21]) & 0xffffffff;
126 ch
= (regs
->regs
[22]) >> 32;
127 cl
= (regs
->regs
[22]) & 0xffffffff;
128 printk("R20 : %08Lx%08Lx R21 : %08Lx%08Lx R22 : %08Lx%08Lx\n",
129 ah
, al
, bh
, bl
, ch
, cl
);
131 ah
= (regs
->regs
[23]) >> 32;
132 al
= (regs
->regs
[23]) & 0xffffffff;
133 bh
= (regs
->regs
[24]) >> 32;
134 bl
= (regs
->regs
[24]) & 0xffffffff;
135 ch
= (regs
->regs
[25]) >> 32;
136 cl
= (regs
->regs
[25]) & 0xffffffff;
137 printk("R23 : %08Lx%08Lx R24 : %08Lx%08Lx R25 : %08Lx%08Lx\n",
138 ah
, al
, bh
, bl
, ch
, cl
);
140 ah
= (regs
->regs
[26]) >> 32;
141 al
= (regs
->regs
[26]) & 0xffffffff;
142 bh
= (regs
->regs
[27]) >> 32;
143 bl
= (regs
->regs
[27]) & 0xffffffff;
144 ch
= (regs
->regs
[28]) >> 32;
145 cl
= (regs
->regs
[28]) & 0xffffffff;
146 printk("R26 : %08Lx%08Lx R27 : %08Lx%08Lx R28 : %08Lx%08Lx\n",
147 ah
, al
, bh
, bl
, ch
, cl
);
149 ah
= (regs
->regs
[29]) >> 32;
150 al
= (regs
->regs
[29]) & 0xffffffff;
151 bh
= (regs
->regs
[30]) >> 32;
152 bl
= (regs
->regs
[30]) & 0xffffffff;
153 ch
= (regs
->regs
[31]) >> 32;
154 cl
= (regs
->regs
[31]) & 0xffffffff;
155 printk("R29 : %08Lx%08Lx R30 : %08Lx%08Lx R31 : %08Lx%08Lx\n",
156 ah
, al
, bh
, bl
, ch
, cl
);
158 ah
= (regs
->regs
[32]) >> 32;
159 al
= (regs
->regs
[32]) & 0xffffffff;
160 bh
= (regs
->regs
[33]) >> 32;
161 bl
= (regs
->regs
[33]) & 0xffffffff;
162 ch
= (regs
->regs
[34]) >> 32;
163 cl
= (regs
->regs
[34]) & 0xffffffff;
164 printk("R32 : %08Lx%08Lx R33 : %08Lx%08Lx R34 : %08Lx%08Lx\n",
165 ah
, al
, bh
, bl
, ch
, cl
);
167 ah
= (regs
->regs
[35]) >> 32;
168 al
= (regs
->regs
[35]) & 0xffffffff;
169 bh
= (regs
->regs
[36]) >> 32;
170 bl
= (regs
->regs
[36]) & 0xffffffff;
171 ch
= (regs
->regs
[37]) >> 32;
172 cl
= (regs
->regs
[37]) & 0xffffffff;
173 printk("R35 : %08Lx%08Lx R36 : %08Lx%08Lx R37 : %08Lx%08Lx\n",
174 ah
, al
, bh
, bl
, ch
, cl
);
176 ah
= (regs
->regs
[38]) >> 32;
177 al
= (regs
->regs
[38]) & 0xffffffff;
178 bh
= (regs
->regs
[39]) >> 32;
179 bl
= (regs
->regs
[39]) & 0xffffffff;
180 ch
= (regs
->regs
[40]) >> 32;
181 cl
= (regs
->regs
[40]) & 0xffffffff;
182 printk("R38 : %08Lx%08Lx R39 : %08Lx%08Lx R40 : %08Lx%08Lx\n",
183 ah
, al
, bh
, bl
, ch
, cl
);
185 ah
= (regs
->regs
[41]) >> 32;
186 al
= (regs
->regs
[41]) & 0xffffffff;
187 bh
= (regs
->regs
[42]) >> 32;
188 bl
= (regs
->regs
[42]) & 0xffffffff;
189 ch
= (regs
->regs
[43]) >> 32;
190 cl
= (regs
->regs
[43]) & 0xffffffff;
191 printk("R41 : %08Lx%08Lx R42 : %08Lx%08Lx R43 : %08Lx%08Lx\n",
192 ah
, al
, bh
, bl
, ch
, cl
);
194 ah
= (regs
->regs
[44]) >> 32;
195 al
= (regs
->regs
[44]) & 0xffffffff;
196 bh
= (regs
->regs
[45]) >> 32;
197 bl
= (regs
->regs
[45]) & 0xffffffff;
198 ch
= (regs
->regs
[46]) >> 32;
199 cl
= (regs
->regs
[46]) & 0xffffffff;
200 printk("R44 : %08Lx%08Lx R45 : %08Lx%08Lx R46 : %08Lx%08Lx\n",
201 ah
, al
, bh
, bl
, ch
, cl
);
203 ah
= (regs
->regs
[47]) >> 32;
204 al
= (regs
->regs
[47]) & 0xffffffff;
205 bh
= (regs
->regs
[48]) >> 32;
206 bl
= (regs
->regs
[48]) & 0xffffffff;
207 ch
= (regs
->regs
[49]) >> 32;
208 cl
= (regs
->regs
[49]) & 0xffffffff;
209 printk("R47 : %08Lx%08Lx R48 : %08Lx%08Lx R49 : %08Lx%08Lx\n",
210 ah
, al
, bh
, bl
, ch
, cl
);
212 ah
= (regs
->regs
[50]) >> 32;
213 al
= (regs
->regs
[50]) & 0xffffffff;
214 bh
= (regs
->regs
[51]) >> 32;
215 bl
= (regs
->regs
[51]) & 0xffffffff;
216 ch
= (regs
->regs
[52]) >> 32;
217 cl
= (regs
->regs
[52]) & 0xffffffff;
218 printk("R50 : %08Lx%08Lx R51 : %08Lx%08Lx R52 : %08Lx%08Lx\n",
219 ah
, al
, bh
, bl
, ch
, cl
);
221 ah
= (regs
->regs
[53]) >> 32;
222 al
= (regs
->regs
[53]) & 0xffffffff;
223 bh
= (regs
->regs
[54]) >> 32;
224 bl
= (regs
->regs
[54]) & 0xffffffff;
225 ch
= (regs
->regs
[55]) >> 32;
226 cl
= (regs
->regs
[55]) & 0xffffffff;
227 printk("R53 : %08Lx%08Lx R54 : %08Lx%08Lx R55 : %08Lx%08Lx\n",
228 ah
, al
, bh
, bl
, ch
, cl
);
230 ah
= (regs
->regs
[56]) >> 32;
231 al
= (regs
->regs
[56]) & 0xffffffff;
232 bh
= (regs
->regs
[57]) >> 32;
233 bl
= (regs
->regs
[57]) & 0xffffffff;
234 ch
= (regs
->regs
[58]) >> 32;
235 cl
= (regs
->regs
[58]) & 0xffffffff;
236 printk("R56 : %08Lx%08Lx R57 : %08Lx%08Lx R58 : %08Lx%08Lx\n",
237 ah
, al
, bh
, bl
, ch
, cl
);
239 ah
= (regs
->regs
[59]) >> 32;
240 al
= (regs
->regs
[59]) & 0xffffffff;
241 bh
= (regs
->regs
[60]) >> 32;
242 bl
= (regs
->regs
[60]) & 0xffffffff;
243 ch
= (regs
->regs
[61]) >> 32;
244 cl
= (regs
->regs
[61]) & 0xffffffff;
245 printk("R59 : %08Lx%08Lx R60 : %08Lx%08Lx R61 : %08Lx%08Lx\n",
246 ah
, al
, bh
, bl
, ch
, cl
);
248 ah
= (regs
->regs
[62]) >> 32;
249 al
= (regs
->regs
[62]) & 0xffffffff;
250 bh
= (regs
->tregs
[0]) >> 32;
251 bl
= (regs
->tregs
[0]) & 0xffffffff;
252 ch
= (regs
->tregs
[1]) >> 32;
253 cl
= (regs
->tregs
[1]) & 0xffffffff;
254 printk("R62 : %08Lx%08Lx T0 : %08Lx%08Lx T1 : %08Lx%08Lx\n",
255 ah
, al
, bh
, bl
, ch
, cl
);
257 ah
= (regs
->tregs
[2]) >> 32;
258 al
= (regs
->tregs
[2]) & 0xffffffff;
259 bh
= (regs
->tregs
[3]) >> 32;
260 bl
= (regs
->tregs
[3]) & 0xffffffff;
261 ch
= (regs
->tregs
[4]) >> 32;
262 cl
= (regs
->tregs
[4]) & 0xffffffff;
263 printk("T2 : %08Lx%08Lx T3 : %08Lx%08Lx T4 : %08Lx%08Lx\n",
264 ah
, al
, bh
, bl
, ch
, cl
);
266 ah
= (regs
->tregs
[5]) >> 32;
267 al
= (regs
->tregs
[5]) & 0xffffffff;
268 bh
= (regs
->tregs
[6]) >> 32;
269 bl
= (regs
->tregs
[6]) & 0xffffffff;
270 ch
= (regs
->tregs
[7]) >> 32;
271 cl
= (regs
->tregs
[7]) & 0xffffffff;
272 printk("T5 : %08Lx%08Lx T6 : %08Lx%08Lx T7 : %08Lx%08Lx\n",
273 ah
, al
, bh
, bl
, ch
, cl
);
276 * If we're in kernel mode, dump the stack too..
278 if (!user_mode(regs
)) {
279 void show_stack(struct task_struct
*tsk
, unsigned long *sp
);
280 unsigned long sp
= regs
->regs
[15] & 0xffffffff;
281 struct task_struct
*tsk
= get_current();
283 tsk
->thread
.kregs
= regs
;
285 show_stack(tsk
, (unsigned long *)sp
);
290 * Free current thread data structures etc..
292 void exit_thread(struct task_struct
*tsk
)
295 * See arch/sparc/kernel/process.c for the precedent for doing
298 * The SH-5 FPU save/restore approach relies on
299 * last_task_used_math pointing to a live task_struct. When
300 * another task tries to use the FPU for the 1st time, the FPUDIS
301 * trap handling (see arch/sh/kernel/cpu/sh5/fpu.c) will save the
302 * existing FPU state to the FP regs field within
303 * last_task_used_math before re-loading the new task's FPU state
304 * (or initialising it if the FPU has been used before). So if
305 * last_task_used_math is stale, and its page has already been
306 * re-allocated for another use, the consequences are rather
307 * grim. Unless we null it here, there is no other path through
308 * which it would get safely nulled.
311 if (last_task_used_math
== tsk
)
312 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
;
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)usp
;
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
;