1 /* 2 * linux/arch/arm/kernel/process.c 3 * 4 * Copyright (C) 1996-2000 Russell King - Converted to ARM. 5 * Original Copyright (C) 1995 Linus Torvalds 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <stdarg.h> 12 13 #include <linux/module.h> 14 #include <linux/sched.h> 15 #include <linux/kernel.h> 16 #include <linux/mm.h> 17 #include <linux/stddef.h> 18 #include <linux/unistd.h> 19 #include <linux/user.h> 20 #include <linux/delay.h> 21 #include <linux/reboot.h> 22 #include <linux/interrupt.h> 23 #include <linux/kallsyms.h> 24 #include <linux/init.h> 25 #include <linux/cpu.h> 26 #include <linux/elfcore.h> 27 #include <linux/pm.h> 28 #include <linux/tick.h> 29 #include <linux/utsname.h> 30 #include <linux/uaccess.h> 31 #include <linux/random.h> 32 33 #include <asm/cacheflush.h> 34 #include <asm/leds.h> 35 #include <asm/processor.h> 36 #include <asm/system.h> 37 #include <asm/thread_notify.h> 38 #include <asm/stacktrace.h> 39 #include <asm/mach/time.h> 40 41 #ifdef CONFIG_CC_STACKPROTECTOR 42 #include <linux/stackprotector.h> 43 unsigned long __stack_chk_guard __read_mostly; 44 EXPORT_SYMBOL(__stack_chk_guard); 45 #endif 46 47 static const char *processor_modes[] = { 48 "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" , 49 "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26", 50 "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" , 51 "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32" 52 }; 53 54 static const char *isa_modes[] = { 55 "ARM" , "Thumb" , "Jazelle", "ThumbEE" 56 }; 57 58 extern void setup_mm_for_reboot(char mode); 59 60 static volatile int hlt_counter; 61 62 #include <mach/system.h> 63 64 void disable_hlt(void) 65 { 66 hlt_counter++; 67 } 68 69 EXPORT_SYMBOL(disable_hlt); 70 71 void enable_hlt(void) 72 { 73 hlt_counter--; 74 } 75 76 EXPORT_SYMBOL(enable_hlt); 77 78 static int __init nohlt_setup(char *__unused) 79 { 80 hlt_counter = 1; 81 return 1; 82 } 83 84 static int __init hlt_setup(char *__unused) 85 { 86 hlt_counter = 0; 87 return 1; 88 } 89 90 __setup("nohlt", nohlt_setup); 91 __setup("hlt", hlt_setup); 92 93 void arm_machine_restart(char mode, const char *cmd) 94 { 95 /* Disable interrupts first */ 96 local_irq_disable(); 97 local_fiq_disable(); 98 99 /* 100 * Tell the mm system that we are going to reboot - 101 * we may need it to insert some 1:1 mappings so that 102 * soft boot works. 103 */ 104 setup_mm_for_reboot(mode); 105 106 /* Clean and invalidate caches */ 107 flush_cache_all(); 108 109 /* Turn off caching */ 110 cpu_proc_fin(); 111 112 /* Push out any further dirty data, and ensure cache is empty */ 113 flush_cache_all(); 114 115 /* 116 * Now call the architecture specific reboot code. 117 */ 118 arch_reset(mode, cmd); 119 120 /* 121 * Whoops - the architecture was unable to reboot. 122 * Tell the user! 123 */ 124 mdelay(1000); 125 printk("Reboot failed -- System halted\n"); 126 while (1); 127 } 128 129 /* 130 * Function pointers to optional machine specific functions 131 */ 132 void (*pm_power_off)(void); 133 EXPORT_SYMBOL(pm_power_off); 134 135 void (*arm_pm_restart)(char str, const char *cmd) = arm_machine_restart; 136 EXPORT_SYMBOL_GPL(arm_pm_restart); 137 138 139 /* 140 * This is our default idle handler. We need to disable 141 * interrupts here to ensure we don't miss a wakeup call. 142 */ 143 static void default_idle(void) 144 { 145 if (!need_resched()) 146 arch_idle(); 147 local_irq_enable(); 148 } 149 150 void (*pm_idle)(void) = default_idle; 151 EXPORT_SYMBOL(pm_idle); 152 153 /* 154 * The idle thread, has rather strange semantics for calling pm_idle, 155 * but this is what x86 does and we need to do the same, so that 156 * things like cpuidle get called in the same way. The only difference 157 * is that we always respect 'hlt_counter' to prevent low power idle. 158 */ 159 void cpu_idle(void) 160 { 161 local_fiq_enable(); 162 163 /* endless idle loop with no priority at all */ 164 while (1) { 165 tick_nohz_stop_sched_tick(1); 166 leds_event(led_idle_start); 167 while (!need_resched()) { 168 #ifdef CONFIG_HOTPLUG_CPU 169 if (cpu_is_offline(smp_processor_id())) 170 cpu_die(); 171 #endif 172 173 local_irq_disable(); 174 if (hlt_counter) { 175 local_irq_enable(); 176 cpu_relax(); 177 } else { 178 stop_critical_timings(); 179 pm_idle(); 180 start_critical_timings(); 181 /* 182 * This will eventually be removed - pm_idle 183 * functions should always return with IRQs 184 * enabled. 185 */ 186 WARN_ON(irqs_disabled()); 187 local_irq_enable(); 188 } 189 } 190 leds_event(led_idle_end); 191 tick_nohz_restart_sched_tick(); 192 preempt_enable_no_resched(); 193 schedule(); 194 preempt_disable(); 195 } 196 } 197 198 static char reboot_mode = 'h'; 199 200 int __init reboot_setup(char *str) 201 { 202 reboot_mode = str[0]; 203 return 1; 204 } 205 206 __setup("reboot=", reboot_setup); 207 208 void machine_shutdown(void) 209 { 210 #ifdef CONFIG_SMP 211 smp_send_stop(); 212 #endif 213 } 214 215 void machine_halt(void) 216 { 217 machine_shutdown(); 218 while (1); 219 } 220 221 void machine_power_off(void) 222 { 223 machine_shutdown(); 224 if (pm_power_off) 225 pm_power_off(); 226 } 227 228 void machine_restart(char *cmd) 229 { 230 machine_shutdown(); 231 arm_pm_restart(reboot_mode, cmd); 232 } 233 234 void __show_regs(struct pt_regs *regs) 235 { 236 unsigned long flags; 237 char buf[64]; 238 239 printk("CPU: %d %s (%s %.*s)\n", 240 raw_smp_processor_id(), print_tainted(), 241 init_utsname()->release, 242 (int)strcspn(init_utsname()->version, " "), 243 init_utsname()->version); 244 print_symbol("PC is at %s\n", instruction_pointer(regs)); 245 print_symbol("LR is at %s\n", regs->ARM_lr); 246 printk("pc : [<%08lx>] lr : [<%08lx>] psr: %08lx\n" 247 "sp : %08lx ip : %08lx fp : %08lx\n", 248 regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr, 249 regs->ARM_sp, regs->ARM_ip, regs->ARM_fp); 250 printk("r10: %08lx r9 : %08lx r8 : %08lx\n", 251 regs->ARM_r10, regs->ARM_r9, 252 regs->ARM_r8); 253 printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", 254 regs->ARM_r7, regs->ARM_r6, 255 regs->ARM_r5, regs->ARM_r4); 256 printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", 257 regs->ARM_r3, regs->ARM_r2, 258 regs->ARM_r1, regs->ARM_r0); 259 260 flags = regs->ARM_cpsr; 261 buf[0] = flags & PSR_N_BIT ? 'N' : 'n'; 262 buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z'; 263 buf[2] = flags & PSR_C_BIT ? 'C' : 'c'; 264 buf[3] = flags & PSR_V_BIT ? 'V' : 'v'; 265 buf[4] = '\0'; 266 267 printk("Flags: %s IRQs o%s FIQs o%s Mode %s ISA %s Segment %s\n", 268 buf, interrupts_enabled(regs) ? "n" : "ff", 269 fast_interrupts_enabled(regs) ? "n" : "ff", 270 processor_modes[processor_mode(regs)], 271 isa_modes[isa_mode(regs)], 272 get_fs() == get_ds() ? "kernel" : "user"); 273 #ifdef CONFIG_CPU_CP15 274 { 275 unsigned int ctrl; 276 277 buf[0] = '\0'; 278 #ifdef CONFIG_CPU_CP15_MMU 279 { 280 unsigned int transbase, dac; 281 asm("mrc p15, 0, %0, c2, c0\n\t" 282 "mrc p15, 0, %1, c3, c0\n" 283 : "=r" (transbase), "=r" (dac)); 284 snprintf(buf, sizeof(buf), " Table: %08x DAC: %08x", 285 transbase, dac); 286 } 287 #endif 288 asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl)); 289 290 printk("Control: %08x%s\n", ctrl, buf); 291 } 292 #endif 293 } 294 295 void show_regs(struct pt_regs * regs) 296 { 297 printk("\n"); 298 printk("Pid: %d, comm: %20s\n", task_pid_nr(current), current->comm); 299 __show_regs(regs); 300 __backtrace(); 301 } 302 303 ATOMIC_NOTIFIER_HEAD(thread_notify_head); 304 305 EXPORT_SYMBOL_GPL(thread_notify_head); 306 307 /* 308 * Free current thread data structures etc.. 309 */ 310 void exit_thread(void) 311 { 312 thread_notify(THREAD_NOTIFY_EXIT, current_thread_info()); 313 } 314 315 void flush_thread(void) 316 { 317 struct thread_info *thread = current_thread_info(); 318 struct task_struct *tsk = current; 319 320 memset(thread->used_cp, 0, sizeof(thread->used_cp)); 321 memset(&tsk->thread.debug, 0, sizeof(struct debug_info)); 322 memset(&thread->fpstate, 0, sizeof(union fp_state)); 323 324 thread_notify(THREAD_NOTIFY_FLUSH, thread); 325 } 326 327 void release_thread(struct task_struct *dead_task) 328 { 329 } 330 331 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); 332 333 int 334 copy_thread(unsigned long clone_flags, unsigned long stack_start, 335 unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs) 336 { 337 struct thread_info *thread = task_thread_info(p); 338 struct pt_regs *childregs = task_pt_regs(p); 339 340 *childregs = *regs; 341 childregs->ARM_r0 = 0; 342 childregs->ARM_sp = stack_start; 343 344 memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save)); 345 thread->cpu_context.sp = (unsigned long)childregs; 346 thread->cpu_context.pc = (unsigned long)ret_from_fork; 347 348 if (clone_flags & CLONE_SETTLS) 349 thread->tp_value = regs->ARM_r3; 350 351 return 0; 352 } 353 354 /* 355 * Fill in the task's elfregs structure for a core dump. 356 */ 357 int dump_task_regs(struct task_struct *t, elf_gregset_t *elfregs) 358 { 359 elf_core_copy_regs(elfregs, task_pt_regs(t)); 360 return 1; 361 } 362 363 /* 364 * fill in the fpe structure for a core dump... 365 */ 366 int dump_fpu (struct pt_regs *regs, struct user_fp *fp) 367 { 368 struct thread_info *thread = current_thread_info(); 369 int used_math = thread->used_cp[1] | thread->used_cp[2]; 370 371 if (used_math) 372 memcpy(fp, &thread->fpstate.soft, sizeof (*fp)); 373 374 return used_math != 0; 375 } 376 EXPORT_SYMBOL(dump_fpu); 377 378 /* 379 * Shuffle the argument into the correct register before calling the 380 * thread function. r4 is the thread argument, r5 is the pointer to 381 * the thread function, and r6 points to the exit function. 382 */ 383 extern void kernel_thread_helper(void); 384 asm( ".pushsection .text\n" 385 " .align\n" 386 " .type kernel_thread_helper, #function\n" 387 "kernel_thread_helper:\n" 388 #ifdef CONFIG_TRACE_IRQFLAGS 389 " bl trace_hardirqs_on\n" 390 #endif 391 " msr cpsr_c, r7\n" 392 " mov r0, r4\n" 393 " mov lr, r6\n" 394 " mov pc, r5\n" 395 " .size kernel_thread_helper, . - kernel_thread_helper\n" 396 " .popsection"); 397 398 #ifdef CONFIG_ARM_UNWIND 399 extern void kernel_thread_exit(long code); 400 asm( ".pushsection .text\n" 401 " .align\n" 402 " .type kernel_thread_exit, #function\n" 403 "kernel_thread_exit:\n" 404 " .fnstart\n" 405 " .cantunwind\n" 406 " bl do_exit\n" 407 " nop\n" 408 " .fnend\n" 409 " .size kernel_thread_exit, . - kernel_thread_exit\n" 410 " .popsection"); 411 #else 412 #define kernel_thread_exit do_exit 413 #endif 414 415 /* 416 * Create a kernel thread. 417 */ 418 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags) 419 { 420 struct pt_regs regs; 421 422 memset(®s, 0, sizeof(regs)); 423 424 regs.ARM_r4 = (unsigned long)arg; 425 regs.ARM_r5 = (unsigned long)fn; 426 regs.ARM_r6 = (unsigned long)kernel_thread_exit; 427 regs.ARM_r7 = SVC_MODE | PSR_ENDSTATE | PSR_ISETSTATE; 428 regs.ARM_pc = (unsigned long)kernel_thread_helper; 429 regs.ARM_cpsr = regs.ARM_r7 | PSR_I_BIT; 430 431 return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, ®s, 0, NULL, NULL); 432 } 433 EXPORT_SYMBOL(kernel_thread); 434 435 unsigned long get_wchan(struct task_struct *p) 436 { 437 struct stackframe frame; 438 int count = 0; 439 if (!p || p == current || p->state == TASK_RUNNING) 440 return 0; 441 442 frame.fp = thread_saved_fp(p); 443 frame.sp = thread_saved_sp(p); 444 frame.lr = 0; /* recovered from the stack */ 445 frame.pc = thread_saved_pc(p); 446 do { 447 int ret = unwind_frame(&frame); 448 if (ret < 0) 449 return 0; 450 if (!in_sched_functions(frame.pc)) 451 return frame.pc; 452 } while (count ++ < 16); 453 return 0; 454 } 455 456 unsigned long arch_randomize_brk(struct mm_struct *mm) 457 { 458 unsigned long range_end = mm->brk + 0x02000000; 459 return randomize_range(mm->brk, range_end, 0) ? : mm->brk; 460 } 461