2 * Copyright (C) 2004-2006 Atmel Corporation
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 #include <linux/sched.h>
9 #include <linux/module.h>
10 #include <linux/kallsyms.h>
13 #include <linux/ptrace.h>
14 #include <linux/reboot.h>
15 #include <linux/tick.h>
16 #include <linux/uaccess.h>
17 #include <linux/unistd.h>
19 #include <asm/sysreg.h>
24 void (*pm_power_off
)(void);
25 EXPORT_SYMBOL(pm_power_off
);
28 * This file handles the architecture-dependent parts of process handling..
33 /* endless idle loop with no priority at all */
35 tick_nohz_stop_sched_tick(1);
36 while (!need_resched())
38 tick_nohz_restart_sched_tick();
39 preempt_enable_no_resched();
45 void machine_halt(void)
48 * Enter Stop mode. The 32 kHz oscillator will keep running so
49 * the RTC will keep the time properly and the system will
52 asm volatile("sleep 3\n\t"
56 void machine_power_off(void)
62 void machine_restart(char *cmd
)
64 ocd_write(DC
, (1 << OCD_DC_DBE_BIT
));
65 ocd_write(DC
, (1 << OCD_DC_RES_BIT
));
70 * PC is actually discarded when returning from a system call -- the
71 * return address must be stored in LR. This function will make sure
72 * LR points to do_exit before starting the thread.
74 * Also, when returning from fork(), r12 is 0, so we must copy the
77 * r0 : The argument to the main thread function
78 * r1 : The address of do_exit
79 * r2 : The address of the main thread function
81 asmlinkage
extern void kernel_thread_helper(void);
82 __asm__(" .type kernel_thread_helper, @function\n"
83 "kernel_thread_helper:\n"
87 " .size kernel_thread_helper, . - kernel_thread_helper");
89 int kernel_thread(int (*fn
)(void *), void *arg
, unsigned long flags
)
93 memset(®s
, 0, sizeof(regs
));
95 regs
.r0
= (unsigned long)arg
;
96 regs
.r1
= (unsigned long)fn
;
97 regs
.r2
= (unsigned long)do_exit
;
98 regs
.lr
= (unsigned long)kernel_thread_helper
;
99 regs
.pc
= (unsigned long)kernel_thread_helper
;
100 regs
.sr
= MODE_SUPERVISOR
;
102 return do_fork(flags
| CLONE_VM
| CLONE_UNTRACED
,
103 0, ®s
, 0, NULL
, NULL
);
105 EXPORT_SYMBOL(kernel_thread
);
108 * Free current thread data structures etc
110 void exit_thread(void)
112 ocd_disable(current
);
115 void flush_thread(void)
120 void release_thread(struct task_struct
*dead_task
)
125 static void dump_mem(const char *str
, const char *log_lvl
,
126 unsigned long bottom
, unsigned long top
)
131 printk("%s%s(0x%08lx to 0x%08lx)\n", log_lvl
, str
, bottom
, top
);
133 for (p
= bottom
& ~31; p
< top
; ) {
134 printk("%s%04lx: ", log_lvl
, p
& 0xffff);
136 for (i
= 0; i
< 8; i
++, p
+= 4) {
139 if (p
< bottom
|| p
>= top
)
142 if (__get_user(val
, (unsigned int __user
*)p
)) {
146 printk("%08x ", val
);
156 static inline int valid_stack_ptr(struct thread_info
*tinfo
, unsigned long p
)
158 return (p
> (unsigned long)tinfo
)
159 && (p
< (unsigned long)tinfo
+ THREAD_SIZE
- 3);
162 #ifdef CONFIG_FRAME_POINTER
163 static void show_trace_log_lvl(struct task_struct
*tsk
, unsigned long *sp
,
164 struct pt_regs
*regs
, const char *log_lvl
)
166 unsigned long lr
, fp
;
167 struct thread_info
*tinfo
;
171 else if (tsk
== current
)
172 asm("mov %0, r7" : "=r"(fp
));
174 fp
= tsk
->thread
.cpu_context
.r7
;
177 * Walk the stack as long as the frame pointer (a) is within
178 * the kernel stack of the task, and (b) it doesn't move
181 tinfo
= task_thread_info(tsk
);
182 printk("%sCall trace:\n", log_lvl
);
183 while (valid_stack_ptr(tinfo
, fp
)) {
184 unsigned long new_fp
;
186 lr
= *(unsigned long *)fp
;
187 #ifdef CONFIG_KALLSYMS
188 printk("%s [<%08lx>] ", log_lvl
, lr
);
190 printk(" [<%08lx>] ", lr
);
192 print_symbol("%s\n", lr
);
194 new_fp
= *(unsigned long *)(fp
+ 4);
202 static void show_trace_log_lvl(struct task_struct
*tsk
, unsigned long *sp
,
203 struct pt_regs
*regs
, const char *log_lvl
)
207 printk("%sCall trace:\n", log_lvl
);
209 while (!kstack_end(sp
)) {
211 if (kernel_text_address(addr
)) {
212 #ifdef CONFIG_KALLSYMS
213 printk("%s [<%08lx>] ", log_lvl
, addr
);
215 printk(" [<%08lx>] ", addr
);
217 print_symbol("%s\n", addr
);
224 void show_stack_log_lvl(struct task_struct
*tsk
, unsigned long sp
,
225 struct pt_regs
*regs
, const char *log_lvl
)
227 struct thread_info
*tinfo
;
231 sp
= tsk
->thread
.cpu_context
.ksp
;
233 sp
= (unsigned long)&tinfo
;
238 tinfo
= task_thread_info(tsk
);
240 if (valid_stack_ptr(tinfo
, sp
)) {
241 dump_mem("Stack: ", log_lvl
, sp
,
242 THREAD_SIZE
+ (unsigned long)tinfo
);
243 show_trace_log_lvl(tsk
, (unsigned long *)sp
, regs
, log_lvl
);
247 void show_stack(struct task_struct
*tsk
, unsigned long *stack
)
249 show_stack_log_lvl(tsk
, (unsigned long)stack
, NULL
, "");
252 void dump_stack(void)
256 show_trace_log_lvl(current
, &stack
, NULL
, "");
258 EXPORT_SYMBOL(dump_stack
);
260 static const char *cpu_modes
[] = {
261 "Application", "Supervisor", "Interrupt level 0", "Interrupt level 1",
262 "Interrupt level 2", "Interrupt level 3", "Exception", "NMI"
265 void show_regs_log_lvl(struct pt_regs
*regs
, const char *log_lvl
)
267 unsigned long sp
= regs
->sp
;
268 unsigned long lr
= regs
->lr
;
269 unsigned long mode
= (regs
->sr
& MODE_MASK
) >> MODE_SHIFT
;
271 if (!user_mode(regs
)) {
272 sp
= (unsigned long)regs
+ FRAME_SIZE_FULL
;
274 printk("%s", log_lvl
);
275 print_symbol("PC is at %s\n", instruction_pointer(regs
));
276 printk("%s", log_lvl
);
277 print_symbol("LR is at %s\n", lr
);
280 printk("%spc : [<%08lx>] lr : [<%08lx>] %s\n"
281 "%ssp : %08lx r12: %08lx r11: %08lx\n",
282 log_lvl
, instruction_pointer(regs
), lr
, print_tainted(),
283 log_lvl
, sp
, regs
->r12
, regs
->r11
);
284 printk("%sr10: %08lx r9 : %08lx r8 : %08lx\n",
285 log_lvl
, regs
->r10
, regs
->r9
, regs
->r8
);
286 printk("%sr7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n",
287 log_lvl
, regs
->r7
, regs
->r6
, regs
->r5
, regs
->r4
);
288 printk("%sr3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n",
289 log_lvl
, regs
->r3
, regs
->r2
, regs
->r1
, regs
->r0
);
290 printk("%sFlags: %c%c%c%c%c\n", log_lvl
,
291 regs
->sr
& SR_Q
? 'Q' : 'q',
292 regs
->sr
& SR_V
? 'V' : 'v',
293 regs
->sr
& SR_N
? 'N' : 'n',
294 regs
->sr
& SR_Z
? 'Z' : 'z',
295 regs
->sr
& SR_C
? 'C' : 'c');
296 printk("%sMode bits: %c%c%c%c%c%c%c%c%c%c\n", log_lvl
,
297 regs
->sr
& SR_H
? 'H' : 'h',
298 regs
->sr
& SR_J
? 'J' : 'j',
299 regs
->sr
& SR_DM
? 'M' : 'm',
300 regs
->sr
& SR_D
? 'D' : 'd',
301 regs
->sr
& SR_EM
? 'E' : 'e',
302 regs
->sr
& SR_I3M
? '3' : '.',
303 regs
->sr
& SR_I2M
? '2' : '.',
304 regs
->sr
& SR_I1M
? '1' : '.',
305 regs
->sr
& SR_I0M
? '0' : '.',
306 regs
->sr
& SR_GM
? 'G' : 'g');
307 printk("%sCPU Mode: %s\n", log_lvl
, cpu_modes
[mode
]);
308 printk("%sProcess: %s [%d] (task: %p thread: %p)\n",
309 log_lvl
, current
->comm
, current
->pid
, current
,
310 task_thread_info(current
));
313 void show_regs(struct pt_regs
*regs
)
315 unsigned long sp
= regs
->sp
;
317 if (!user_mode(regs
))
318 sp
= (unsigned long)regs
+ FRAME_SIZE_FULL
;
320 show_regs_log_lvl(regs
, "");
321 show_trace_log_lvl(current
, (unsigned long *)sp
, regs
, "");
323 EXPORT_SYMBOL(show_regs
);
325 /* Fill in the fpu structure for a core dump. This is easy -- we don't have any */
326 int dump_fpu(struct pt_regs
*regs
, elf_fpregset_t
*fpu
)
332 asmlinkage
void ret_from_fork(void);
334 int copy_thread(int nr
, unsigned long clone_flags
, unsigned long usp
,
335 unsigned long unused
,
336 struct task_struct
*p
, struct pt_regs
*regs
)
338 struct pt_regs
*childregs
;
340 childregs
= ((struct pt_regs
*)(THREAD_SIZE
+ (unsigned long)task_stack_page(p
))) - 1;
346 childregs
->sp
= (unsigned long)task_stack_page(p
) + THREAD_SIZE
;
348 childregs
->r12
= 0; /* Set return value for child */
350 p
->thread
.cpu_context
.sr
= MODE_SUPERVISOR
| SR_GM
;
351 p
->thread
.cpu_context
.ksp
= (unsigned long)childregs
;
352 p
->thread
.cpu_context
.pc
= (unsigned long)ret_from_fork
;
354 clear_tsk_thread_flag(p
, TIF_DEBUG
);
355 if ((clone_flags
& CLONE_PTRACE
) && test_thread_flag(TIF_DEBUG
))
361 /* r12-r8 are dummy parameters to force the compiler to use the stack */
362 asmlinkage
int sys_fork(struct pt_regs
*regs
)
364 return do_fork(SIGCHLD
, regs
->sp
, regs
, 0, NULL
, NULL
);
367 asmlinkage
int sys_clone(unsigned long clone_flags
, unsigned long newsp
,
368 unsigned long parent_tidptr
,
369 unsigned long child_tidptr
, struct pt_regs
*regs
)
373 return do_fork(clone_flags
, newsp
, regs
, 0,
374 (int __user
*)parent_tidptr
,
375 (int __user
*)child_tidptr
);
378 asmlinkage
int sys_vfork(struct pt_regs
*regs
)
380 return do_fork(CLONE_VFORK
| CLONE_VM
| SIGCHLD
, regs
->sp
, regs
,
384 asmlinkage
int sys_execve(char __user
*ufilename
, char __user
*__user
*uargv
,
385 char __user
*__user
*uenvp
, struct pt_regs
*regs
)
390 filename
= getname(ufilename
);
391 error
= PTR_ERR(filename
);
392 if (IS_ERR(filename
))
395 error
= do_execve(filename
, uargv
, uenvp
, regs
);
397 current
->ptrace
&= ~PT_DTRACE
;
406 * This function is supposed to answer the question "who called
409 unsigned long get_wchan(struct task_struct
*p
)
412 unsigned long stack_page
;
414 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
417 stack_page
= (unsigned long)task_stack_page(p
);
421 * The stored value of PC is either the address right after
422 * the call to __switch_to() or ret_from_fork.
424 pc
= thread_saved_pc(p
);
425 if (in_sched_functions(pc
)) {
426 #ifdef CONFIG_FRAME_POINTER
427 unsigned long fp
= p
->thread
.cpu_context
.r7
;
428 BUG_ON(fp
< stack_page
|| fp
> (THREAD_SIZE
+ stack_page
));
429 pc
= *(unsigned long *)fp
;
432 * We depend on the frame size of schedule here, which
433 * is actually quite ugly. It might be possible to
434 * determine the frame size automatically at build
435 * time by doing this:
437 * - disassemble the resulting sched.o
438 * - look for 'sub sp,??' shortly after '<schedule>:'
440 unsigned long sp
= p
->thread
.cpu_context
.ksp
+ 16;
441 BUG_ON(sp
< stack_page
|| sp
> (THREAD_SIZE
+ stack_page
));
442 pc
= *(unsigned long *)sp
;