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 | { |
Todd Poynor | 83285ed | 2011-06-15 17:44:50 -0700 | [diff] [blame] | 83 | idle_notifier_call_chain(IDLE_START); |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 84 | ledtrig_cpu(CPU_LED_IDLE_START); |
Will Deacon | 11ed0ba | 2011-11-14 17:24:58 +0100 | [diff] [blame] | 85 | #ifdef CONFIG_PL310_ERRATA_769419 |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 86 | wmb(); |
Will Deacon | 11ed0ba | 2011-11-14 17:24:58 +0100 | [diff] [blame] | 87 | #endif |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | void arch_cpu_idle_exit(void) |
| 91 | { |
| 92 | ledtrig_cpu(CPU_LED_IDLE_END); |
Todd Poynor | 83285ed | 2011-06-15 17:44:50 -0700 | [diff] [blame] | 93 | idle_notifier_call_chain(IDLE_END); |
Thomas Gleixner | f7b861b | 2013-03-21 22:49:38 +0100 | [diff] [blame] | 94 | } |
| 95 | |
San Mehat | c6023aa | 2009-08-25 16:52:22 -0700 | [diff] [blame] | 96 | /* |
| 97 | * dump a block of kernel memory from around the given address |
| 98 | */ |
| 99 | static void show_data(unsigned long addr, int nbytes, const char *name) |
| 100 | { |
| 101 | int i, j; |
| 102 | int nlines; |
| 103 | u32 *p; |
| 104 | |
| 105 | /* |
| 106 | * don't attempt to dump non-kernel addresses or |
| 107 | * values that are probably just small negative numbers |
| 108 | */ |
| 109 | if (addr < PAGE_OFFSET || addr > -256UL) |
| 110 | return; |
| 111 | |
| 112 | printk("\n%s: %#lx:\n", name, addr); |
| 113 | |
| 114 | /* |
| 115 | * round address down to a 32 bit boundary |
| 116 | * and always dump a multiple of 32 bytes |
| 117 | */ |
| 118 | p = (u32 *)(addr & ~(sizeof(u32) - 1)); |
| 119 | nbytes += (addr & (sizeof(u32) - 1)); |
| 120 | nlines = (nbytes + 31) / 32; |
| 121 | |
| 122 | |
| 123 | for (i = 0; i < nlines; i++) { |
| 124 | /* |
| 125 | * just display low 16 bits of address to keep |
| 126 | * each line of the dump < 80 characters |
| 127 | */ |
| 128 | printk("%04lx ", (unsigned long)p & 0xffff); |
| 129 | for (j = 0; j < 8; j++) { |
| 130 | u32 data; |
| 131 | if (probe_kernel_address(p, data)) { |
Ji Zhang | 40a1830 | 2018-01-26 15:21:12 +0800 | [diff] [blame] | 132 | pr_cont(" ********"); |
San Mehat | c6023aa | 2009-08-25 16:52:22 -0700 | [diff] [blame] | 133 | } else { |
Ji Zhang | 40a1830 | 2018-01-26 15:21:12 +0800 | [diff] [blame] | 134 | pr_cont(" %08x", data); |
San Mehat | c6023aa | 2009-08-25 16:52:22 -0700 | [diff] [blame] | 135 | } |
| 136 | ++p; |
| 137 | } |
Ji Zhang | 40a1830 | 2018-01-26 15:21:12 +0800 | [diff] [blame] | 138 | pr_cont("\n"); |
San Mehat | c6023aa | 2009-08-25 16:52:22 -0700 | [diff] [blame] | 139 | } |
| 140 | } |
| 141 | |
| 142 | static void show_extra_register_data(struct pt_regs *regs, int nbytes) |
| 143 | { |
| 144 | mm_segment_t fs; |
| 145 | |
| 146 | fs = get_fs(); |
| 147 | set_fs(KERNEL_DS); |
| 148 | show_data(regs->ARM_pc - nbytes, nbytes * 2, "PC"); |
| 149 | show_data(regs->ARM_lr - nbytes, nbytes * 2, "LR"); |
| 150 | show_data(regs->ARM_sp - nbytes, nbytes * 2, "SP"); |
| 151 | show_data(regs->ARM_ip - nbytes, nbytes * 2, "IP"); |
| 152 | show_data(regs->ARM_fp - nbytes, nbytes * 2, "FP"); |
| 153 | show_data(regs->ARM_r0 - nbytes, nbytes * 2, "R0"); |
| 154 | show_data(regs->ARM_r1 - nbytes, nbytes * 2, "R1"); |
| 155 | show_data(regs->ARM_r2 - nbytes, nbytes * 2, "R2"); |
| 156 | show_data(regs->ARM_r3 - nbytes, nbytes * 2, "R3"); |
| 157 | show_data(regs->ARM_r4 - nbytes, nbytes * 2, "R4"); |
| 158 | show_data(regs->ARM_r5 - nbytes, nbytes * 2, "R5"); |
| 159 | show_data(regs->ARM_r6 - nbytes, nbytes * 2, "R6"); |
| 160 | show_data(regs->ARM_r7 - nbytes, nbytes * 2, "R7"); |
| 161 | show_data(regs->ARM_r8 - nbytes, nbytes * 2, "R8"); |
| 162 | show_data(regs->ARM_r9 - nbytes, nbytes * 2, "R9"); |
| 163 | show_data(regs->ARM_r10 - nbytes, nbytes * 2, "R10"); |
| 164 | set_fs(fs); |
| 165 | } |
| 166 | |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 167 | void __show_regs(struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | { |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 169 | unsigned long flags; |
| 170 | char buf[64]; |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 171 | #ifndef CONFIG_CPU_V7M |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 172 | unsigned int domain, fs; |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 173 | #ifdef CONFIG_CPU_SW_DOMAIN_PAN |
| 174 | /* |
| 175 | * Get the domain register for the parent context. In user |
| 176 | * mode, we don't save the DACR, so lets use what it should |
| 177 | * be. For other modes, we place it after the pt_regs struct. |
| 178 | */ |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 179 | if (user_mode(regs)) { |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 180 | domain = DACR_UACCESS_ENABLE; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 181 | fs = get_fs(); |
| 182 | } else { |
Russell King | 5fa9da5 | 2016-05-13 10:26:10 +0100 | [diff] [blame] | 183 | domain = to_svc_pt_regs(regs)->dacr; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 184 | fs = to_svc_pt_regs(regs)->addr_limit; |
| 185 | } |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 186 | #else |
| 187 | domain = get_domain(); |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 188 | fs = get_fs(); |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 189 | #endif |
| 190 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | |
Tejun Heo | a43cb95 | 2013-04-30 15:27:17 -0700 | [diff] [blame] | 192 | show_regs_print_info(KERN_DEFAULT); |
| 193 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | print_symbol("PC is at %s\n", instruction_pointer(regs)); |
| 195 | print_symbol("LR is at %s\n", regs->ARM_lr); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 196 | printk("pc : [<%08lx>] lr : [<%08lx>] psr: %08lx\n" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | "sp : %08lx ip : %08lx fp : %08lx\n", |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 198 | regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr, |
| 199 | regs->ARM_sp, regs->ARM_ip, regs->ARM_fp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | printk("r10: %08lx r9 : %08lx r8 : %08lx\n", |
| 201 | regs->ARM_r10, regs->ARM_r9, |
| 202 | regs->ARM_r8); |
| 203 | printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", |
| 204 | regs->ARM_r7, regs->ARM_r6, |
| 205 | regs->ARM_r5, regs->ARM_r4); |
| 206 | printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", |
| 207 | regs->ARM_r3, regs->ARM_r2, |
| 208 | regs->ARM_r1, regs->ARM_r0); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 209 | |
| 210 | flags = regs->ARM_cpsr; |
| 211 | buf[0] = flags & PSR_N_BIT ? 'N' : 'n'; |
| 212 | buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z'; |
| 213 | buf[2] = flags & PSR_C_BIT ? 'C' : 'c'; |
| 214 | buf[3] = flags & PSR_V_BIT ? 'V' : 'v'; |
| 215 | buf[4] = '\0'; |
| 216 | |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 217 | #ifndef CONFIG_CPU_V7M |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 218 | { |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 219 | const char *segment; |
| 220 | |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 221 | if ((domain & domain_mask(DOMAIN_USER)) == |
| 222 | domain_val(DOMAIN_USER, DOMAIN_NOACCESS)) |
| 223 | segment = "none"; |
Russell King | e6978e4 | 2016-05-13 11:40:20 +0100 | [diff] [blame] | 224 | else if (fs == get_ds()) |
Russell King | a5e090a | 2015-08-19 20:40:41 +0100 | [diff] [blame] | 225 | segment = "kernel"; |
| 226 | else |
| 227 | segment = "user"; |
| 228 | |
| 229 | printk("Flags: %s IRQs o%s FIQs o%s Mode %s ISA %s Segment %s\n", |
| 230 | buf, interrupts_enabled(regs) ? "n" : "ff", |
| 231 | fast_interrupts_enabled(regs) ? "n" : "ff", |
| 232 | processor_modes[processor_mode(regs)], |
| 233 | isa_modes[isa_mode(regs)], segment); |
| 234 | } |
Uwe Kleine-König | e2e55fd | 2013-12-16 10:38:57 +0100 | [diff] [blame] | 235 | #else |
| 236 | printk("xPSR: %08lx\n", regs->ARM_cpsr); |
| 237 | #endif |
| 238 | |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 239 | #ifdef CONFIG_CPU_CP15 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | { |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 241 | unsigned int ctrl; |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 242 | |
| 243 | buf[0] = '\0'; |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 244 | #ifdef CONFIG_CPU_CP15_MMU |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 245 | { |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 246 | unsigned int transbase; |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 247 | asm("mrc p15, 0, %0, c2, c0\n\t" |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 248 | : "=r" (transbase)); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 249 | snprintf(buf, sizeof(buf), " Table: %08x DAC: %08x", |
Russell King | 77f1b959 | 2015-12-03 14:34:45 +0000 | [diff] [blame] | 250 | transbase, domain); |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 251 | } |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 252 | #endif |
Russell King | 154c772 | 2007-06-18 14:59:45 +0100 | [diff] [blame] | 253 | asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl)); |
| 254 | |
| 255 | printk("Control: %08x%s\n", ctrl, buf); |
| 256 | } |
Hyok S. Choi | f12d0d7 | 2006-09-26 17:36:37 +0900 | [diff] [blame] | 257 | #endif |
San Mehat | c6023aa | 2009-08-25 16:52:22 -0700 | [diff] [blame] | 258 | |
| 259 | show_extra_register_data(regs, 128); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 262 | void show_regs(struct pt_regs * regs) |
| 263 | { |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 264 | __show_regs(regs); |
Laura Abbott | b380ab4 | 2011-08-31 02:04:06 +0100 | [diff] [blame] | 265 | dump_stack(); |
Russell King | 652a12e | 2005-04-17 15:50:36 +0100 | [diff] [blame] | 266 | } |
| 267 | |
Russell King | 797245f | 2009-12-18 14:34:43 +0000 | [diff] [blame] | 268 | ATOMIC_NOTIFIER_HEAD(thread_notify_head); |
| 269 | |
| 270 | EXPORT_SYMBOL_GPL(thread_notify_head); |
| 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | * Free current thread data structures etc.. |
| 274 | */ |
Jiri Slaby | e646469 | 2016-05-20 17:00:20 -0700 | [diff] [blame] | 275 | void exit_thread(struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | { |
Jiri Slaby | e646469 | 2016-05-20 17:00:20 -0700 | [diff] [blame] | 277 | thread_notify(THREAD_NOTIFY_EXIT, task_thread_info(tsk)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | } |
| 279 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | void flush_thread(void) |
| 281 | { |
| 282 | struct thread_info *thread = current_thread_info(); |
| 283 | struct task_struct *tsk = current; |
| 284 | |
Will Deacon | 864232f | 2010-09-03 10:42:55 +0100 | [diff] [blame] | 285 | flush_ptrace_hw_breakpoint(tsk); |
| 286 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | memset(thread->used_cp, 0, sizeof(thread->used_cp)); |
| 288 | memset(&tsk->thread.debug, 0, sizeof(struct debug_info)); |
Russell King | d6551e8 | 2006-06-21 13:31:52 +0100 | [diff] [blame] | 289 | memset(&thread->fpstate, 0, sizeof(union fp_state)); |
| 290 | |
Nathan Lynch | fbfb872 | 2014-09-11 02:49:08 +0100 | [diff] [blame] | 291 | flush_tls(); |
| 292 | |
Russell King | d6551e8 | 2006-06-21 13:31:52 +0100 | [diff] [blame] | 293 | thread_notify(THREAD_NOTIFY_FLUSH, thread); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | } |
| 295 | |
| 296 | void release_thread(struct task_struct *dead_task) |
| 297 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); |
| 301 | |
| 302 | int |
Alexey Dobriyan | 6f2c55b | 2009-04-02 16:56:59 -0700 | [diff] [blame] | 303 | copy_thread(unsigned long clone_flags, unsigned long stack_start, |
Al Viro | afa86fc | 2012-10-22 22:51:14 -0400 | [diff] [blame] | 304 | unsigned long stk_sz, struct task_struct *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | { |
Al Viro | 815d5ec | 2006-01-12 01:05:57 -0800 | [diff] [blame] | 306 | struct thread_info *thread = task_thread_info(p); |
| 307 | struct pt_regs *childregs = task_pt_regs(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save)); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 310 | |
Russell King | af4cb25 | 2015-09-09 21:19:49 +0100 | [diff] [blame] | 311 | #ifdef CONFIG_CPU_USE_DOMAINS |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 312 | /* |
| 313 | * Copy the initial value of the domain access control register |
| 314 | * from the current thread: thread->addr_limit will have been |
| 315 | * copied from the current thread via setup_thread_stack() in |
| 316 | * kernel/fork.c |
| 317 | */ |
| 318 | thread->cpu_domain = get_domain(); |
Russell King | af4cb25 | 2015-09-09 21:19:49 +0100 | [diff] [blame] | 319 | #endif |
Russell King | 1eef5d2 | 2015-08-19 21:23:48 +0100 | [diff] [blame] | 320 | |
Al Viro | 38a61b6 | 2012-10-21 15:54:27 -0400 | [diff] [blame] | 321 | if (likely(!(p->flags & PF_KTHREAD))) { |
| 322 | *childregs = *current_pt_regs(); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 323 | childregs->ARM_r0 = 0; |
Al Viro | 38a61b6 | 2012-10-21 15:54:27 -0400 | [diff] [blame] | 324 | if (stack_start) |
| 325 | childregs->ARM_sp = stack_start; |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 326 | } else { |
Al Viro | 9fff2fa | 2012-10-10 22:23:29 -0400 | [diff] [blame] | 327 | memset(childregs, 0, sizeof(struct pt_regs)); |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 328 | thread->cpu_context.r4 = stk_sz; |
| 329 | thread->cpu_context.r5 = stack_start; |
Al Viro | 9e14f82 | 2012-09-09 21:31:07 -0400 | [diff] [blame] | 330 | childregs->ARM_cpsr = SVC_MODE; |
| 331 | } |
Al Viro | 9fff2fa | 2012-10-10 22:23:29 -0400 | [diff] [blame] | 332 | thread->cpu_context.pc = (unsigned long)ret_from_fork; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | thread->cpu_context.sp = (unsigned long)childregs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
Will Deacon | 864232f | 2010-09-03 10:42:55 +0100 | [diff] [blame] | 335 | clear_ptrace_hw_breakpoint(p); |
| 336 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | if (clone_flags & CLONE_SETTLS) |
André Hentschel | a4780ad | 2013-06-18 23:23:26 +0100 | [diff] [blame] | 338 | thread->tp_value[0] = childregs->ARM_r3; |
| 339 | thread->tp_value[1] = get_tpuser(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | |
Catalin Marinas | 2e82669a | 2011-04-06 16:16:29 +0100 | [diff] [blame] | 341 | thread_notify(THREAD_NOTIFY_COPY, thread); |
| 342 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | return 0; |
| 344 | } |
| 345 | |
| 346 | /* |
Artem Bityutskiy | cde3f86 | 2009-10-13 08:54:30 +0100 | [diff] [blame] | 347 | * Fill in the task's elfregs structure for a core dump. |
| 348 | */ |
| 349 | int dump_task_regs(struct task_struct *t, elf_gregset_t *elfregs) |
| 350 | { |
| 351 | elf_core_copy_regs(elfregs, task_pt_regs(t)); |
| 352 | return 1; |
| 353 | } |
| 354 | |
| 355 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | * fill in the fpe structure for a core dump... |
| 357 | */ |
| 358 | int dump_fpu (struct pt_regs *regs, struct user_fp *fp) |
| 359 | { |
| 360 | struct thread_info *thread = current_thread_info(); |
| 361 | int used_math = thread->used_cp[1] | thread->used_cp[2]; |
| 362 | |
| 363 | if (used_math) |
| 364 | memcpy(fp, &thread->fpstate.soft, sizeof (*fp)); |
| 365 | |
| 366 | return used_math != 0; |
| 367 | } |
| 368 | EXPORT_SYMBOL(dump_fpu); |
| 369 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | unsigned long get_wchan(struct task_struct *p) |
| 371 | { |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 372 | struct stackframe frame; |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 373 | unsigned long stack_page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | int count = 0; |
| 375 | if (!p || p == current || p->state == TASK_RUNNING) |
| 376 | return 0; |
| 377 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 378 | frame.fp = thread_saved_fp(p); |
| 379 | frame.sp = thread_saved_sp(p); |
| 380 | frame.lr = 0; /* recovered from the stack */ |
| 381 | frame.pc = thread_saved_pc(p); |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 382 | stack_page = (unsigned long)task_stack_page(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | do { |
Konstantin Khlebnikov | 1b15ec7 | 2013-12-05 14:21:36 +0100 | [diff] [blame] | 384 | if (frame.sp < stack_page || |
| 385 | frame.sp >= stack_page + THREAD_SIZE || |
| 386 | unwind_frame(&frame) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | return 0; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 388 | if (!in_sched_functions(frame.pc)) |
| 389 | return frame.pc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | } while (count ++ < 16); |
| 391 | return 0; |
| 392 | } |
Nicolas Pitre | 990cb8a | 2010-06-14 16:27:19 -0400 | [diff] [blame] | 393 | |
| 394 | unsigned long arch_randomize_brk(struct mm_struct *mm) |
| 395 | { |
Jason Cooper | c984cbf | 2016-10-11 13:53:59 -0700 | [diff] [blame] | 396 | return randomize_page(mm->brk, 0x02000000); |
Nicolas Pitre | 990cb8a | 2010-06-14 16:27:19 -0400 | [diff] [blame] | 397 | } |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 398 | |
Will Deacon | 6cde6d4 | 2011-01-11 14:04:36 +0100 | [diff] [blame] | 399 | #ifdef CONFIG_MMU |
Russell King | a5463cd | 2013-07-31 21:58:56 +0100 | [diff] [blame] | 400 | #ifdef CONFIG_KUSER_HELPERS |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 401 | /* |
| 402 | * The vectors page is always readable from user space for the |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 403 | * atomic helpers. Insert it into the gate_vma so that it is visible |
| 404 | * through ptrace and /proc/<pid>/mem. |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 405 | */ |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 406 | static struct vm_area_struct gate_vma = { |
| 407 | .vm_start = 0xffff0000, |
| 408 | .vm_end = 0xffff0000 + PAGE_SIZE, |
| 409 | .vm_flags = VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYEXEC, |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 410 | }; |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 411 | |
Will Deacon | f9d4861 | 2012-01-20 12:01:13 +0100 | [diff] [blame] | 412 | static int __init gate_vma_init(void) |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 413 | { |
Russell King | f6604ef | 2013-02-23 17:55:39 +0000 | [diff] [blame] | 414 | gate_vma.vm_page_prot = PAGE_READONLY_EXEC; |
Will Deacon | f9d4861 | 2012-01-20 12:01:13 +0100 | [diff] [blame] | 415 | return 0; |
| 416 | } |
| 417 | arch_initcall(gate_vma_init); |
| 418 | |
| 419 | struct vm_area_struct *get_gate_vma(struct mm_struct *mm) |
| 420 | { |
| 421 | return &gate_vma; |
| 422 | } |
| 423 | |
| 424 | int in_gate_area(struct mm_struct *mm, unsigned long addr) |
| 425 | { |
| 426 | return (addr >= gate_vma.vm_start) && (addr < gate_vma.vm_end); |
| 427 | } |
| 428 | |
| 429 | int in_gate_area_no_mm(unsigned long addr) |
| 430 | { |
| 431 | return in_gate_area(NULL, addr); |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 432 | } |
Russell King | 1d0bbf4 | 2013-08-06 09:49:14 +0100 | [diff] [blame] | 433 | #define is_gate_vma(vma) ((vma) == &gate_vma) |
Russell King | a5463cd | 2013-07-31 21:58:56 +0100 | [diff] [blame] | 434 | #else |
| 435 | #define is_gate_vma(vma) 0 |
| 436 | #endif |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 437 | |
| 438 | const char *arch_vma_name(struct vm_area_struct *vma) |
| 439 | { |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 440 | return is_gate_vma(vma) ? "[vectors]" : NULL; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 441 | } |
| 442 | |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 443 | /* If possible, provide a placement hint at a random offset from the |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 444 | * stack for the sigpage and vdso pages. |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 445 | */ |
| 446 | static unsigned long sigpage_addr(const struct mm_struct *mm, |
| 447 | unsigned int npages) |
| 448 | { |
| 449 | unsigned long offset; |
| 450 | unsigned long first; |
| 451 | unsigned long last; |
| 452 | unsigned long addr; |
| 453 | unsigned int slots; |
| 454 | |
| 455 | first = PAGE_ALIGN(mm->start_stack); |
| 456 | |
| 457 | last = TASK_SIZE - (npages << PAGE_SHIFT); |
| 458 | |
| 459 | /* No room after stack? */ |
| 460 | if (first > last) |
| 461 | return 0; |
| 462 | |
| 463 | /* Just enough room? */ |
| 464 | if (first == last) |
| 465 | return first; |
| 466 | |
| 467 | slots = ((last - first) >> PAGE_SHIFT) + 1; |
| 468 | |
| 469 | offset = get_random_int() % slots; |
| 470 | |
| 471 | addr = first + (offset << PAGE_SHIFT); |
| 472 | |
| 473 | return addr; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 474 | } |
| 475 | |
Russell King | e0d4075 | 2013-08-03 10:30:05 +0100 | [diff] [blame] | 476 | static struct page *signal_page; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 477 | extern struct page *get_signal_page(void); |
| 478 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 479 | static const struct vm_special_mapping sigpage_mapping = { |
| 480 | .name = "[sigpage]", |
| 481 | .pages = &signal_page, |
| 482 | }; |
| 483 | |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 484 | int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) |
| 485 | { |
| 486 | struct mm_struct *mm = current->mm; |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 487 | struct vm_area_struct *vma; |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 488 | unsigned long npages; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 489 | unsigned long addr; |
Nathan Lynch | 389522b | 2014-09-22 22:12:35 +0100 | [diff] [blame] | 490 | unsigned long hint; |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 491 | int ret = 0; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 492 | |
Russell King | e0d4075 | 2013-08-03 10:30:05 +0100 | [diff] [blame] | 493 | if (!signal_page) |
| 494 | signal_page = get_signal_page(); |
| 495 | if (!signal_page) |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 496 | return -ENOMEM; |
| 497 | |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 498 | npages = 1; /* for sigpage */ |
| 499 | npages += vdso_total_pages; |
| 500 | |
Michal Hocko | 6904817 | 2016-05-23 16:25:54 -0700 | [diff] [blame] | 501 | if (down_write_killable(&mm->mmap_sem)) |
| 502 | return -EINTR; |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 503 | hint = sigpage_addr(mm, npages); |
| 504 | addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0); |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 505 | if (IS_ERR_VALUE(addr)) { |
| 506 | ret = addr; |
| 507 | goto up_fail; |
| 508 | } |
| 509 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 510 | vma = _install_special_mapping(mm, addr, PAGE_SIZE, |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 511 | VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC, |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 512 | &sigpage_mapping); |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 513 | |
Nathan Lynch | 02e0409 | 2014-09-22 22:08:42 +0100 | [diff] [blame] | 514 | if (IS_ERR(vma)) { |
| 515 | ret = PTR_ERR(vma); |
| 516 | goto up_fail; |
| 517 | } |
| 518 | |
| 519 | mm->context.sigpage = addr; |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 520 | |
Nathan Lynch | ecf99a4 | 2015-03-25 19:15:08 +0100 | [diff] [blame] | 521 | /* Unlike the sigpage, failure to install the vdso is unlikely |
| 522 | * to be fatal to the process, so no error check needed |
| 523 | * here. |
| 524 | */ |
| 525 | arm_install_vdso(mm, addr + PAGE_SIZE); |
| 526 | |
Russell King | 48be69a | 2013-07-24 00:29:18 +0100 | [diff] [blame] | 527 | up_fail: |
| 528 | up_write(&mm->mmap_sem); |
| 529 | return ret; |
Nicolas Pitre | ec706da | 2010-08-26 23:10:50 -0400 | [diff] [blame] | 530 | } |
Will Deacon | 6cde6d4 | 2011-01-11 14:04:36 +0100 | [diff] [blame] | 531 | #endif |