Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Paul Gortmaker | ecea4ab | 2011-07-22 10:58:34 -0400 | [diff] [blame] | 13 | #include <linux/export.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <linux/user.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/interrupt.h> |
| 21 | #include <linux/kallsyms.h> |
| 22 | #include <linux/init.h> |
Ben Dooks | 84dff1a | 2006-03-15 23:17:23 +0000 | [diff] [blame] | 23 | #include <linux/elfcore.h> |
Richard Purdie | 74617fb | 2006-06-19 19:57:12 +0100 | [diff] [blame] | 24 | #include <linux/pm.h> |
Kevin Hilman | 9e4559d | 2007-03-14 17:33:24 +0100 | [diff] [blame] | 25 | #include <linux/tick.h> |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 26 | #include <linux/utsname.h> |
Russell King | 33fa9b1 | 2008-09-06 11:35:55 +0100 | [diff] [blame] | 27 | #include <linux/uaccess.h> |
Nicolas Pitre | 990cb8a | 2010-06-14 16:27:19 -0400 | [diff] [blame] | 28 | #include <linux/random.h> |
Will Deacon | 864232f | 2010-09-03 10:42:55 +0100 | [diff] [blame] | 29 | #include <linux/hw_breakpoint.h> |
Bryan Wu | fa8bbb1 | 2012-03-14 02:26:56 +0800 | [diff] [blame] | 30 | #include <linux/leds.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | #include <asm/processor.h> |
Russell King | d6551e8 | 2006-06-21 13:31:52 +0100 | [diff] [blame] | 33 | #include <asm/thread_notify.h> |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 34 | #include <asm/stacktrace.h> |
Russell King | 779dd95 | 2014-04-06 16:17:39 +0100 | [diff] [blame] | 35 | #include <asm/system_misc.h> |
Russell King | 2ea8339 | 2005-06-27 14:04:05 +0100 | [diff] [blame] | 36 | #include <asm/mach/time.h> |
André Hentschel | a4780ad | 2013-06-18 23:23:26 +0100 | [diff] [blame] | 37 | #include <asm/tls.h> |
Russell King | 045ab94 | 2015-04-01 17:02:45 +0100 | [diff] [blame] | 38 | #include <asm/vdso.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
Nicolas Pitre | c743f38 | 2010-05-24 23:55:42 -0400 | [diff] [blame] | 40 | #ifdef CONFIG_CC_STACKPROTECTOR |
| 41 | #include <linux/stackprotector.h> |
| 42 | unsigned long __stack_chk_guard __read_mostly; |
| 43 | EXPORT_SYMBOL(__stack_chk_guard); |
| 44 | #endif |
| 45 | |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 46 | static const char *processor_modes[] __maybe_unused = { |
Russell King | ae0a846 | 2007-01-09 12:57:37 +0000 | [diff] [blame] | 47 | "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" , |
| 48 | "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26", |
Stephen Boyd | f3a0420 | 2014-12-01 19:45:19 +0100 | [diff] [blame] | 49 | "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "MON_32" , "ABT_32" , |
| 50 | "UK8_32" , "UK9_32" , "HYP_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32" |
Russell King | ae0a846 | 2007-01-09 12:57:37 +0000 | [diff] [blame] | 51 | }; |
| 52 | |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 53 | static const char *isa_modes[] __maybe_unused = { |
George G. Davis | 909d6c6 | 2007-06-26 01:38:27 +0100 | [diff] [blame] | 54 | "ARM" , "Thumb" , "Jazelle", "ThumbEE" |
| 55 | }; |
| 56 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | /* |
Nicolas Pitre | 4fa2043 | 2011-08-01 17:25:06 -0400 | [diff] [blame] | 58 | * This is our default idle handler. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | */ |
Nicolas Pitre | 4fa2043 | 2011-08-01 17:25:06 -0400 | [diff] [blame] | 60 | |
| 61 | void (*arm_pm_idle)(void); |
| 62 | |
Nicolas Pitre | ad68cc7 | 2014-01-29 12:45:09 -0500 | [diff] [blame] | 63 | /* |
| 64 | * Called from the core idle loop. |
| 65 | */ |
| 66 | |
| 67 | void arch_cpu_idle(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | { |
Nicolas Pitre | 4fa2043 | 2011-08-01 17:25:06 -0400 | [diff] [blame] | 69 | if (arm_pm_idle) |
| 70 | arm_pm_idle(); |
| 71 | else |
Nicolas Pitre | ae94091 | 2011-12-19 03:03:58 -0500 | [diff] [blame] | 72 | cpu_do_idle(); |
Russell King | 9ccdac3 | 2009-06-22 22:34:55 +0100 | [diff] [blame] | 73 | local_irq_enable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | } |
| 75 | |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 76 | void arch_cpu_idle_prepare(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | { |
| 78 | local_fiq_enable(); |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 79 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 81 | void arch_cpu_idle_enter(void) |
| 82 | { |
| 83 | ledtrig_cpu(CPU_LED_IDLE_START); |
Will Deacon | 11ed0ba | 2011-11-14 17:24:58 +0100 | [diff] [blame] | 84 | #ifdef CONFIG_PL310_ERRATA_769419 |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 85 | wmb(); |
Will Deacon | 11ed0ba | 2011-11-14 17:24:58 +0100 | [diff] [blame] | 86 | #endif |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | void arch_cpu_idle_exit(void) |
| 90 | { |
| 91 | ledtrig_cpu(CPU_LED_IDLE_END); |
| 92 | } |
| 93 | |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 94 | void __show_regs(struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | { |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 96 | unsigned long flags; |
| 97 | char buf[64]; |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 98 | #ifndef CONFIG_CPU_V7M |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 99 | unsigned int domain, fs; |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 100 | #ifdef CONFIG_CPU_SW_DOMAIN_PAN |
| 101 | /* |
| 102 | * Get the domain register for the parent context. In user |
| 103 | * mode, we don't save the DACR, so lets use what it should |
| 104 | * be. For other modes, we place it after the pt_regs struct. |
| 105 | */ |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 106 | if (user_mode(regs)) { |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 107 | domain = DACR_UACCESS_ENABLE; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 108 | fs = get_fs(); |
| 109 | } else { |
Russell King | 5fa9da5 | 2016-05-13 10:26:10 +0100 | [diff] [blame] | 110 | domain = to_svc_pt_regs(regs)->dacr; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 111 | fs = to_svc_pt_regs(regs)->addr_limit; |
| 112 | } |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 113 | #else |
| 114 | domain = get_domain(); |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 115 | fs = get_fs(); |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 116 | #endif |
| 117 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
Tejun Heo | a43cb95 | 2013-04-30 15:27:17 -0700 | [diff] [blame] | 119 | show_regs_print_info(KERN_DEFAULT); |
| 120 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | print_symbol("PC is at %s\n", instruction_pointer(regs)); |
| 122 | print_symbol("LR is at %s\n", regs->ARM_lr); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 123 | printk("pc : [<%08lx>] lr : [<%08lx>] psr: %08lx\n" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | "sp : %08lx ip : %08lx fp : %08lx\n", |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 125 | regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr, |
| 126 | regs->ARM_sp, regs->ARM_ip, regs->ARM_fp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | printk("r10: %08lx r9 : %08lx r8 : %08lx\n", |
| 128 | regs->ARM_r10, regs->ARM_r9, |
| 129 | regs->ARM_r8); |
| 130 | printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", |
| 131 | regs->ARM_r7, regs->ARM_r6, |
| 132 | regs->ARM_r5, regs->ARM_r4); |
| 133 | printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", |
| 134 | regs->ARM_r3, regs->ARM_r2, |
| 135 | regs->ARM_r1, regs->ARM_r0); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 136 | |
| 137 | flags = regs->ARM_cpsr; |
| 138 | buf[0] = flags & PSR_N_BIT ? 'N' : 'n'; |
| 139 | buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z'; |
| 140 | buf[2] = flags & PSR_C_BIT ? 'C' : 'c'; |
| 141 | buf[3] = flags & PSR_V_BIT ? 'V' : 'v'; |
| 142 | buf[4] = '\0'; |
| 143 | |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 144 | #ifndef CONFIG_CPU_V7M |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 145 | { |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 146 | const char *segment; |
| 147 | |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 148 | if ((domain & domain_mask(DOMAIN_USER)) == |
| 149 | domain_val(DOMAIN_USER, DOMAIN_NOACCESS)) |
| 150 | segment = "none"; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 151 | else if (fs == get_ds()) |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 152 | segment = "kernel"; |
| 153 | else |
| 154 | segment = "user"; |
| 155 | |
| 156 | printk("Flags: %s IRQs o%s FIQs o%s Mode %s ISA %s Segment %s\n", |
| 157 | buf, interrupts_enabled(regs) ? "n" : "ff", |
| 158 | fast_interrupts_enabled(regs) ? "n" : "ff", |
| 159 | processor_modes[processor_mode(regs)], |
| 160 | isa_modes[isa_mode(regs)], segment); |
| 161 | } |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 162 | #else |
| 163 | printk("xPSR: %08lx\n", regs->ARM_cpsr); |
| 164 | #endif |
| 165 | |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 166 | #ifdef CONFIG_CPU_CP15 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | { |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 168 | unsigned int ctrl; |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 169 | |
| 170 | buf[0] = '\0'; |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 171 | #ifdef CONFIG_CPU_CP15_MMU |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 172 | { |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 173 | unsigned int transbase; |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 174 | asm("mrc p15, 0, %0, c2, c0\n\t" |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 175 | : "=r" (transbase)); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 176 | snprintf(buf, sizeof(buf), " Table: %08x DAC: %08x", |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 177 | transbase, domain); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 178 | } |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 179 | #endif |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 180 | asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl)); |
| 181 | |
| 182 | printk("Control: %08x%s\n", ctrl, buf); |
| 183 | } |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 184 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 187 | void show_regs(struct pt_regs * regs) |
| 188 | { |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 189 | __show_regs(regs); |
Laura Abbott | b380ab4 | 2011-08-31 02:04:06 +0100 | [diff] [blame] | 190 | dump_stack(); |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 191 | } |
| 192 | |
Russell King | 797245f | 2009-12-18 14:34:43 +0000 | [diff] [blame] | 193 | ATOMIC_NOTIFIER_HEAD(thread_notify_head); |
| 194 | |
| 195 | EXPORT_SYMBOL_GPL(thread_notify_head); |
| 196 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | * Free current thread data structures etc.. |
| 199 | */ |
Jiri Slaby | e646469 | 2016-05-20 17:00:20 -0700 | [diff] [blame] | 200 | void exit_thread(struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | { |
Jiri Slaby | e646469 | 2016-05-20 17:00:20 -0700 | [diff] [blame] | 202 | thread_notify(THREAD_NOTIFY_EXIT, task_thread_info(tsk)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | } |
| 204 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | void flush_thread(void) |
| 206 | { |
| 207 | struct thread_info *thread = current_thread_info(); |
| 208 | struct task_struct *tsk = current; |
| 209 | |
Will Deacon | 864232f | 2010-09-03 10:42:55 +0100 | [diff] [blame] | 210 | flush_ptrace_hw_breakpoint(tsk); |
| 211 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | memset(thread->used_cp, 0, sizeof(thread->used_cp)); |
| 213 | memset(&tsk->thread.debug, 0, sizeof(struct debug_info)); |
Russell King | d6551e8 | 2006-06-21 13:31:52 +0100 | [diff] [blame] | 214 | memset(&thread->fpstate, 0, sizeof(union fp_state)); |
| 215 | |
Nathan Lynch | fbfb872 | 2014-09-11 02:49:08 +0100 | [diff] [blame] | 216 | flush_tls(); |
| 217 | |
Russell King | d6551e8 | 2006-06-21 13:31:52 +0100 | [diff] [blame] | 218 | thread_notify(THREAD_NOTIFY_FLUSH, thread); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | void release_thread(struct task_struct *dead_task) |
| 222 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); |
| 226 | |
| 227 | int |
Alexey Dobriyan | 6f2c55b | 2009-04-02 16:56:59 -0700 | [diff] [blame] | 228 | copy_thread(unsigned long clone_flags, unsigned long stack_start, |
Al Viro | afa86fc | 2012-10-22 22:51:14 -0400 | [diff] [blame] | 229 | unsigned long stk_sz, struct task_struct *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | { |
Al Viro | 815d5ec | 2006-01-12 01:05:57 -0800 | [diff] [blame] | 231 | struct thread_info *thread = task_thread_info(p); |
| 232 | struct pt_regs *childregs = task_pt_regs(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save)); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 235 | |
Russell King | af4cb25 | 2015-09-09 21:19:49 +0100 | [diff] [blame] | 236 | #ifdef CONFIG_CPU_USE_DOMAINS |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 237 | /* |
| 238 | * Copy the initial value of the domain access control register |
| 239 | * from the current thread: thread->addr_limit will have been |
| 240 | * copied from the current thread via setup_thread_stack() in |
| 241 | * kernel/fork.c |
| 242 | */ |
| 243 | thread->cpu_domain = get_domain(); |
Russell King | af4cb25 | 2015-09-09 21:19:49 +0100 | [diff] [blame] | 244 | #endif |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 245 | |
Al Viro | 38a61b6 | 2012-10-21 15:54:27 -0400 | [diff] [blame] | 246 | if (likely(!(p->flags & PF_KTHREAD))) { |
| 247 | *childregs = *current_pt_regs(); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 248 | childregs->ARM_r0 = 0; |
Al Viro | 38a61b6 | 2012-10-21 15:54:27 -0400 | [diff] [blame] | 249 | if (stack_start) |
| 250 | childregs->ARM_sp = stack_start; |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 251 | } else { |
Al Viro | 9fff2fa | 2012-10-10 22:23:29 -0400 | [diff] [blame] | 252 | memset(childregs, 0, sizeof(struct pt_regs)); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 253 | thread->cpu_context.r4 = stk_sz; |
| 254 | thread->cpu_context.r5 = stack_start; |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 255 | childregs->ARM_cpsr = SVC_MODE; |
| 256 | } |
Al Viro | 9fff2fa | 2012-10-10 22:23:29 -0400 | [diff] [blame] | 257 | thread->cpu_context.pc = (unsigned long)ret_from_fork; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | thread->cpu_context.sp = (unsigned long)childregs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | |
Will Deacon | 864232f | 2010-09-03 10:42:55 +0100 | [diff] [blame] | 260 | clear_ptrace_hw_breakpoint(p); |
| 261 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | if (clone_flags & CLONE_SETTLS) |
André Hentschel | a4780ad | 2013-06-18 23:23:26 +0100 | [diff] [blame] | 263 | thread->tp_value[0] = childregs->ARM_r3; |
| 264 | thread->tp_value[1] = get_tpuser(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | |
Catalin Marinas | 2e82669a | 2011-04-06 16:16:29 +0100 | [diff] [blame] | 266 | thread_notify(THREAD_NOTIFY_COPY, thread); |
| 267 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | return 0; |
| 269 | } |
| 270 | |
| 271 | /* |
Artem Bityutskiy | cde3f86 | 2009-10-13 08:54:30 +0100 | [diff] [blame] | 272 | * Fill in the task's elfregs structure for a core dump. |
| 273 | */ |
| 274 | int dump_task_regs(struct task_struct *t, elf_gregset_t *elfregs) |
| 275 | { |
| 276 | elf_core_copy_regs(elfregs, task_pt_regs(t)); |
| 277 | return 1; |
| 278 | } |
| 279 | |
| 280 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | * fill in the fpe structure for a core dump... |
| 282 | */ |
| 283 | int dump_fpu (struct pt_regs *regs, struct user_fp *fp) |
| 284 | { |
| 285 | struct thread_info *thread = current_thread_info(); |
| 286 | int used_math = thread->used_cp[1] | thread->used_cp[2]; |
| 287 | |
| 288 | if (used_math) |
| 289 | memcpy(fp, &thread->fpstate.soft, sizeof (*fp)); |
| 290 | |
| 291 | return used_math != 0; |
| 292 | } |
| 293 | EXPORT_SYMBOL(dump_fpu); |
| 294 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | unsigned long get_wchan(struct task_struct *p) |
| 296 | { |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 297 | struct stackframe frame; |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 298 | unsigned long stack_page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | int count = 0; |
| 300 | if (!p || p == current || p->state == TASK_RUNNING) |
| 301 | return 0; |
| 302 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 303 | frame.fp = thread_saved_fp(p); |
| 304 | frame.sp = thread_saved_sp(p); |
| 305 | frame.lr = 0; /* recovered from the stack */ |
| 306 | frame.pc = thread_saved_pc(p); |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 307 | stack_page = (unsigned long)task_stack_page(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | do { |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 309 | if (frame.sp < stack_page || |
| 310 | frame.sp >= stack_page + THREAD_SIZE || |
| 311 | unwind_frame(&frame) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | return 0; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 313 | if (!in_sched_functions(frame.pc)) |
| 314 | return frame.pc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | } while (count ++ < 16); |
| 316 | return 0; |
| 317 | } |
Nicolas Pitre | 990cb8a | 2010-06-14 16:27:19 -0400 | [diff] [blame] | 318 | |
| 319 | unsigned long arch_randomize_brk(struct mm_struct *mm) |
| 320 | { |
Jason Cooper | c984cbf | 2016-10-11 13:53:59 -0700 | [diff] [blame] | 321 | return randomize_page(mm->brk, 0x02000000); |
Nicolas Pitre | 990cb8a | 2010-06-14 16:27:19 -0400 | [diff] [blame] | 322 | } |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 323 | |
Will Deacon | 6cde6d4 | 2011-01-11 14:04:36 +0100 | [diff] [blame] | 324 | #ifdef CONFIG_MMU |
Russell King | a5463cd | 2013-07-31 21:58:56 +0100 | [diff] [blame] | 325 | #ifdef CONFIG_KUSER_HELPERS |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 326 | /* |
| 327 | * The vectors page is always readable from user space for the |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 328 | * atomic helpers. Insert it into the gate_vma so that it is visible |
| 329 | * through ptrace and /proc/<pid>/mem. |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 330 | */ |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 331 | static struct vm_area_struct gate_vma = { |
| 332 | .vm_start = 0xffff0000, |
| 333 | .vm_end = 0xffff0000 + PAGE_SIZE, |
| 334 | .vm_flags = VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYEXEC, |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 335 | }; |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 336 | |
Will Deacon | f9d4861 | 2012-01-20 12:01:13 +0100 | [diff] [blame] | 337 | static int __init gate_vma_init(void) |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 338 | { |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 339 | gate_vma.vm_page_prot = PAGE_READONLY_EXEC; |
Will Deacon | f9d4861 | 2012-01-20 12:01:13 +0100 | [diff] [blame] | 340 | return 0; |
| 341 | } |
| 342 | arch_initcall(gate_vma_init); |
| 343 | |
| 344 | struct vm_area_struct *get_gate_vma(struct mm_struct *mm) |
| 345 | { |
| 346 | return &gate_vma; |
| 347 | } |
| 348 | |
| 349 | int in_gate_area(struct mm_struct *mm, unsigned long addr) |
| 350 | { |
| 351 | return (addr >= gate_vma.vm_start) && (addr < gate_vma.vm_end); |
| 352 | } |
| 353 | |
| 354 | int in_gate_area_no_mm(unsigned long addr) |
| 355 | { |
| 356 | return in_gate_area(NULL, addr); |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 357 | } |
Russell King | 1d0bbf4 | 2013-08-06 09:49:14 +0100 | [diff] [blame] | 358 | #define is_gate_vma(vma) ((vma) == &gate_vma) |
Russell King | a5463cd | 2013-07-31 21:58:56 +0100 | [diff] [blame] | 359 | #else |
| 360 | #define is_gate_vma(vma) 0 |
| 361 | #endif |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 362 | |
| 363 | const char *arch_vma_name(struct vm_area_struct *vma) |
| 364 | { |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 365 | return is_gate_vma(vma) ? "[vectors]" : NULL; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 366 | } |
| 367 | |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 368 | /* If possible, provide a placement hint at a random offset from the |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 369 | * stack for the sigpage and vdso pages. |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 370 | */ |
| 371 | static unsigned long sigpage_addr(const struct mm_struct *mm, |
| 372 | unsigned int npages) |
| 373 | { |
| 374 | unsigned long offset; |
| 375 | unsigned long first; |
| 376 | unsigned long last; |
| 377 | unsigned long addr; |
| 378 | unsigned int slots; |
| 379 | |
| 380 | first = PAGE_ALIGN(mm->start_stack); |
| 381 | |
| 382 | last = TASK_SIZE - (npages << PAGE_SHIFT); |
| 383 | |
| 384 | /* No room after stack? */ |
| 385 | if (first > last) |
| 386 | return 0; |
| 387 | |
| 388 | /* Just enough room? */ |
| 389 | if (first == last) |
| 390 | return first; |
| 391 | |
| 392 | slots = ((last - first) >> PAGE_SHIFT) + 1; |
| 393 | |
| 394 | offset = get_random_int() % slots; |
| 395 | |
| 396 | addr = first + (offset << PAGE_SHIFT); |
| 397 | |
| 398 | return addr; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 399 | } |
| 400 | |
Russell King | e0d4075 | 2013-08-03 10:30:05 +0100 | [diff] [blame] | 401 | static struct page *signal_page; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 402 | extern struct page *get_signal_page(void); |
| 403 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 404 | static const struct vm_special_mapping sigpage_mapping = { |
| 405 | .name = "[sigpage]", |
| 406 | .pages = &signal_page, |
| 407 | }; |
| 408 | |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 409 | int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) |
| 410 | { |
| 411 | struct mm_struct *mm = current->mm; |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 412 | struct vm_area_struct *vma; |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 413 | unsigned long npages; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 414 | unsigned long addr; |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 415 | unsigned long hint; |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 416 | int ret = 0; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 417 | |
Russell King | e0d4075 | 2013-08-03 10:30:05 +0100 | [diff] [blame] | 418 | if (!signal_page) |
| 419 | signal_page = get_signal_page(); |
| 420 | if (!signal_page) |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 421 | return -ENOMEM; |
| 422 | |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 423 | npages = 1; /* for sigpage */ |
| 424 | npages += vdso_total_pages; |
| 425 | |
Michal Hocko | 6904817 | 2016-05-23 16:25:54 -0700 | [diff] [blame] | 426 | if (down_write_killable(&mm->mmap_sem)) |
| 427 | return -EINTR; |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 428 | hint = sigpage_addr(mm, npages); |
| 429 | addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0); |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 430 | if (IS_ERR_VALUE(addr)) { |
| 431 | ret = addr; |
| 432 | goto up_fail; |
| 433 | } |
| 434 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 435 | vma = _install_special_mapping(mm, addr, PAGE_SIZE, |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 436 | VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC, |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 437 | &sigpage_mapping); |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 438 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 439 | if (IS_ERR(vma)) { |
| 440 | ret = PTR_ERR(vma); |
| 441 | goto up_fail; |
| 442 | } |
| 443 | |
| 444 | mm->context.sigpage = addr; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 445 | |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 446 | /* Unlike the sigpage, failure to install the vdso is unlikely |
| 447 | * to be fatal to the process, so no error check needed |
| 448 | * here. |
| 449 | */ |
| 450 | arm_install_vdso(mm, addr + PAGE_SIZE); |
| 451 | |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 452 | up_fail: |
| 453 | up_write(&mm->mmap_sem); |
| 454 | return ret; |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 455 | } |
Will Deacon | 6cde6d4 | 2011-01-11 14:04:36 +0100 | [diff] [blame] | 456 | #endif |