/*

 * Low-level assembly code to pass an interrupt to a higher-level handler.

 */

.text

.globl exception0, exception1, exception2, exception3, exception4, exception5

.globl exception6, exception7, exception8, exception9, exception10, exception11

.globl exception12, exception13, exception14, exception16, exception17

.globl exception18, exception19

.globl irq0, irq1, irq2, irq3, irq4, irq5, irq6, irq7, irq8, irq9

.globl irq10, irq11, irq12, irq13, irq14, irq15

.globl syscall_int

.globl clone_return

.globl userland_trampoline, kthread_trampoline

#include "options.h"

#include "machine/param.h"

#include "machine/vm.h"

#include "asmsyms.h"

#define SANITY_CHECKS

#define SAVE_REGISTERS \

	movl	%eax, SF_EAX(%esp); \

	movl	%ebx, SF_EBX(%esp); \

	movl	%ecx, SF_ECX(%esp); \

	movl	%edx, SF_EDX(%esp); \

	movl	%ebp, SF_EBP(%esp); \

	movl	%esp, SF_ESP(%esp); \

	movl	%edi, SF_EDI(%esp); \

	movl	%esi, SF_ESI(%esp);

#define SAVE_SEGS \

	xorl	%eax, %eax; \

	movw	%ds, %ax; \

	movl	%eax, SF_DS(%esp); \

	movw	%es, %ax; \

	movl	%eax, SF_ES(%esp); \

	movw	%fs, %ax; \

	movl	%eax, SF_FS(%esp); \

	movw	%gs, %ax; \

	movl	%eax, SF_GS(%esp);

#define RESTORE_REGISTERS \

	movl	SF_EAX(%esp), %eax; \

	movl	SF_EBX(%esp), %ebx; \

	movl	SF_ECX(%esp), %ecx; \

	movl	SF_EDX(%esp), %edx; \

	movl	SF_EBP(%esp), %ebp; \

	/* movl	SF_ESP(%esp), %esp; */ \

	movl	SF_EDI(%esp), %edi; \

	movl	SF_ESI(%esp), %esi;

#define RESTORE_SEGS \

	movl	SF_DS(%esp), %eax; \

	movw	%ax, %ds; \

	movl	SF_ES(%esp), %eax; \

	movw	%ax, %es; \

	movl	SF_FS(%esp), %eax; \

	movw	%ax, %fs; \

	movl	SF_GS(%esp), %eax; \

	movw	%ax, %gs;

do_irq:

	SAVE_REGISTERS

	SAVE_SEGS

	/* Set up kernel data */

	movl	$GDT_SEL_KERNEL_DATA, %eax

	movw	%ax, %ds

	movw	%ax, %es

	/* Ensure per-cpu stuff works */

	movl	$GDT_SEL_KERNEL_PCPU, %eax

	movw	%ax, %fs

	/* Increment the nested IRQ count */

	incl	%fs:(PCPU_NESTEDIRQ)

	/* Restore the interrupt flag */

	movl	SF_EFLAGS(%esp), %eax

	testl	$0x200, %eax

	jz	1f

	sti

1:	/* Call the interrupt handler */

	pushl	%esp

	call	interrupt_handler

	addl	$4, %esp

	/* Restore previous state */

	RESTORE_SEGS

	RESTORE_REGISTERS

	addl	$SF_EIP, %esp

	iret

do_exception:

	SAVE_REGISTERS

	SAVE_SEGS

	/* Set up kernel data */

	movl	$GDT_SEL_KERNEL_DATA, %eax

	movw	%ax, %ds

	movw	%ax, %es

	/* Ensure per-cpu stuff works */

	movl	$GDT_SEL_KERNEL_PCPU, %eax

	movw	%ax, %fs

	/* Call the exception handler */

	pushl	%esp

	call	exception_handler

	addl	$4, %esp

	/* Restore previous state */

	RESTORE_SEGS

	RESTORE_REGISTERS

	addl	$SF_EIP, %esp

	iret

/*

 * There exist two versions of exceptions: those with an error code, and those

 * without one. Our handler code expects to be called with an error code, so

 * we add a fake zero one if needed for those exceptions that don't have one.

 */

#define EXCEPTION_HANDLER_ERRORCODE(num) \

exception ## num: \

	subl	$SF_ERRNUM, %esp; \

	movl	$num, SF_TRAPNO(%esp); \

	jmp	do_exception

#define EXCEPTION_HANDLER(num) \

exception ## num: \

	subl	$SF_EIP, %esp; \

	movl	$num, SF_TRAPNO(%esp); \

	movl	$0, SF_ERRNUM(%esp); \

	jmp	do_exception

/* IRQ handlers are a lot simpler: they come in a single easy flavour */

#define IRQ_HANDLER(num) \

irq ## num: \

	subl	$SF_EIP, %esp; \

	movl	$num, SF_TRAPNO(%esp); \

	jmp	do_irq

/*

 * System call interrupt; system call number should be placed in %eax, all

 * arguments are expected to be placed on the stack.  Note that we only

 * preserve what's needed by the System V ABI because that's what everyone

 * seems to use anyway.

 */

syscall_int:

	/*

	 * System V ABI for Intel386 Architecture says we only have to

	 * preserve %ebx, %esi, %edi, %ebp and %esp (the latter is done

	 * implicitely by the hardware).

	 */

	pushl	%ebp

	pushl	%ebx

	pushl	%esi

	pushl	%edi

	/* Save segment registers as well; we only use ds/es/fs */

	pushl	%ds

	pushl	%es

	pushl	%fs

#ifdef SANITY_CHECKS

	/*

	 * Sanity check: a system call must be made from userland, thus %ds

	 * must be userland version

	 */

	movw	%ds, %bx

	cmpw	$(GDT_SEL_USER_DATA + 3), %bx

	je	syscall_start_dsok

	int 	$3

syscall_start_dsok:

	/* Sanity check: interrupts must be enabled when entering */

	movl	36(%esp), %ebx

	andl	$0x200, %ebx

	orl	%ebx, %ebx

	jne	syscall_start_ifok

	int	$3

syscall_start_ifok:

#endif

	/*

	 * Switch to kernel segment register context (ds/es/fs); this ensures

	 * the stores below will work (%esi uses %ds implicitely)

	 */

	movw	$GDT_SEL_KERNEL_DATA, %bx

	movw	%bx, %ds

	movw	%bx, %es

	movw	$GDT_SEL_KERNEL_PCPU, %bx

	movw	%bx, %fs

	/*

	 * Fetch the caller's stack pointer; this will be saved at our

	 * current stack - but note that we have already created a

	 * stackframe, so we just use that as base.

	 *

	 * The 40 comes from stored fs es ds edi esi ebx ebp eip cs flg esp ss

	 * as they occur on offsets 0  4  8  12  16  20  24  28 32  36  40  44

	 */

	movl 40(%esp), %esi

	/*

	 * Set up a pointer to the structure, and copy 6 arguments

	 * in place. Note that the stack grows backward, so we need

	 * to place them in reverse order.

	 */

	pushl	20(%esi)

	pushl	16(%esi)

	pushl	12(%esi)

	pushl	 8(%esi)

	pushl	 4(%esi)

	pushl	%eax

	/*

	 * Invoke the generic syscall hander; return values will be passed in

	 * %eax, so we cannot thrash that. Note that our argument is pushed

	 * beforehand, which simply points to the syscall values.

	 */

	pushl	%esp

	call	syscall

	addl	$28, %esp	/* 6 regs + esp */

syscall_return:

	/* Restore registers */

	popl	%fs

	popl	%es

	popl	%ds

#ifdef SANITY_CHECKS

	/*

	 * Sanity check: we must have restored an userland ds; if we don't,

	 * iret will reset %ds to null because it can't be accessed in ring 3,

	 * leading to hard-to-debug problems. Best to verify it here.

	 */

	movw	%ds, %bx

	cmpw	$(GDT_SEL_USER_DATA + 3), %bx

	je	syscall_end_dsok

	int	$3

syscall_end_dsok:

	/* Sanity check: interrupts must be enabled when a syscall is done */

	movl	24(%esp), %ebx

	andl	$0x200, %ebx

	orl	%ebx, %ebx

	jne	syscall_end_ifok

	int	$3

syscall_end_ifok:

#endif

	popl	%edi

	popl	%esi

	popl	%ebx

	popl	%ebp

	iret

clone_return:

	/*

	 * Once here, the to-be-cloned thread is scheduled to be

	 * resumed. We are returning to a new thread, so we'll

	 * need to restore the context exactly as it were when

	 * the thread did the syscall.

	 *

	 * However, the top of the kernel stack will still have

	 * the stackframe set up by our syscall routine (as there

	 * is no other way to do a clone) - we can use that

	 * information to restore the caller.

	 *

	 * Note that the ABI dictates that %eax is used to return

	 * a value to the new thread, so we'll have to restore it.

	 */

	/* Rewind the stack as created by syscall_int */

	movl	%fs:(PCPU_CURTHREAD), %ebx

	movl	T_ESP0(%ebx), %esp

	subl	$48, %esp

	/* Fetch return value */

	movl	T_ARG1(%ebx), %eax

	/* And terminate the system call */

	jmp	syscall_return

#ifdef OPTION_SMP

spurious_irq:

	iret

#endif

/* Now we just need to list the exception handlers */

EXCEPTION_HANDLER(0)

EXCEPTION_HANDLER(1)

EXCEPTION_HANDLER(2)

EXCEPTION_HANDLER(3)

EXCEPTION_HANDLER(4)

EXCEPTION_HANDLER(5)

EXCEPTION_HANDLER(6)

EXCEPTION_HANDLER(7)

EXCEPTION_HANDLER_ERRORCODE(8)

EXCEPTION_HANDLER(9)

EXCEPTION_HANDLER_ERRORCODE(10)

EXCEPTION_HANDLER_ERRORCODE(11)

EXCEPTION_HANDLER_ERRORCODE(12)

EXCEPTION_HANDLER_ERRORCODE(13)

EXCEPTION_HANDLER_ERRORCODE(14)

EXCEPTION_HANDLER(16)

EXCEPTION_HANDLER_ERRORCODE(17)

EXCEPTION_HANDLER(18)

EXCEPTION_HANDLER(19)

/* ...and the IRQ handlers */

IRQ_HANDLER(0)

IRQ_HANDLER(1)

IRQ_HANDLER(2)

IRQ_HANDLER(3)

IRQ_HANDLER(4)

IRQ_HANDLER(5)

IRQ_HANDLER(6)

IRQ_HANDLER(7)

IRQ_HANDLER(8)

IRQ_HANDLER(9)

IRQ_HANDLER(10)

IRQ_HANDLER(11)

IRQ_HANDLER(12)

IRQ_HANDLER(13)

IRQ_HANDLER(14)

IRQ_HANDLER(15)

kthread_trampoline:

	/* Fetch arguments; arg1 is the %eip and arg2 is the argument */

	movl	%fs:(PCPU_CURTHREAD), %ebx

	movl	T_ARG1(%ebx), %eax		/* eax = eip */

	pushl	T_ARG2(%ebx)

	/* Call the kthread code with interrupts enabled */

	pushl	$0x200

	pushl	$GDT_SEL_KERNEL_CODE

	pushl	%eax

	iret

userland_trampoline:

	/* Fetch arguments; arg1 is the %eip and arg2 is the argument */

	movl	%fs:(PCPU_CURTHREAD), %ebx

	movl	T_ARG1(%ebx), %eax		/* eax = eip */

	movl	T_ARG2(%ebx), %esi		/* esi = arg */

	/* Set up %ds/%es to point to the userland segments */

	movl	$(GDT_SEL_USER_DATA + 3), %edx

	movl	%dx, %ds

	movl	%dx, %es

	pushl	$(GDT_SEL_USER_DATA + 3)			/* ss */

	pushl	$(USERLAND_STACK_ADDR + THREAD_STACK_SIZE)	/* esp */

	pushl	$0x200					/* eflags */

	pushl	$(GDT_SEL_USER_CODE + 3)		/* cs */

	pushl	%eax					/* eip */

	iret