sh: Proper show_stack/show_trace() implementation.
[linux-2.6.git] / arch / sh / kernel / process.c
1 /* $Id: process.c,v 1.28 2004/05/05 16:54:23 lethal Exp $
2  *
3  *  linux/arch/sh/kernel/process.c
4  *
5  *  Copyright (C) 1995  Linus Torvalds
6  *
7  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
8  *                   Copyright (C) 2006 Lineo Solutions Inc. support SH4A UBC
9  */
10
11 /*
12  * This file handles the architecture-dependent parts of process handling..
13  */
14
15 #include <linux/module.h>
16 #include <linux/unistd.h>
17 #include <linux/mm.h>
18 #include <linux/elfcore.h>
19 #include <linux/a.out.h>
20 #include <linux/slab.h>
21 #include <linux/pm.h>
22 #include <linux/ptrace.h>
23 #include <linux/kallsyms.h>
24 #include <linux/kexec.h>
25
26 #include <asm/io.h>
27 #include <asm/uaccess.h>
28 #include <asm/mmu_context.h>
29 #include <asm/elf.h>
30 #include <asm/ubc.h>
31
32 static int hlt_counter=0;
33
34 int ubc_usercnt = 0;
35
36 #define HARD_IDLE_TIMEOUT (HZ / 3)
37
38 void (*pm_idle)(void);
39
40 void (*pm_power_off)(void);
41 EXPORT_SYMBOL(pm_power_off);
42
43 void disable_hlt(void)
44 {
45         hlt_counter++;
46 }
47
48 EXPORT_SYMBOL(disable_hlt);
49
50 void enable_hlt(void)
51 {
52         hlt_counter--;
53 }
54
55 EXPORT_SYMBOL(enable_hlt);
56
57 void default_idle(void)
58 {
59         if (!hlt_counter)
60                 cpu_sleep();
61         else
62                 cpu_relax();
63 }
64
65 void cpu_idle(void)
66 {
67         /* endless idle loop with no priority at all */
68         while (1) {
69                 void (*idle)(void) = pm_idle;
70
71                 if (!idle)
72                         idle = default_idle;
73
74                 while (!need_resched())
75                         idle();
76
77                 preempt_enable_no_resched();
78                 schedule();
79                 preempt_disable();
80         }
81 }
82
83 void machine_restart(char * __unused)
84 {
85         /* SR.BL=1 and invoke address error to let CPU reset (manual reset) */
86         asm volatile("ldc %0, sr\n\t"
87                      "mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
88 }
89
90 void machine_halt(void)
91 {
92         local_irq_disable();
93
94         while (1)
95                 cpu_sleep();
96 }
97
98 void machine_power_off(void)
99 {
100         if (pm_power_off)
101                 pm_power_off();
102 }
103
104 void show_regs(struct pt_regs * regs)
105 {
106         printk("\n");
107         printk("Pid : %d, Comm: %20s\n", current->pid, current->comm);
108         print_symbol("PC is at %s\n", instruction_pointer(regs));
109         printk("PC  : %08lx SP  : %08lx SR  : %08lx ",
110                regs->pc, regs->regs[15], regs->sr);
111 #ifdef CONFIG_MMU
112         printk("TEA : %08x    ", ctrl_inl(MMU_TEA));
113 #else
114         printk("                  ");
115 #endif
116         printk("%s\n", print_tainted());
117
118         printk("R0  : %08lx R1  : %08lx R2  : %08lx R3  : %08lx\n",
119                regs->regs[0],regs->regs[1],
120                regs->regs[2],regs->regs[3]);
121         printk("R4  : %08lx R5  : %08lx R6  : %08lx R7  : %08lx\n",
122                regs->regs[4],regs->regs[5],
123                regs->regs[6],regs->regs[7]);
124         printk("R8  : %08lx R9  : %08lx R10 : %08lx R11 : %08lx\n",
125                regs->regs[8],regs->regs[9],
126                regs->regs[10],regs->regs[11]);
127         printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",
128                regs->regs[12],regs->regs[13],
129                regs->regs[14]);
130         printk("MACH: %08lx MACL: %08lx GBR : %08lx PR  : %08lx\n",
131                regs->mach, regs->macl, regs->gbr, regs->pr);
132
133         show_trace(NULL, (unsigned long *)regs->regs[15], regs);
134 }
135
136 /*
137  * Create a kernel thread
138  */
139
140 /*
141  * This is the mechanism for creating a new kernel thread.
142  *
143  */
144 extern void kernel_thread_helper(void);
145 __asm__(".align 5\n"
146         "kernel_thread_helper:\n\t"
147         "jsr    @r5\n\t"
148         " nop\n\t"
149         "mov.l  1f, r1\n\t"
150         "jsr    @r1\n\t"
151         " mov   r0, r4\n\t"
152         ".align 2\n\t"
153         "1:.long do_exit");
154
155 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
156 {       /* Don't use this in BL=1(cli).  Or else, CPU resets! */
157         struct pt_regs regs;
158
159         memset(&regs, 0, sizeof(regs));
160         regs.regs[4] = (unsigned long) arg;
161         regs.regs[5] = (unsigned long) fn;
162
163         regs.pc = (unsigned long) kernel_thread_helper;
164         regs.sr = (1 << 30);
165
166         /* Ok, create the new process.. */
167         return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
168 }
169
170 /*
171  * Free current thread data structures etc..
172  */
173 void exit_thread(void)
174 {
175         if (current->thread.ubc_pc) {
176                 current->thread.ubc_pc = 0;
177                 ubc_usercnt -= 1;
178         }
179 }
180
181 void flush_thread(void)
182 {
183 #if defined(CONFIG_SH_FPU)
184         struct task_struct *tsk = current;
185         /* Forget lazy FPU state */
186         clear_fpu(tsk, task_pt_regs(tsk));
187         clear_used_math();
188 #endif
189 }
190
191 void release_thread(struct task_struct *dead_task)
192 {
193         /* do nothing */
194 }
195
196 /* Fill in the fpu structure for a core dump.. */
197 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
198 {
199         int fpvalid = 0;
200
201 #if defined(CONFIG_SH_FPU)
202         struct task_struct *tsk = current;
203
204         fpvalid = !!tsk_used_math(tsk);
205         if (fpvalid) {
206                 unlazy_fpu(tsk, regs);
207                 memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
208         }
209 #endif
210
211         return fpvalid;
212 }
213
214 /* 
215  * Capture the user space registers if the task is not running (in user space)
216  */
217 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
218 {
219         struct pt_regs ptregs;
220         
221         ptregs = *task_pt_regs(tsk);
222         elf_core_copy_regs(regs, &ptregs);
223
224         return 1;
225 }
226
227 int
228 dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *fpu)
229 {
230         int fpvalid = 0;
231
232 #if defined(CONFIG_SH_FPU)
233         fpvalid = !!tsk_used_math(tsk);
234         if (fpvalid) {
235                 unlazy_fpu(tsk, task_pt_regs(tsk));
236                 memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
237         }
238 #endif
239
240         return fpvalid;
241 }
242
243 asmlinkage void ret_from_fork(void);
244
245 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
246                 unsigned long unused,
247                 struct task_struct *p, struct pt_regs *regs)
248 {
249         struct thread_info *ti = task_thread_info(p);
250         struct pt_regs *childregs;
251 #if defined(CONFIG_SH_FPU)
252         struct task_struct *tsk = current;
253
254         unlazy_fpu(tsk, regs);
255         p->thread.fpu = tsk->thread.fpu;
256         copy_to_stopped_child_used_math(p);
257 #endif
258
259         childregs = task_pt_regs(p);
260         *childregs = *regs;
261
262         if (user_mode(regs)) {
263                 childregs->regs[15] = usp;
264                 ti->addr_limit = USER_DS;
265         } else {
266                 childregs->regs[15] = (unsigned long)task_stack_page(p) + THREAD_SIZE;
267                 ti->addr_limit = KERNEL_DS;
268         }
269         if (clone_flags & CLONE_SETTLS) {
270                 childregs->gbr = childregs->regs[0];
271         }
272         childregs->regs[0] = 0; /* Set return value for child */
273
274         p->thread.sp = (unsigned long) childregs;
275         p->thread.pc = (unsigned long) ret_from_fork;
276
277         p->thread.ubc_pc = 0;
278
279         return 0;
280 }
281
282 /* Tracing by user break controller.  */
283 static void
284 ubc_set_tracing(int asid, unsigned long pc)
285 {
286 #if defined(CONFIG_CPU_SH4A)
287         unsigned long val;
288
289         val = (UBC_CBR_ID_INST | UBC_CBR_RW_READ | UBC_CBR_CE);
290         val |= (UBC_CBR_AIE | UBC_CBR_AIV_SET(asid));
291
292         ctrl_outl(val, UBC_CBR0);
293         ctrl_outl(pc,  UBC_CAR0);
294         ctrl_outl(0x0, UBC_CAMR0);
295         ctrl_outl(0x0, UBC_CBCR);
296
297         val = (UBC_CRR_RES | UBC_CRR_PCB | UBC_CRR_BIE);
298         ctrl_outl(val, UBC_CRR0);
299
300         /* Read UBC register that we writed last. For chekking UBC Register changed */
301         val = ctrl_inl(UBC_CRR0);
302
303 #else   /* CONFIG_CPU_SH4A */
304         ctrl_outl(pc, UBC_BARA);
305
306 #ifdef CONFIG_MMU
307         /* We don't have any ASID settings for the SH-2! */
308         if (cpu_data->type != CPU_SH7604)
309                 ctrl_outb(asid, UBC_BASRA);
310 #endif
311
312         ctrl_outl(0, UBC_BAMRA);
313
314         if (cpu_data->type == CPU_SH7729 || cpu_data->type == CPU_SH7710) {
315                 ctrl_outw(BBR_INST | BBR_READ | BBR_CPU, UBC_BBRA);
316                 ctrl_outl(BRCR_PCBA | BRCR_PCTE, UBC_BRCR);
317         } else {
318                 ctrl_outw(BBR_INST | BBR_READ, UBC_BBRA);
319                 ctrl_outw(BRCR_PCBA, UBC_BRCR);
320         }
321 #endif  /* CONFIG_CPU_SH4A */
322 }
323
324 /*
325  *      switch_to(x,y) should switch tasks from x to y.
326  *
327  */
328 struct task_struct *__switch_to(struct task_struct *prev, struct task_struct *next)
329 {
330 #if defined(CONFIG_SH_FPU)
331         unlazy_fpu(prev, task_pt_regs(prev));
332 #endif
333
334 #ifdef CONFIG_PREEMPT
335         {
336                 unsigned long flags;
337                 struct pt_regs *regs;
338
339                 local_irq_save(flags);
340                 regs = task_pt_regs(prev);
341                 if (user_mode(regs) && regs->regs[15] >= 0xc0000000) {
342                         int offset = (int)regs->regs[15];
343
344                         /* Reset stack pointer: clear critical region mark */
345                         regs->regs[15] = regs->regs[1];
346                         if (regs->pc < regs->regs[0])
347                                 /* Go to rewind point */
348                                 regs->pc = regs->regs[0] + offset;
349                 }
350                 local_irq_restore(flags);
351         }
352 #endif
353
354 #ifdef CONFIG_MMU
355         /*
356          * Restore the kernel mode register
357          *      k7 (r7_bank1)
358          */
359         asm volatile("ldc       %0, r7_bank"
360                      : /* no output */
361                      : "r" (task_thread_info(next)));
362 #endif
363
364         /* If no tasks are using the UBC, we're done */
365         if (ubc_usercnt == 0)
366                 /* If no tasks are using the UBC, we're done */;
367         else if (next->thread.ubc_pc && next->mm) {
368                 int asid = 0;
369 #ifdef CONFIG_MMU
370                 asid |= next->mm->context.id & MMU_CONTEXT_ASID_MASK;
371 #endif
372                 ubc_set_tracing(asid, next->thread.ubc_pc);
373         } else {
374 #if defined(CONFIG_CPU_SH4A)
375                 ctrl_outl(UBC_CBR_INIT, UBC_CBR0);
376                 ctrl_outl(UBC_CRR_INIT, UBC_CRR0);
377 #else
378                 ctrl_outw(0, UBC_BBRA);
379                 ctrl_outw(0, UBC_BBRB);
380 #endif
381         }
382
383         return prev;
384 }
385
386 asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
387                         unsigned long r6, unsigned long r7,
388                         struct pt_regs regs)
389 {
390 #ifdef CONFIG_MMU
391         return do_fork(SIGCHLD, regs.regs[15], &regs, 0, NULL, NULL);
392 #else
393         /* fork almost works, enough to trick you into looking elsewhere :-( */
394         return -EINVAL;
395 #endif
396 }
397
398 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
399                          unsigned long parent_tidptr,
400                          unsigned long child_tidptr,
401                          struct pt_regs regs)
402 {
403         if (!newsp)
404                 newsp = regs.regs[15];
405         return do_fork(clone_flags, newsp, &regs, 0,
406                         (int __user *)parent_tidptr, (int __user *)child_tidptr);
407 }
408
409 /*
410  * This is trivial, and on the face of it looks like it
411  * could equally well be done in user mode.
412  *
413  * Not so, for quite unobvious reasons - register pressure.
414  * In user mode vfork() cannot have a stack frame, and if
415  * done by calling the "clone()" system call directly, you
416  * do not have enough call-clobbered registers to hold all
417  * the information you need.
418  */
419 asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
420                          unsigned long r6, unsigned long r7,
421                          struct pt_regs regs)
422 {
423         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.regs[15], &regs,
424                        0, NULL, NULL);
425 }
426
427 /*
428  * sys_execve() executes a new program.
429  */
430 asmlinkage int sys_execve(char *ufilename, char **uargv,
431                           char **uenvp, unsigned long r7,
432                           struct pt_regs regs)
433 {
434         int error;
435         char *filename;
436
437         filename = getname((char __user *)ufilename);
438         error = PTR_ERR(filename);
439         if (IS_ERR(filename))
440                 goto out;
441
442         error = do_execve(filename,
443                           (char __user * __user *)uargv,
444                           (char __user * __user *)uenvp,
445                           &regs);
446         if (error == 0) {
447                 task_lock(current);
448                 current->ptrace &= ~PT_DTRACE;
449                 task_unlock(current);
450         }
451         putname(filename);
452 out:
453         return error;
454 }
455
456 unsigned long get_wchan(struct task_struct *p)
457 {
458         unsigned long schedule_frame;
459         unsigned long pc;
460
461         if (!p || p == current || p->state == TASK_RUNNING)
462                 return 0;
463
464         /*
465          * The same comment as on the Alpha applies here, too ...
466          */
467         pc = thread_saved_pc(p);
468         if (in_sched_functions(pc)) {
469                 schedule_frame = ((unsigned long *)(long)p->thread.sp)[1];
470                 return (unsigned long)((unsigned long *)schedule_frame)[1];
471         }
472         return pc;
473 }
474
475 asmlinkage void break_point_trap(unsigned long r4, unsigned long r5,
476                                  unsigned long r6, unsigned long r7,
477                                  struct pt_regs regs)
478 {
479         /* Clear tracing.  */
480 #if defined(CONFIG_CPU_SH4A)
481         ctrl_outl(UBC_CBR_INIT, UBC_CBR0);
482         ctrl_outl(UBC_CRR_INIT, UBC_CRR0);
483 #else
484         ctrl_outw(0, UBC_BBRA);
485         ctrl_outw(0, UBC_BBRB);
486 #endif
487         current->thread.ubc_pc = 0;
488         ubc_usercnt -= 1;
489
490         force_sig(SIGTRAP, current);
491 }
492
493 asmlinkage void break_point_trap_software(unsigned long r4, unsigned long r5,
494                                           unsigned long r6, unsigned long r7,
495                                           struct pt_regs regs)
496 {
497         regs.pc -= 2;
498         force_sig(SIGTRAP, current);
499 }