2 * Based on arch/arm/kernel/process.c
4 * Original Copyright (C) 1995 Linus Torvalds
5 * Copyright (C) 1996-2000 Russell King - Converted to ARM.
6 * Copyright (C) 2012 ARM Ltd.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include <linux/compat.h>
24 #include <linux/export.h>
25 #include <linux/sched.h>
26 #include <linux/kernel.h>
28 #include <linux/stddef.h>
29 #include <linux/unistd.h>
30 #include <linux/user.h>
31 #include <linux/delay.h>
32 #include <linux/reboot.h>
33 #include <linux/interrupt.h>
34 #include <linux/kallsyms.h>
35 #include <linux/init.h>
36 #include <linux/cpu.h>
37 #include <linux/elfcore.h>
39 #include <linux/tick.h>
40 #include <linux/utsname.h>
41 #include <linux/uaccess.h>
42 #include <linux/random.h>
43 #include <linux/hw_breakpoint.h>
44 #include <linux/personality.h>
45 #include <linux/notifier.h>
47 #include <asm/compat.h>
48 #include <asm/cacheflush.h>
49 #include <asm/fpsimd.h>
50 #include <asm/mmu_context.h>
51 #include <asm/processor.h>
52 #include <asm/stacktrace.h>
54 static void setup_restart(void)
57 * Tell the mm system that we are going to reboot -
58 * we may need it to insert some 1:1 mappings so that
61 setup_mm_for_reboot();
63 /* Clean and invalidate caches */
66 /* Turn D-cache off */
69 /* Push out any further dirty data, and ensure cache is empty */
73 void soft_restart(unsigned long addr)
80 * Function pointers to optional machine specific functions
82 void (*pm_power_off)(void);
83 EXPORT_SYMBOL_GPL(pm_power_off);
85 void (*arm_pm_restart)(char str, const char *cmd);
86 EXPORT_SYMBOL_GPL(arm_pm_restart);
88 void arch_cpu_idle_prepare(void)
94 * This is our default idle handler.
96 void arch_cpu_idle(void)
99 * This should do all the clock switching and wait for interrupt
106 void machine_shutdown(void)
113 void machine_halt(void)
119 void machine_power_off(void)
126 void machine_restart(char *cmd)
130 /* Disable interrupts first */
134 /* Now call the architecture specific reboot code. */
136 arm_pm_restart('h', cmd);
139 * Whoops - the architecture was unable to reboot.
141 printk("Reboot failed -- System halted\n");
146 * dump a block of kernel memory from around the given address
148 static void show_data(unsigned long addr, int nbytes, const char *name)
155 * don't attempt to dump non-kernel addresses or
156 * values that are probably just small negative numbers
158 if (addr < PAGE_OFFSET || addr > -256UL)
161 printk("\n%s: %#lx:\n", name, addr);
164 * round address down to a 32 bit boundary
165 * and always dump a multiple of 32 bytes
167 p = (u32 *)(addr & ~(sizeof(u32) - 1));
168 nbytes += (addr & (sizeof(u32) - 1));
169 nlines = (nbytes + 31) / 32;
172 for (i = 0; i < nlines; i++) {
174 * just display low 16 bits of address to keep
175 * each line of the dump < 80 characters
177 printk("%04lx ", (unsigned long)p & 0xffff);
178 for (j = 0; j < 8; j++) {
180 if (probe_kernel_address(p, data)) {
183 printk(" %08x", data);
191 static void show_extra_register_data(struct pt_regs *regs, int nbytes)
198 show_data(regs->pc - nbytes, nbytes * 2, "PC");
199 show_data(regs->regs[30] - nbytes, nbytes * 2, "LR");
200 show_data(regs->sp - nbytes, nbytes * 2, "SP");
201 for (i = 0; i < 30; i++) {
203 snprintf(name, sizeof(name), "X%u", i);
204 show_data(regs->regs[i] - nbytes, nbytes * 2, name);
209 void __show_regs(struct pt_regs *regs)
213 show_regs_print_info(KERN_DEFAULT);
214 print_symbol("PC is at %s\n", instruction_pointer(regs));
215 print_symbol("LR is at %s\n", regs->regs[30]);
216 printk("pc : [<%016llx>] lr : [<%016llx>] pstate: %08llx\n",
217 regs->pc, regs->regs[30], regs->pstate);
218 printk("sp : %016llx\n", regs->sp);
219 for (i = 29; i >= 0; i--) {
220 printk("x%-2d: %016llx ", i, regs->regs[i]);
224 if (!user_mode(regs))
225 show_extra_register_data(regs, 128);
229 void show_regs(struct pt_regs * regs)
236 * Free current thread data structures etc..
238 void exit_thread(void)
242 void flush_thread(void)
244 fpsimd_flush_thread();
245 flush_ptrace_hw_breakpoint(current);
248 void release_thread(struct task_struct *dead_task)
252 int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
254 fpsimd_preserve_current_state();
259 asmlinkage void ret_from_fork(void) asm("ret_from_fork");
261 int copy_thread(unsigned long clone_flags, unsigned long stack_start,
262 unsigned long stk_sz, struct task_struct *p)
264 struct pt_regs *childregs = task_pt_regs(p);
265 unsigned long tls = p->thread.tp_value;
267 memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));
269 if (likely(!(p->flags & PF_KTHREAD))) {
270 *childregs = *current_pt_regs();
271 childregs->regs[0] = 0;
272 if (is_compat_thread(task_thread_info(p))) {
274 childregs->compat_sp = stack_start;
277 * Read the current TLS pointer from tpidr_el0 as it may be
278 * out-of-sync with the saved value.
280 asm("mrs %0, tpidr_el0" : "=r" (tls));
282 /* 16-byte aligned stack mandatory on AArch64 */
283 if (stack_start & 15)
285 childregs->sp = stack_start;
289 * If a TLS pointer was passed to clone (4th argument), use it
290 * for the new thread.
292 if (clone_flags & CLONE_SETTLS)
293 tls = childregs->regs[3];
295 memset(childregs, 0, sizeof(struct pt_regs));
296 childregs->pstate = PSR_MODE_EL1h;
297 p->thread.cpu_context.x19 = stack_start;
298 p->thread.cpu_context.x20 = stk_sz;
300 p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
301 p->thread.cpu_context.sp = (unsigned long)childregs;
302 p->thread.tp_value = tls;
304 ptrace_hw_copy_thread(p);
309 static void tls_thread_switch(struct task_struct *next)
311 unsigned long tpidr, tpidrro;
313 if (!is_compat_task()) {
314 asm("mrs %0, tpidr_el0" : "=r" (tpidr));
315 current->thread.tp_value = tpidr;
318 if (is_compat_thread(task_thread_info(next))) {
320 tpidrro = next->thread.tp_value;
322 tpidr = next->thread.tp_value;
327 " msr tpidr_el0, %0\n"
328 " msr tpidrro_el0, %1"
329 : : "r" (tpidr), "r" (tpidrro));
335 struct task_struct *__switch_to(struct task_struct *prev,
336 struct task_struct *next)
338 struct task_struct *last;
340 fpsimd_thread_switch(next);
341 tls_thread_switch(next);
342 hw_breakpoint_thread_switch(next);
343 contextidr_thread_switch(next);
346 * Complete any pending TLB or cache maintenance on this CPU in case
347 * the thread migrates to a different CPU.
351 /* the actual thread switch */
352 last = cpu_switch_to(prev, next);
357 unsigned long get_wchan(struct task_struct *p)
359 struct stackframe frame;
361 if (!p || p == current || p->state == TASK_RUNNING)
364 frame.fp = thread_saved_fp(p);
365 frame.sp = thread_saved_sp(p);
366 frame.pc = thread_saved_pc(p);
368 int ret = unwind_frame(&frame);
371 if (!in_sched_functions(frame.pc))
373 } while (count ++ < 16);
377 unsigned long arch_align_stack(unsigned long sp)
379 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
380 sp -= get_random_int() & ~PAGE_MASK;
384 static unsigned long randomize_base(unsigned long base)
386 unsigned long range_end = base + (STACK_RND_MASK << PAGE_SHIFT) + 1;
387 return randomize_range(base, range_end, 0) ? : base;
390 unsigned long arch_randomize_brk(struct mm_struct *mm)
392 return randomize_base(mm->brk);
395 unsigned long randomize_et_dyn(unsigned long base)
397 return randomize_base(base);