// SPDX-License-Identifier: GPL-2.0 // Copyright (C) 2005-2017 Andes Technology Corporation #include <linux/sched.h> #include <linux/sched/debug.h> #include <linux/sched/task_stack.h> #include <linux/delay.h> #include <linux/kallsyms.h> #include <linux/uaccess.h> #include <asm/elf.h> #include <asm/proc-fns.h> #include <asm/fpu.h> #include <linux/ptrace.h> #include <linux/reboot.h> #if IS_ENABLED(CONFIG_LAZY_FPU) struct task_struct *last_task_used_math; #endif extern void setup_mm_for_reboot(char mode); extern inline void arch_reset(char mode) { if (mode == 's') { /* Use cpu handler, jump to 0 */ cpu_reset(0); } } void (*pm_power_off) (void); EXPORT_SYMBOL(pm_power_off); static char reboot_mode_nds32 = 'h'; int __init reboot_setup(char *str) { reboot_mode_nds32 = str[0]; return 1; } static int cpub_pwroff(void) { return 0; } __setup("reboot=", reboot_setup); void machine_halt(void) { cpub_pwroff(); } EXPORT_SYMBOL(machine_halt); void machine_power_off(void) { if (pm_power_off) pm_power_off(); } EXPORT_SYMBOL(machine_power_off); void machine_restart(char *cmd) { /* * Clean and disable cache, and turn off interrupts */ cpu_proc_fin(); /* * Tell the mm system that we are going to reboot - * we may need it to insert some 1:1 mappings so that * soft boot works. */ setup_mm_for_reboot(reboot_mode_nds32); /* Execute kernel restart handler call chain */ do_kernel_restart(cmd); /* * Now call the architecture specific reboot code. */ arch_reset(reboot_mode_nds32); /* * Whoops - the architecture was unable to reboot. * Tell the user! */ mdelay(1000); pr_info("Reboot failed -- System halted\n"); while (1) ; } EXPORT_SYMBOL(machine_restart); void show_regs(struct pt_regs *regs) { printk("PC is at %pS\n", (void *)instruction_pointer(regs)); printk("LP is at %pS\n", (void *)regs->lp); pr_info("pc : [<%08lx>] lp : [<%08lx>] %s\n" "sp : %08lx fp : %08lx gp : %08lx\n", instruction_pointer(regs), regs->lp, print_tainted(), regs->sp, regs->fp, regs->gp); pr_info("r25: %08lx r24: %08lx\n", regs->uregs[25], regs->uregs[24]); pr_info("r23: %08lx r22: %08lx r21: %08lx r20: %08lx\n", regs->uregs[23], regs->uregs[22], regs->uregs[21], regs->uregs[20]); pr_info("r19: %08lx r18: %08lx r17: %08lx r16: %08lx\n", regs->uregs[19], regs->uregs[18], regs->uregs[17], regs->uregs[16]); pr_info("r15: %08lx r14: %08lx r13: %08lx r12: %08lx\n", regs->uregs[15], regs->uregs[14], regs->uregs[13], regs->uregs[12]); pr_info("r11: %08lx r10: %08lx r9 : %08lx r8 : %08lx\n", regs->uregs[11], regs->uregs[10], regs->uregs[9], regs->uregs[8]); pr_info("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", regs->uregs[7], regs->uregs[6], regs->uregs[5], regs->uregs[4]); pr_info("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", regs->uregs[3], regs->uregs[2], regs->uregs[1], regs->uregs[0]); pr_info(" IRQs o%s Segment %s\n", interrupts_enabled(regs) ? "n" : "ff", uaccess_kernel() ? "kernel" : "user"); } EXPORT_SYMBOL(show_regs); void exit_thread(struct task_struct *tsk) { #if defined(CONFIG_FPU) && defined(CONFIG_LAZY_FPU) if (last_task_used_math == tsk) last_task_used_math = NULL; #endif } void flush_thread(void) { #if defined(CONFIG_FPU) clear_fpu(task_pt_regs(current)); clear_used_math(); # ifdef CONFIG_LAZY_FPU if (last_task_used_math == current) last_task_used_math = NULL; # endif #endif } DEFINE_PER_CPU(struct task_struct *, __entry_task); asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); int copy_thread(unsigned long clone_flags, unsigned long stack_start, unsigned long stk_sz, struct task_struct *p, unsigned long tls) { struct pt_regs *childregs = task_pt_regs(p); memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context)); if (unlikely(p->flags & PF_KTHREAD)) { memset(childregs, 0, sizeof(struct pt_regs)); /* kernel thread fn */ p->thread.cpu_context.r6 = stack_start; /* kernel thread argument */ p->thread.cpu_context.r7 = stk_sz; } else { *childregs = *current_pt_regs(); if (stack_start) childregs->sp = stack_start; /* child get zero as ret. */ childregs->uregs[0] = 0; childregs->osp = 0; if (clone_flags & CLONE_SETTLS) childregs->uregs[25] = tls; } /* cpu context switching */ p->thread.cpu_context.pc = (unsigned long)ret_from_fork; p->thread.cpu_context.sp = (unsigned long)childregs; #if IS_ENABLED(CONFIG_FPU) if (used_math()) { # if !IS_ENABLED(CONFIG_LAZY_FPU) unlazy_fpu(current); # else preempt_disable(); if (last_task_used_math == current) save_fpu(current); preempt_enable(); # endif p->thread.fpu = current->thread.fpu; clear_fpu(task_pt_regs(p)); set_stopped_child_used_math(p); } #endif #ifdef CONFIG_HWZOL childregs->lb = 0; childregs->le = 0; childregs->lc = 0; #endif return 0; } #if IS_ENABLED(CONFIG_FPU) struct task_struct *_switch_fpu(struct task_struct *prev, struct task_struct *next) { #if !IS_ENABLED(CONFIG_LAZY_FPU) unlazy_fpu(prev); #endif if (!(next->flags & PF_KTHREAD)) clear_fpu(task_pt_regs(next)); return prev; } #endif /* * fill in the fpe structure for a core dump... */ int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu) { int fpvalid = 0; #if IS_ENABLED(CONFIG_FPU) struct task_struct *tsk = current; fpvalid = tsk_used_math(tsk); if (fpvalid) { lose_fpu(); memcpy(fpu, &tsk->thread.fpu, sizeof(*fpu)); } #endif return fpvalid; } EXPORT_SYMBOL(dump_fpu); unsigned long get_wchan(struct task_struct *p) { unsigned long fp, lr; unsigned long stack_start, stack_end; int count = 0; if (!p || p == current || p->state == TASK_RUNNING) return 0; if (IS_ENABLED(CONFIG_FRAME_POINTER)) { stack_start = (unsigned long)end_of_stack(p); stack_end = (unsigned long)task_stack_page(p) + THREAD_SIZE; fp = thread_saved_fp(p); do { if (fp < stack_start || fp > stack_end) return 0; lr = ((unsigned long *)fp)[0]; if (!in_sched_functions(lr)) return lr; fp = *(unsigned long *)(fp + 4); } while (count++ < 16); } return 0; } EXPORT_SYMBOL(get_wchan);