Subversion Repositories HelenOS

/* Preemptible trap handler for TL=1.

 *

 * This trap handler makes arrangements to make calling of scheduler() from

 * within a trap context possible. It is called from several other trap

 * This function can be entered either with interrupt globals or alternate

 * globals. Memory management trap handlers are obliged to switch to one of

 * those global sets prior to calling this function. Register window management

 * functions are not allowed to modify the alternate global registers.

 * The kernel is designed to work on trap levels 0 - 4. For instance, the

 * following can happen:

 * TL0: kernel thread runs (CANSAVE=0, kernel stack not in DTLB)

 * TL1: preemptible trap handler started after a tick interrupt

 * TL2: preemptible trap handler did SAVE

 * TL3: spill handler touched the kernel stack  

 * TL4: hardware or software failure

 * Input registers:

 * 	%g2	 	First argument for the function.

 *	%g7		Pre-set as address of the userspace window buffer.

.if NOT(\is_syscall)

	rdpr %tstate, %g3

	/*

	 * One of the ways this handler can be invoked is after a nested MMU trap from

	 * either spill_1_normal or fill_1_normal traps. Both of these traps manipulate

	 * the CWP register. We deal with the situation by simulating the MMU trap

	 * on TL=1 and restart the respective SAVE or RESTORE instruction once the MMU

	 * trap is resolved. However, because we are in the wrong window from the

	 * perspective of the MMU trap, we need to synchronize CWP with CWP from TL=0.

	 */ 

	and %g3, TSTATE_CWP_MASK, %g4

	wrpr %g4, 0, %cwp			! resynchronize CWP

	andcc %g3, TSTATE_PRIV_BIT, %g0		! if this trap came from the privileged mode...

	bnz 0f					! ...skip setting of kernel stack and primary context

	nop

.endif

	/*

	 * Normal window spills will go to the userspace window buffer.

	 */

	wrpr %g0, WSTATE_OTHER(0) | WSTATE_NORMAL(2), %wstate

	wrpr %g0, NWINDOWS - 1, %cleanwin	! prevent unnecessary clean_window exceptions

	save %g6, -PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE, %sp

.if \is_syscall

	/*

	 * Copy arguments for the syscall to the new window.

	 */

	mov %i0, %o0

	mov %i1, %o1

	mov %i2, %o2

	mov %i3, %o3

	mov %i4, %o4

	mov %i5, %o5

.endif

	/*

	 * Mark the CANRESTORE windows as OTHER windows.

	 */

	wrpr %l0, %otherwin

	wrpr %g0, %canrestore

	/*

	 * Switch to primary context 0.

	 */

	mov VA_PRIMARY_CONTEXT_REG, %l0

	stxa %g0, [%l0] ASI_DMMU

	flush %l0

.if NOT(\is_syscall)

	ba 1f

	/*

	 * At this moment, we are using the kernel stack 

	 */

1:

.endif

	/*

	 * Other window spills will go to the userspace window buffer

	 * and normal spills will go to the kernel stack.

	 */

	wrpr %g0, WSTATE_OTHER(0) | WSTATE_NORMAL(0), %wstate

	/*

	 * Copy arguments.

	 */

.if NOT(\is_syscall)

.else

	! store the syscall number on the stack as 7th argument

	stx %g2, [%sp + STACK_WINDOW_SAVE_AREA_SIZE + STACK_BIAS + STACK_ARG6] 

.endif

	rd %y, %g4

.if NOT(\is_syscall)

	/*

	 */

.else

	/*

	 * Call the higher-level syscall handler.

	 */

	call syscall_handler

	nop

	mov %o0, %i0				! copy the value returned by the syscall

.endif

	/*

	 */

	/*

	 */

	/*

	 */

	/*

	 */

	/*

	 * If OTHERWIN is zero, then all the userspace windows have been

	 * spilled to kernel memory (i.e. register window buffer). Moreover,

	 * if the scheduler was called in the meantime, all valid windows

	 * belonging to other threads were spilled by context_restore().

	 * If OTHERWIN is non-zero, then some userspace windows are still

	 * valid. Others might have been spilled. However, the CWP pointer

	 * needs no fixing because the scheduler had not been called.

	 */

	rdpr %otherwin, %l0

	brnz %l0, 0f

	nop

	/*

	 * OTHERWIN == 0

	 */

	/*

	 */

0:

	andcc %g1, TSTATE_PRIV_BIT, %g0		! if we are not returning to userspace...,

	bnz 1f					! ...skip restoring userspace windows

	/*

	 * Spills and fills will be processed by the {spill,fill}_1_normal

	 * handlers.

	 */

	wrpr %g0, WSTATE_OTHER(0) | WSTATE_NORMAL(1), %wstate

	/*

	 * Set primary context according to secondary context.

	 */

	wr %g0, ASI_DMMU, %asi

	ldxa [VA_SECONDARY_CONTEXT_REG] %asi, %g1

	stxa %g1, [VA_PRIMARY_CONTEXT_REG] %asi

	rd %pc, %g1

	flush %g1

	rdpr %cwp, %g1

	rdpr %otherwin, %g2

	/*

	 * Skip all OTHERWIN windows and descend to the first window

	 * in the userspace window buffer.

	 */

	sub %g1, %g2, %g3

	dec %g3

	and %g3, NWINDOWS - 1, %g3

	wrpr %g3, 0, %cwp

	/*

	 * CWP is now in the window last saved in the userspace window buffer.

	 * Fill all windows stored in the buffer.

	 */

	clr %g4

0:	andcc %g7, UWB_ALIGNMENT - 1, %g0	! alignment check

	bz 0f					! %g7 is UWB_ALIGNMENT-aligned, no more windows to refill

	nop

	add %g7, -STACK_WINDOW_SAVE_AREA_SIZE, %g7

	ldx [%g7 + L0_OFFSET], %l0

	ldx [%g7 + L1_OFFSET], %l1

	ldx [%g7 + L2_OFFSET], %l2

	ldx [%g7 + L3_OFFSET], %l3

	ldx [%g7 + L4_OFFSET], %l4

	ldx [%g7 + L5_OFFSET], %l5

	ldx [%g7 + L6_OFFSET], %l6

	ldx [%g7 + L7_OFFSET], %l7

	ldx [%g7 + I0_OFFSET], %i0

	ldx [%g7 + I1_OFFSET], %i1

	ldx [%g7 + I2_OFFSET], %i2

	ldx [%g7 + I3_OFFSET], %i3

	ldx [%g7 + I4_OFFSET], %i4

	ldx [%g7 + I5_OFFSET], %i5

	ldx [%g7 + I6_OFFSET], %i6

	ldx [%g7 + I7_OFFSET], %i7

	dec %g3

	and %g3, NWINDOWS - 1, %g3

	wrpr %g3, 0, %cwp			! switch to the preceeding window

	ba 0b

	inc %g4

0:

	/*

	 * Switch back to the proper current window and adjust

	 * OTHERWIN, CANRESTORE, CANSAVE and CLEANWIN.

	 */

	wrpr %g1, 0, %cwp

	add %g4, %g2, %g2

	cmp %g2, NWINDOWS - 2

	bg 2f					! fix the CANRESTORE=NWINDOWS-1 anomaly

	mov NWINDOWS - 2, %g1			! use dealy slot for both cases

	sub %g1, %g2, %g1

	wrpr %g0, 0, %otherwin

	wrpr %g1, 0, %cansave			! NWINDOWS - 2 - CANRESTORE

	wrpr %g2, 0, %canrestore		! OTHERWIN + windows in the buffer

	wrpr %g2, 0, %cleanwin			! avoid information leak

.if \is_syscall

	done

.else

	/*

	 * We got here in order to avoid inconsistency of the window state registers.

	 * If the:

	 *

	 * 	save %g6, -PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE, %sp

	 *

	 * instruction trapped and spilled a register window into the userspace

	 * window buffer, we have just restored NWINDOWS - 1 register windows.

	 * However, CANRESTORE can be only NWINDOW - 2 at most.

	 *

	 * The solution is to manually switch to (CWP - 1) mod NWINDOWS

	 * and set the window state registers so that:

	 *

	 * 	CANRESTORE 	= NWINDOWS - 2

	 *	CLEANWIN	= NWINDOWS - 2

	 *	CANSAVE 	= 0

	 *	OTHERWIN	= 0

	 *

	 * The RESTORE instruction is therfore to be skipped.

	 */

2:

	wrpr %g0, 0, %otherwin

	wrpr %g0, 0, %cansave

	wrpr %g1, 0, %canrestore

	wrpr %g1, 0, %cleanwin

	rdpr %cwp, %g1

	dec %g1

	and %g1, NWINDOWS - 1, %g1

	wrpr %g1, 0, %cwp			! CWP--

.if \is_syscall

	done

.else

	retry

.endif