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> 43unsigned long __stack_chk_guard __read_mostly; 44EXPORT_SYMBOL(__stack_chk_guard); 45#endif 46 47static 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 54static const char *isa_modes[] = { 55 "ARM" , "Thumb" , "Jazelle", "ThumbEE" 56}; 57 58extern void setup_mm_for_reboot(char mode); 59 60static volatile int hlt_counter; 61 62#include <mach/system.h> 63 64void disable_hlt(void) 65{ 66 hlt_counter++; 67} 68 69EXPORT_SYMBOL(disable_hlt); 70 71void enable_hlt(void) 72{ 73 hlt_counter--; 74} 75 76EXPORT_SYMBOL(enable_hlt); 77 78static int __init nohlt_setup(char *__unused) 79{ 80 hlt_counter = 1; 81 return 1; 82} 83 84static 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 93void 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 */ 132void (*pm_power_off)(void); 133EXPORT_SYMBOL(pm_power_off); 134 135void (*arm_pm_restart)(char str, const char *cmd) = arm_machine_restart; 136EXPORT_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 */ 143static void default_idle(void) 144{ 145 if (!need_resched()) 146 arch_idle(); 147 local_irq_enable(); 148} 149 150void (*pm_idle)(void) = default_idle; 151EXPORT_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 */ 159void 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 198static char reboot_mode = 'h'; 199 200int __init reboot_setup(char *str) 201{ 202 reboot_mode = str[0]; 203 return 1; 204} 205 206__setup("reboot=", reboot_setup); 207 208void machine_shutdown(void) 209{ 210#ifdef CONFIG_SMP 211 smp_send_stop(); 212#endif 213} 214 215void machine_halt(void) 216{ 217 machine_shutdown(); 218 while (1); 219} 220 221void machine_power_off(void) 222{ 223 machine_shutdown(); 224 if (pm_power_off) 225 pm_power_off(); 226} 227 228void machine_restart(char *cmd) 229{ 230 machine_shutdown(); 231 arm_pm_restart(reboot_mode, cmd); 232} 233 234void __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 295void 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 303ATOMIC_NOTIFIER_HEAD(thread_notify_head); 304 305EXPORT_SYMBOL_GPL(thread_notify_head); 306 307/* 308 * Free current thread data structures etc.. 309 */ 310void exit_thread(void) 311{ 312 thread_notify(THREAD_NOTIFY_EXIT, current_thread_info()); 313} 314 315void 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 327void release_thread(struct task_struct *dead_task) 328{ 329} 330 331asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); 332 333int 334copy_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 */ 357int 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 */ 366int 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} 376EXPORT_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 */ 383extern void kernel_thread_helper(void); 384asm( ".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 399extern void kernel_thread_exit(long code); 400asm( ".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 */ 418pid_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} 433EXPORT_SYMBOL(kernel_thread); 434 435unsigned 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 456unsigned 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