/* SPDX-License-Identifier: GPL-2.0 */ /* * rtrap.S: Return from Sparc trap low-level code. * * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) */ #include <asm/page.h> #include <asm/ptrace.h> #include <asm/psr.h> #include <asm/asi.h> #include <asm/smp.h> #include <asm/contregs.h> #include <asm/winmacro.h> #include <asm/asmmacro.h> #include <asm/thread_info.h> #define t_psr l0 #define t_pc l1 #define t_npc l2 #define t_wim l3 #define twin_tmp1 l4 #define glob_tmp g4 #define curptr g6 /* 7 WINDOW SPARC PATCH INSTRUCTIONS */ .globl rtrap_7win_patch1, rtrap_7win_patch2, rtrap_7win_patch3 .globl rtrap_7win_patch4, rtrap_7win_patch5 rtrap_7win_patch1: srl %t_wim, 0x6, %glob_tmp rtrap_7win_patch2: and %glob_tmp, 0x7f, %glob_tmp rtrap_7win_patch3: srl %g1, 7, %g2 rtrap_7win_patch4: srl %g2, 6, %g2 rtrap_7win_patch5: and %g1, 0x7f, %g1 /* END OF PATCH INSTRUCTIONS */ /* We need to check for a few things which are: * 1) The need to call schedule() because this * processes quantum is up. * 2) Pending signals for this process, if any * exist we need to call do_signal() to do * the needy. * * Else we just check if the rett would land us * in an invalid window, if so we need to grab * it off the user/kernel stack first. */ .globl ret_trap_entry, rtrap_patch1, rtrap_patch2 .globl rtrap_patch3, rtrap_patch4, rtrap_patch5 .globl ret_trap_lockless_ipi ret_trap_entry: ret_trap_lockless_ipi: andcc %t_psr, PSR_PS, %g0 sethi %hi(PSR_SYSCALL), %g1 be 1f andn %t_psr, %g1, %t_psr wr %t_psr, 0x0, %psr b ret_trap_kernel nop 1: ld [%curptr + TI_FLAGS], %g2 andcc %g2, (_TIF_NEED_RESCHED), %g0 be signal_p nop call schedule nop ld [%curptr + TI_FLAGS], %g2 signal_p: andcc %g2, _TIF_DO_NOTIFY_RESUME_MASK, %g0 bz,a ret_trap_continue ld [%sp + STACKFRAME_SZ + PT_PSR], %t_psr mov %g2, %o2 mov %l6, %o1 call do_notify_resume add %sp, STACKFRAME_SZ, %o0 ! pt_regs ptr b signal_p ld [%curptr + TI_FLAGS], %g2 ret_trap_continue: sethi %hi(PSR_SYSCALL), %g1 andn %t_psr, %g1, %t_psr wr %t_psr, 0x0, %psr WRITE_PAUSE ld [%curptr + TI_W_SAVED], %twin_tmp1 orcc %g0, %twin_tmp1, %g0 be ret_trap_nobufwins nop wr %t_psr, PSR_ET, %psr WRITE_PAUSE mov 1, %o1 call try_to_clear_window_buffer add %sp, STACKFRAME_SZ, %o0 b signal_p ld [%curptr + TI_FLAGS], %g2 ret_trap_nobufwins: /* Load up the user's out registers so we can pull * a window from the stack, if necessary. */ LOAD_PT_INS(sp) /* If there are already live user windows in the * set we can return from trap safely. */ ld [%curptr + TI_UWINMASK], %twin_tmp1 orcc %g0, %twin_tmp1, %g0 bne ret_trap_userwins_ok nop /* Calculate new %wim, we have to pull a register * window from the users stack. */ ret_trap_pull_one_window: rd %wim, %t_wim sll %t_wim, 0x1, %twin_tmp1 rtrap_patch1: srl %t_wim, 0x7, %glob_tmp or %glob_tmp, %twin_tmp1, %glob_tmp rtrap_patch2: and %glob_tmp, 0xff, %glob_tmp wr %glob_tmp, 0x0, %wim /* Here comes the architecture specific * branch to the user stack checking routine * for return from traps. */ b srmmu_rett_stackchk andcc %fp, 0x7, %g0 ret_trap_userwins_ok: LOAD_PT_PRIV(sp, t_psr, t_pc, t_npc) or %t_pc, %t_npc, %g2 andcc %g2, 0x3, %g0 sethi %hi(PSR_SYSCALL), %g2 be 1f andn %t_psr, %g2, %t_psr b ret_trap_unaligned_pc add %sp, STACKFRAME_SZ, %o0 1: LOAD_PT_YREG(sp, g1) LOAD_PT_GLOBALS(sp) wr %t_psr, 0x0, %psr WRITE_PAUSE jmp %t_pc rett %t_npc ret_trap_unaligned_pc: ld [%sp + STACKFRAME_SZ + PT_PC], %o1 ld [%sp + STACKFRAME_SZ + PT_NPC], %o2 ld [%sp + STACKFRAME_SZ + PT_PSR], %o3 wr %t_wim, 0x0, %wim ! or else... wr %t_psr, PSR_ET, %psr WRITE_PAUSE call do_memaccess_unaligned nop b signal_p ld [%curptr + TI_FLAGS], %g2 ret_trap_kernel: /* Will the rett land us in the invalid window? */ mov 2, %g1 sll %g1, %t_psr, %g1 rtrap_patch3: srl %g1, 8, %g2 or %g1, %g2, %g1 rd %wim, %g2 andcc %g2, %g1, %g0 be 1f ! Nope, just return from the trap sll %g2, 0x1, %g1 /* We have to grab a window before returning. */ rtrap_patch4: srl %g2, 7, %g2 or %g1, %g2, %g1 rtrap_patch5: and %g1, 0xff, %g1 wr %g1, 0x0, %wim /* Grrr, make sure we load from the right %sp... */ LOAD_PT_ALL(sp, t_psr, t_pc, t_npc, g1) restore %g0, %g0, %g0 LOAD_WINDOW(sp) b 2f save %g0, %g0, %g0 /* Reload the entire frame in case this is from a * kernel system call or whatever... */ 1: LOAD_PT_ALL(sp, t_psr, t_pc, t_npc, g1) 2: sethi %hi(PSR_SYSCALL), %twin_tmp1 andn %t_psr, %twin_tmp1, %t_psr wr %t_psr, 0x0, %psr WRITE_PAUSE jmp %t_pc rett %t_npc ret_trap_user_stack_is_bolixed: wr %t_wim, 0x0, %wim wr %t_psr, PSR_ET, %psr WRITE_PAUSE call window_ret_fault add %sp, STACKFRAME_SZ, %o0 b signal_p ld [%curptr + TI_FLAGS], %g2 .globl srmmu_rett_stackchk srmmu_rett_stackchk: bne ret_trap_user_stack_is_bolixed sethi %hi(PAGE_OFFSET), %g1 cmp %g1, %fp bleu ret_trap_user_stack_is_bolixed mov AC_M_SFSR, %g1 LEON_PI(lda [%g1] ASI_LEON_MMUREGS, %g0) SUN_PI_(lda [%g1] ASI_M_MMUREGS, %g0) LEON_PI(lda [%g0] ASI_LEON_MMUREGS, %g1) SUN_PI_(lda [%g0] ASI_M_MMUREGS, %g1) or %g1, 0x2, %g1 LEON_PI(sta %g1, [%g0] ASI_LEON_MMUREGS) SUN_PI_(sta %g1, [%g0] ASI_M_MMUREGS) restore %g0, %g0, %g0 LOAD_WINDOW(sp) save %g0, %g0, %g0 andn %g1, 0x2, %g1 LEON_PI(sta %g1, [%g0] ASI_LEON_MMUREGS) SUN_PI_(sta %g1, [%g0] ASI_M_MMUREGS) mov AC_M_SFAR, %g2 LEON_PI(lda [%g2] ASI_LEON_MMUREGS, %g2) SUN_PI_(lda [%g2] ASI_M_MMUREGS, %g2) mov AC_M_SFSR, %g1 LEON_PI(lda [%g1] ASI_LEON_MMUREGS, %g1) SUN_PI_(lda [%g1] ASI_M_MMUREGS, %g1) andcc %g1, 0x2, %g0 be ret_trap_userwins_ok nop b,a ret_trap_user_stack_is_bolixed