| /* SPDX-License-Identifier: GPL-2.0 */ | |
| /* | |
| * wuf.S: Window underflow trap handler for the Sparc. | |
| * | |
| * Copyright (C) 1995 David S. Miller | |
| */ | |
| #include <asm/contregs.h> | |
| #include <asm/page.h> | |
| #include <asm/ptrace.h> | |
| #include <asm/psr.h> | |
| #include <asm/smp.h> | |
| #include <asm/asi.h> | |
| #include <asm/winmacro.h> | |
| #include <asm/asmmacro.h> | |
| #include <asm/thread_info.h> | |
| /* Just like the overflow handler we define macros for registers | |
| * with fixed meanings in this routine. | |
| */ | |
| #define t_psr l0 | |
| #define t_pc l1 | |
| #define t_npc l2 | |
| #define t_wim l3 | |
| /* Don't touch the above registers or else you die horribly... */ | |
| /* Now macros for the available scratch registers in this routine. */ | |
| #define twin_tmp1 l4 | |
| #define twin_tmp2 l5 | |
| #define curptr g6 | |
| .text | |
| .align 4 | |
| /* The trap entry point has executed the following: | |
| * | |
| * rd %psr, %l0 | |
| * rd %wim, %l3 | |
| * b fill_window_entry | |
| * andcc %l0, PSR_PS, %g0 | |
| */ | |
| /* Datum current_thread_info->uwinmask contains at all times a bitmask | |
| * where if any user windows are active, at least one bit will | |
| * be set in to mask. If no user windows are active, the bitmask | |
| * will be all zeroes. | |
| */ | |
| /* To get an idea of what has just happened to cause this | |
| * trap take a look at this diagram: | |
| * | |
| * 1 2 3 4 <-- Window number | |
| * ---------- | |
| * T O W I <-- Symbolic name | |
| * | |
| * O == the window that execution was in when | |
| * the restore was attempted | |
| * | |
| * T == the trap itself has save'd us into this | |
| * window | |
| * | |
| * W == this window is the one which is now invalid | |
| * and must be made valid plus loaded from the | |
| * stack | |
| * | |
| * I == this window will be the invalid one when we | |
| * are done and return from trap if successful | |
| */ | |
| /* BEGINNING OF PATCH INSTRUCTIONS */ | |
| /* On 7-window Sparc the boot code patches fnwin_patch1 | |
| * with the following instruction. | |
| */ | |
| .globl fnwin_patch1_7win, fnwin_patch2_7win | |
| fnwin_patch1_7win: srl %t_wim, 6, %twin_tmp2 | |
| fnwin_patch2_7win: and %twin_tmp1, 0x7f, %twin_tmp1 | |
| /* END OF PATCH INSTRUCTIONS */ | |
| .globl fill_window_entry, fnwin_patch1, fnwin_patch2 | |
| fill_window_entry: | |
| /* LOCATION: Window 'T' */ | |
| /* Compute what the new %wim is going to be if we retrieve | |
| * the proper window off of the stack. | |
| */ | |
| sll %t_wim, 1, %twin_tmp1 | |
| fnwin_patch1: srl %t_wim, 7, %twin_tmp2 | |
| or %twin_tmp1, %twin_tmp2, %twin_tmp1 | |
| fnwin_patch2: and %twin_tmp1, 0xff, %twin_tmp1 | |
| wr %twin_tmp1, 0x0, %wim /* Make window 'I' invalid */ | |
| andcc %t_psr, PSR_PS, %g0 | |
| be fwin_from_user | |
| restore %g0, %g0, %g0 /* Restore to window 'O' */ | |
| /* Trapped from kernel, we trust that the kernel does not | |
| * 'over restore' sorta speak and just grab the window | |
| * from the stack and return. Easy enough. | |
| */ | |
| fwin_from_kernel: | |
| /* LOCATION: Window 'O' */ | |
| restore %g0, %g0, %g0 | |
| /* LOCATION: Window 'W' */ | |
| LOAD_WINDOW(sp) /* Load it up */ | |
| /* Spin the wheel... */ | |
| save %g0, %g0, %g0 | |
| save %g0, %g0, %g0 | |
| /* I'd like to buy a vowel please... */ | |
| /* LOCATION: Window 'T' */ | |
| /* Now preserve the condition codes in %psr, pause, and | |
| * return from trap. This is the simplest case of all. | |
| */ | |
| wr %t_psr, 0x0, %psr | |
| WRITE_PAUSE | |
| jmp %t_pc | |
| rett %t_npc | |
| fwin_from_user: | |
| /* LOCATION: Window 'O' */ | |
| restore %g0, %g0, %g0 /* Restore to window 'W' */ | |
| /* LOCATION: Window 'W' */ | |
| /* Branch to the stack validation routine */ | |
| b srmmu_fwin_stackchk | |
| andcc %sp, 0x7, %g0 | |
| #define STACK_OFFSET (THREAD_SIZE - TRACEREG_SZ - STACKFRAME_SZ) | |
| fwin_user_stack_is_bolixed: | |
| /* LOCATION: Window 'W' */ | |
| /* Place a pt_regs frame on the kernel stack, save back | |
| * to the trap window and call c-code to deal with this. | |
| */ | |
| LOAD_CURRENT(l4, l5) | |
| sethi %hi(STACK_OFFSET), %l5 | |
| or %l5, %lo(STACK_OFFSET), %l5 | |
| add %l4, %l5, %l5 | |
| /* Store globals into pt_regs frame. */ | |
| STORE_PT_GLOBALS(l5) | |
| STORE_PT_YREG(l5, g3) | |
| /* Save current in a global while we change windows. */ | |
| mov %l4, %curptr | |
| save %g0, %g0, %g0 | |
| /* LOCATION: Window 'O' */ | |
| rd %psr, %g3 /* Read %psr in live user window */ | |
| mov %fp, %g4 /* Save bogus frame pointer. */ | |
| save %g0, %g0, %g0 | |
| /* LOCATION: Window 'T' */ | |
| sethi %hi(STACK_OFFSET), %l5 | |
| or %l5, %lo(STACK_OFFSET), %l5 | |
| add %curptr, %l5, %sp | |
| /* Build rest of pt_regs. */ | |
| STORE_PT_INS(sp) | |
| STORE_PT_PRIV(sp, t_psr, t_pc, t_npc) | |
| /* re-set trap time %wim value */ | |
| wr %t_wim, 0x0, %wim | |
| /* Fix users window mask and buffer save count. */ | |
| mov 0x1, %g5 | |
| sll %g5, %g3, %g5 | |
| st %g5, [%curptr + TI_UWINMASK] ! one live user window still | |
| st %g0, [%curptr + TI_W_SAVED] ! no windows in the buffer | |
| wr %t_psr, PSR_ET, %psr ! enable traps | |
| nop | |
| call window_underflow_fault | |
| mov %g4, %o0 | |
| b ret_trap_entry | |
| clr %l6 | |
| fwin_user_stack_is_ok: | |
| /* LOCATION: Window 'W' */ | |
| /* The users stack area is kosher and mapped, load the | |
| * window and fall through to the finish up routine. | |
| */ | |
| LOAD_WINDOW(sp) | |
| /* Round and round she goes... */ | |
| save %g0, %g0, %g0 /* Save to window 'O' */ | |
| save %g0, %g0, %g0 /* Save to window 'T' */ | |
| /* Where she'll trap nobody knows... */ | |
| /* LOCATION: Window 'T' */ | |
| fwin_user_finish_up: | |
| /* LOCATION: Window 'T' */ | |
| wr %t_psr, 0x0, %psr | |
| WRITE_PAUSE | |
| jmp %t_pc | |
| rett %t_npc | |
| /* Here come the architecture specific checks for stack. | |
| * mappings. Note that unlike the window overflow handler | |
| * we only need to check whether the user can read from | |
| * the appropriate addresses. Also note that we are in | |
| * an invalid window which will be loaded, and this means | |
| * that until we actually load the window up we are free | |
| * to use any of the local registers contained within. | |
| * | |
| * On success these routine branch to fwin_user_stack_is_ok | |
| * if the area at %sp is user readable and the window still | |
| * needs to be loaded, else fwin_user_finish_up if the | |
| * routine has done the loading itself. On failure (bogus | |
| * user stack) the routine shall branch to the label called | |
| * fwin_user_stack_is_bolixed. | |
| * | |
| * Contrary to the arch-specific window overflow stack | |
| * check routines in wof.S, these routines are free to use | |
| * any of the local registers they want to as this window | |
| * does not belong to anyone at this point, however the | |
| * outs and ins are still verboten as they are part of | |
| * 'someone elses' window possibly. | |
| */ | |
| .globl srmmu_fwin_stackchk | |
| srmmu_fwin_stackchk: | |
| /* LOCATION: Window 'W' */ | |
| /* Caller did 'andcc %sp, 0x7, %g0' */ | |
| bne fwin_user_stack_is_bolixed | |
| sethi %hi(PAGE_OFFSET), %l5 | |
| /* Check if the users stack is in kernel vma, then our | |
| * trial and error technique below would succeed for | |
| * the 'wrong' reason. | |
| */ | |
| mov AC_M_SFSR, %l4 | |
| cmp %l5, %sp | |
| bleu fwin_user_stack_is_bolixed | |
| LEON_PI( lda [%l4] ASI_LEON_MMUREGS, %g0) ! clear fault status | |
| SUN_PI_( lda [%l4] ASI_M_MMUREGS, %g0) ! clear fault status | |
| /* The technique is, turn off faults on this processor, | |
| * just let the load rip, then check the sfsr to see if | |
| * a fault did occur. Then we turn on fault traps again | |
| * and branch conditionally based upon what happened. | |
| */ | |
| LEON_PI(lda [%g0] ASI_LEON_MMUREGS, %l5) ! read mmu-ctrl reg | |
| SUN_PI_(lda [%g0] ASI_M_MMUREGS, %l5) ! read mmu-ctrl reg | |
| or %l5, 0x2, %l5 ! turn on no-fault bit | |
| LEON_PI(sta %l5, [%g0] ASI_LEON_MMUREGS) ! store it | |
| SUN_PI_(sta %l5, [%g0] ASI_M_MMUREGS) ! store it | |
| /* Cross fingers and go for it. */ | |
| LOAD_WINDOW(sp) | |
| /* A penny 'saved'... */ | |
| save %g0, %g0, %g0 | |
| save %g0, %g0, %g0 | |
| /* Is a BADTRAP earned... */ | |
| /* LOCATION: Window 'T' */ | |
| LEON_PI(lda [%g0] ASI_LEON_MMUREGS, %twin_tmp1) ! load mmu-ctrl again | |
| SUN_PI_(lda [%g0] ASI_M_MMUREGS, %twin_tmp1) ! load mmu-ctrl again | |
| andn %twin_tmp1, 0x2, %twin_tmp1 ! clear no-fault bit | |
| LEON_PI(sta %twin_tmp1, [%g0] ASI_LEON_MMUREGS) ! store it | |
| SUN_PI_(sta %twin_tmp1, [%g0] ASI_M_MMUREGS) ! store it | |
| mov AC_M_SFAR, %twin_tmp2 | |
| LEON_PI(lda [%twin_tmp2] ASI_LEON_MMUREGS, %g0) ! read fault address | |
| SUN_PI_(lda [%twin_tmp2] ASI_M_MMUREGS, %g0) ! read fault address | |
| mov AC_M_SFSR, %twin_tmp2 | |
| LEON_PI(lda [%twin_tmp2] ASI_LEON_MMUREGS, %twin_tmp2) ! read fault status | |
| SUN_PI_(lda [%twin_tmp2] ASI_M_MMUREGS, %twin_tmp2) ! read fault status | |
| andcc %twin_tmp2, 0x2, %g0 ! did fault occur? | |
| bne 1f ! yep, cleanup | |
| nop | |
| wr %t_psr, 0x0, %psr | |
| nop | |
| b fwin_user_finish_up + 0x4 | |
| nop | |
| /* Did I ever tell you about my window lobotomy? | |
| * anyways... fwin_user_stack_is_bolixed expects | |
| * to be in window 'W' so make it happy or else | |
| * we watchdog badly. | |
| */ | |
| 1: | |
| restore %g0, %g0, %g0 | |
| b fwin_user_stack_is_bolixed ! oh well | |
| restore %g0, %g0, %g0 |