process.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446
  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. #include <linux/module.h>
  13. #include <linux/sched.h>
  14. #include <linux/kernel.h>
  15. #include <linux/mm.h>
  16. #include <linux/stddef.h>
  17. #include <linux/unistd.h>
  18. #include <linux/ptrace.h>
  19. #include <linux/slab.h>
  20. #include <linux/user.h>
  21. #include <linux/a.out.h>
  22. #include <linux/delay.h>
  23. #include <linux/reboot.h>
  24. #include <linux/interrupt.h>
  25. #include <linux/kallsyms.h>
  26. #include <linux/init.h>
  27. #include <linux/cpu.h>
  28. #include <linux/elfcore.h>
  29. #include <linux/pm.h>
  30. #include <asm/leds.h>
  31. #include <asm/processor.h>
  32. #include <asm/system.h>
  33. #include <asm/thread_notify.h>
  34. #include <asm/uaccess.h>
  35. #include <asm/mach/time.h>
  36. static const char *processor_modes[] = {
  37. "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
  38. "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
  39. "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" ,
  40. "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
  41. };
  42. extern void setup_mm_for_reboot(char mode);
  43. static volatile int hlt_counter;
  44. #include <asm/arch/system.h>
  45. void disable_hlt(void)
  46. {
  47. hlt_counter++;
  48. }
  49. EXPORT_SYMBOL(disable_hlt);
  50. void enable_hlt(void)
  51. {
  52. hlt_counter--;
  53. }
  54. EXPORT_SYMBOL(enable_hlt);
  55. static int __init nohlt_setup(char *__unused)
  56. {
  57. hlt_counter = 1;
  58. return 1;
  59. }
  60. static int __init hlt_setup(char *__unused)
  61. {
  62. hlt_counter = 0;
  63. return 1;
  64. }
  65. __setup("nohlt", nohlt_setup);
  66. __setup("hlt", hlt_setup);
  67. void arm_machine_restart(char mode)
  68. {
  69. /*
  70. * Clean and disable cache, and turn off interrupts
  71. */
  72. cpu_proc_fin();
  73. /*
  74. * Tell the mm system that we are going to reboot -
  75. * we may need it to insert some 1:1 mappings so that
  76. * soft boot works.
  77. */
  78. setup_mm_for_reboot(mode);
  79. /*
  80. * Now call the architecture specific reboot code.
  81. */
  82. arch_reset(mode);
  83. /*
  84. * Whoops - the architecture was unable to reboot.
  85. * Tell the user!
  86. */
  87. mdelay(1000);
  88. printk("Reboot failed -- System halted\n");
  89. while (1);
  90. }
  91. /*
  92. * Function pointers to optional machine specific functions
  93. */
  94. void (*pm_idle)(void);
  95. EXPORT_SYMBOL(pm_idle);
  96. void (*pm_power_off)(void);
  97. EXPORT_SYMBOL(pm_power_off);
  98. void (*arm_pm_restart)(char str) = arm_machine_restart;
  99. EXPORT_SYMBOL_GPL(arm_pm_restart);
  100. /*
  101. * This is our default idle handler. We need to disable
  102. * interrupts here to ensure we don't miss a wakeup call.
  103. */
  104. static void default_idle(void)
  105. {
  106. if (hlt_counter)
  107. cpu_relax();
  108. else {
  109. local_irq_disable();
  110. if (!need_resched()) {
  111. timer_dyn_reprogram();
  112. arch_idle();
  113. }
  114. local_irq_enable();
  115. }
  116. }
  117. /*
  118. * The idle thread. We try to conserve power, while trying to keep
  119. * overall latency low. The architecture specific idle is passed
  120. * a value to indicate the level of "idleness" of the system.
  121. */
  122. void cpu_idle(void)
  123. {
  124. local_fiq_enable();
  125. /* endless idle loop with no priority at all */
  126. while (1) {
  127. void (*idle)(void) = pm_idle;
  128. #ifdef CONFIG_HOTPLUG_CPU
  129. if (cpu_is_offline(smp_processor_id())) {
  130. leds_event(led_idle_start);
  131. cpu_die();
  132. }
  133. #endif
  134. if (!idle)
  135. idle = default_idle;
  136. leds_event(led_idle_start);
  137. while (!need_resched())
  138. idle();
  139. leds_event(led_idle_end);
  140. preempt_enable_no_resched();
  141. schedule();
  142. preempt_disable();
  143. }
  144. }
  145. static char reboot_mode = 'h';
  146. int __init reboot_setup(char *str)
  147. {
  148. reboot_mode = str[0];
  149. return 1;
  150. }
  151. __setup("reboot=", reboot_setup);
  152. void machine_halt(void)
  153. {
  154. if (pm_power_off)
  155. pm_power_off();
  156. while(1);
  157. }
  158. void machine_power_off(void)
  159. {
  160. if (pm_power_off)
  161. pm_power_off();
  162. }
  163. void machine_restart(char * __unused)
  164. {
  165. arm_pm_restart(reboot_mode);
  166. }
  167. void __show_regs(struct pt_regs *regs)
  168. {
  169. unsigned long flags = condition_codes(regs);
  170. printk("CPU: %d\n", smp_processor_id());
  171. print_symbol("PC is at %s\n", instruction_pointer(regs));
  172. print_symbol("LR is at %s\n", regs->ARM_lr);
  173. printk("pc : [<%08lx>] lr : [<%08lx>] %s\n"
  174. "sp : %08lx ip : %08lx fp : %08lx\n",
  175. instruction_pointer(regs),
  176. regs->ARM_lr, print_tainted(), regs->ARM_sp,
  177. regs->ARM_ip, regs->ARM_fp);
  178. printk("r10: %08lx r9 : %08lx r8 : %08lx\n",
  179. regs->ARM_r10, regs->ARM_r9,
  180. regs->ARM_r8);
  181. printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n",
  182. regs->ARM_r7, regs->ARM_r6,
  183. regs->ARM_r5, regs->ARM_r4);
  184. printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n",
  185. regs->ARM_r3, regs->ARM_r2,
  186. regs->ARM_r1, regs->ARM_r0);
  187. printk("Flags: %c%c%c%c",
  188. flags & PSR_N_BIT ? 'N' : 'n',
  189. flags & PSR_Z_BIT ? 'Z' : 'z',
  190. flags & PSR_C_BIT ? 'C' : 'c',
  191. flags & PSR_V_BIT ? 'V' : 'v');
  192. printk(" IRQs o%s FIQs o%s Mode %s%s Segment %s\n",
  193. interrupts_enabled(regs) ? "n" : "ff",
  194. fast_interrupts_enabled(regs) ? "n" : "ff",
  195. processor_modes[processor_mode(regs)],
  196. thumb_mode(regs) ? " (T)" : "",
  197. get_fs() == get_ds() ? "kernel" : "user");
  198. #if CONFIG_CPU_CP15
  199. {
  200. unsigned int ctrl;
  201. __asm__ (
  202. " mrc p15, 0, %0, c1, c0\n"
  203. : "=r" (ctrl));
  204. printk("Control: %04X\n", ctrl);
  205. }
  206. #ifdef CONFIG_CPU_CP15_MMU
  207. {
  208. unsigned int transbase, dac;
  209. __asm__ (
  210. " mrc p15, 0, %0, c2, c0\n"
  211. " mrc p15, 0, %1, c3, c0\n"
  212. : "=r" (transbase), "=r" (dac));
  213. printk("Table: %08X DAC: %08X\n",
  214. transbase, dac);
  215. }
  216. #endif
  217. #endif
  218. }
  219. void show_regs(struct pt_regs * regs)
  220. {
  221. printk("\n");
  222. printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
  223. __show_regs(regs);
  224. __backtrace();
  225. }
  226. void show_fpregs(struct user_fp *regs)
  227. {
  228. int i;
  229. for (i = 0; i < 8; i++) {
  230. unsigned long *p;
  231. char type;
  232. p = (unsigned long *)(regs->fpregs + i);
  233. switch (regs->ftype[i]) {
  234. case 1: type = 'f'; break;
  235. case 2: type = 'd'; break;
  236. case 3: type = 'e'; break;
  237. default: type = '?'; break;
  238. }
  239. if (regs->init_flag)
  240. type = '?';
  241. printk(" f%d(%c): %08lx %08lx %08lx%c",
  242. i, type, p[0], p[1], p[2], i & 1 ? '\n' : ' ');
  243. }
  244. printk("FPSR: %08lx FPCR: %08lx\n",
  245. (unsigned long)regs->fpsr,
  246. (unsigned long)regs->fpcr);
  247. }
  248. /*
  249. * Free current thread data structures etc..
  250. */
  251. void exit_thread(void)
  252. {
  253. }
  254. ATOMIC_NOTIFIER_HEAD(thread_notify_head);
  255. EXPORT_SYMBOL_GPL(thread_notify_head);
  256. void flush_thread(void)
  257. {
  258. struct thread_info *thread = current_thread_info();
  259. struct task_struct *tsk = current;
  260. memset(thread->used_cp, 0, sizeof(thread->used_cp));
  261. memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
  262. memset(&thread->fpstate, 0, sizeof(union fp_state));
  263. thread_notify(THREAD_NOTIFY_FLUSH, thread);
  264. }
  265. void release_thread(struct task_struct *dead_task)
  266. {
  267. struct thread_info *thread = task_thread_info(dead_task);
  268. thread_notify(THREAD_NOTIFY_RELEASE, thread);
  269. }
  270. asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
  271. int
  272. copy_thread(int nr, unsigned long clone_flags, unsigned long stack_start,
  273. unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
  274. {
  275. struct thread_info *thread = task_thread_info(p);
  276. struct pt_regs *childregs = task_pt_regs(p);
  277. *childregs = *regs;
  278. childregs->ARM_r0 = 0;
  279. childregs->ARM_sp = stack_start;
  280. memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
  281. thread->cpu_context.sp = (unsigned long)childregs;
  282. thread->cpu_context.pc = (unsigned long)ret_from_fork;
  283. if (clone_flags & CLONE_SETTLS)
  284. thread->tp_value = regs->ARM_r3;
  285. return 0;
  286. }
  287. /*
  288. * fill in the fpe structure for a core dump...
  289. */
  290. int dump_fpu (struct pt_regs *regs, struct user_fp *fp)
  291. {
  292. struct thread_info *thread = current_thread_info();
  293. int used_math = thread->used_cp[1] | thread->used_cp[2];
  294. if (used_math)
  295. memcpy(fp, &thread->fpstate.soft, sizeof (*fp));
  296. return used_math != 0;
  297. }
  298. EXPORT_SYMBOL(dump_fpu);
  299. /*
  300. * fill in the user structure for a core dump..
  301. */
  302. void dump_thread(struct pt_regs * regs, struct user * dump)
  303. {
  304. struct task_struct *tsk = current;
  305. dump->magic = CMAGIC;
  306. dump->start_code = tsk->mm->start_code;
  307. dump->start_stack = regs->ARM_sp & ~(PAGE_SIZE - 1);
  308. dump->u_tsize = (tsk->mm->end_code - tsk->mm->start_code) >> PAGE_SHIFT;
  309. dump->u_dsize = (tsk->mm->brk - tsk->mm->start_data + PAGE_SIZE - 1) >> PAGE_SHIFT;
  310. dump->u_ssize = 0;
  311. dump->u_debugreg[0] = tsk->thread.debug.bp[0].address;
  312. dump->u_debugreg[1] = tsk->thread.debug.bp[1].address;
  313. dump->u_debugreg[2] = tsk->thread.debug.bp[0].insn.arm;
  314. dump->u_debugreg[3] = tsk->thread.debug.bp[1].insn.arm;
  315. dump->u_debugreg[4] = tsk->thread.debug.nsaved;
  316. if (dump->start_stack < 0x04000000)
  317. dump->u_ssize = (0x04000000 - dump->start_stack) >> PAGE_SHIFT;
  318. dump->regs = *regs;
  319. dump->u_fpvalid = dump_fpu (regs, &dump->u_fp);
  320. }
  321. EXPORT_SYMBOL(dump_thread);
  322. /*
  323. * Shuffle the argument into the correct register before calling the
  324. * thread function. r1 is the thread argument, r2 is the pointer to
  325. * the thread function, and r3 points to the exit function.
  326. */
  327. extern void kernel_thread_helper(void);
  328. asm( ".section .text\n"
  329. " .align\n"
  330. " .type kernel_thread_helper, #function\n"
  331. "kernel_thread_helper:\n"
  332. " mov r0, r1\n"
  333. " mov lr, r3\n"
  334. " mov pc, r2\n"
  335. " .size kernel_thread_helper, . - kernel_thread_helper\n"
  336. " .previous");
  337. /*
  338. * Create a kernel thread.
  339. */
  340. pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
  341. {
  342. struct pt_regs regs;
  343. memset(&regs, 0, sizeof(regs));
  344. regs.ARM_r1 = (unsigned long)arg;
  345. regs.ARM_r2 = (unsigned long)fn;
  346. regs.ARM_r3 = (unsigned long)do_exit;
  347. regs.ARM_pc = (unsigned long)kernel_thread_helper;
  348. regs.ARM_cpsr = SVC_MODE;
  349. return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
  350. }
  351. EXPORT_SYMBOL(kernel_thread);
  352. unsigned long get_wchan(struct task_struct *p)
  353. {
  354. unsigned long fp, lr;
  355. unsigned long stack_start, stack_end;
  356. int count = 0;
  357. if (!p || p == current || p->state == TASK_RUNNING)
  358. return 0;
  359. stack_start = (unsigned long)end_of_stack(p);
  360. stack_end = (unsigned long)task_stack_page(p) + THREAD_SIZE;
  361. fp = thread_saved_fp(p);
  362. do {
  363. if (fp < stack_start || fp > stack_end)
  364. return 0;
  365. lr = pc_pointer (((unsigned long *)fp)[-1]);
  366. if (!in_sched_functions(lr))
  367. return lr;
  368. fp = *(unsigned long *) (fp - 12);
  369. } while (count ++ < 16);
  370. return 0;
  371. }