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