// Initialises the GDT (global descriptor table)
static ZLOX_VOID zlox_init_gdt()
{
	gdt_ptr.limit = (sizeof(ZLOX_GDT_ENTRY) * ZLOX_GDT_ENTRY_NUMBER) - 1;
	gdt_ptr.base  = (ZLOX_UINT32)gdt_entries;
	
	zlox_gdt_set_gate(0, 0, 0, 0, 0);			// Null segment
	zlox_gdt_set_gate(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);	// Code segment
	zlox_gdt_set_gate(2, 0, 0xFFFFFFFF, 0x92, 0xCF);	// Data segment
	zlox_gdt_set_gate(3, 0, 0xFFFFFFFF, 0xFA, 0xCF);	// User mode code segment
	zlox_gdt_set_gate(4, 0, 0xFFFFFFFF, 0xF2, 0xCF);	// User mode data segment
	zlox_write_tss(5, 0x10, 0x0);

	_zlox_gdt_flush((ZLOX_UINT32)&gdt_ptr);
	_zlox_tss_flush();
}

# zlox_interrupt.s Contains interrupt service routine wrappers.
....................................
....................................
_ZLOX_INT_ISR_NOERRCODE	30
_ZLOX_INT_ISR_NOERRCODE	31
_ZLOX_INT_ISR_NOERRCODE	128
_ZLOX_INT_IRQ	0,	32
_ZLOX_INT_IRQ	1,	33
_ZLOX_INT_IRQ	2,	34
....................................
....................................

// Initialise the interrupt descriptor table.
static ZLOX_VOID zlox_init_idt()
{
....................................
....................................
	zlox_idt_set_gate(30, (ZLOX_UINT32)_zlox_isr_30, 0x08, 0x8E);
	zlox_idt_set_gate(31, (ZLOX_UINT32)_zlox_isr_31, 0x08, 0x8E);
	zlox_idt_set_gate(31, (ZLOX_UINT32)_zlox_isr_31, 0x08, 0x8E);
	zlox_idt_set_gate(128, (ZLOX_UINT32)_zlox_isr_128, 0x08, 0x8E); // syscall
	zlox_idt_set_gate(ZLOX_IRQ0, (ZLOX_UINT32)_zlox_irq_0, 0x08, 0x8E);
	zlox_idt_set_gate(ZLOX_IRQ1, (ZLOX_UINT32)_zlox_irq_1, 0x08, 0x8E);
	zlox_idt_set_gate(ZLOX_IRQ2, (ZLOX_UINT32)_zlox_irq_2, 0x08, 0x8E);
....................................
....................................
}

ZLOX_VOID zlox_register_interrupt_callback(ZLOX_UINT8 n, ZLOX_ISR_CALLBACK callback)
{
    interrupt_callbacks[n] = callback;
}

// This gets called from our ASM interrupt handler stub.
ZLOX_VOID zlox_isr_handler(ZLOX_ISR_REGISTERS regs)
{
	// This line is important. When the processor extends the 8-bit interrupt number
	// to a 32bit value, it sign-extends, not zero extends. So if the most significant
	// bit (0x80) is set, regs.int_no will be very large (about 0xffffff80).
	ZLOX_UINT8 int_no = regs.int_no & 0xFF;
	if (interrupt_callbacks[int_no] != 0)
	{
		ZLOX_ISR_CALLBACK callback = interrupt_callbacks[int_no];
		callback(&regs);
	}
	else
	{
		zlox_monitor_write("zenglox recieved unhandled interrupt: ");
		zlox_monitor_write_hex(int_no);
		zlox_monitor_put('\n');
		for(;;)
			;
	}
}

// zlox_syscall.c Defines the implementation of a system call system.

#include "zlox_syscall.h"
#include "zlox_isr.h"
#include "zlox_monitor.h"

static ZLOX_VOID zlox_syscall_handler(ZLOX_ISR_REGISTERS * regs);

ZLOX_DEFN_SYSCALL1(monitor_write, 0, const char*);
ZLOX_DEFN_SYSCALL1(monitor_write_hex, 1, const char*);
ZLOX_DEFN_SYSCALL1(monitor_write_dec, 2, const char*);

static ZLOX_VOID * syscalls[3] =
{
    &zlox_monitor_write,
    &zlox_monitor_write_hex,
    &zlox_monitor_write_dec,
};

ZLOX_UINT32 num_syscalls = 3;

ZLOX_VOID zlox_initialise_syscalls()
{
    // Register our syscall handler.
    zlox_register_interrupt_callback (0x80, &zlox_syscall_handler);
}

static ZLOX_VOID zlox_syscall_handler(ZLOX_ISR_REGISTERS * regs)
{
    // Firstly, check if the requested syscall number is valid.
    // The syscall number is found in EAX.
    if (regs->eax >= num_syscalls)
        return;

    // Get the required syscall location.
    ZLOX_VOID * location = syscalls[regs->eax];

    // We don't know how many parameters the function wants, so we just
    // push them all onto the stack in the correct order. The function will
    // use all the parameters it wants, and we can pop them all back off afterwards.
    ZLOX_SINT32 ret;
    asm volatile (" \
      push %1; \
      push %2; \
      push %3; \
      push %4; \
      push %5; \
      call *%6; \
      pop %%ebx; \
      pop %%ebx; \
      pop %%ebx; \
      pop %%ebx; \
      pop %%ebx; \
    " : "=a" (ret) : "D" (regs->edi), "S" (regs->esi), "d" (regs->edx), "c" (regs->ecx), "b" (regs->ebx), "0" (location));

    regs->eax = ret;
}

// zlox_syscall.h Defines the interface for and structures relating to the syscall dispatch system.

#ifndef _ZLOX_SYSCALL_H_
#define _ZLOX_SYSCALL_H_

#include "zlox_common.h"

ZLOX_VOID zlox_initialise_syscalls();

#define ZLOX_DECL_SYSCALL1(fn,p1) ZLOX_SINT32 zlox_syscall_##fn(p1);

#define ZLOX_DEFN_SYSCALL1(fn, num, P1) \
int zlox_syscall_##fn(P1 p1) \
{ \
  ZLOX_SINT32 a; \
  asm volatile("int $0x80" : "=a" (a) : "0" (num), "b" ((ZLOX_SINT32)p1)); \
  return a; \
}

ZLOX_DECL_SYSCALL1(monitor_write, const char*)
ZLOX_DECL_SYSCALL1(monitor_write_hex, const char*)
ZLOX_DECL_SYSCALL1(monitor_write_dec, const char*)

#endif // _ZLOX_SYSCALL_H_

int zlox_syscall_monitor_write(const char* p1) 
{ 
  ZLOX_SINT32 a; 
  asm volatile("int $0x80" : "=a" (a) : "0" (0), "b" ((ZLOX_SINT32)p1)); 
  return a; 
}

// zlox_task.c Implements the functionality needed to multitask.
...........................................
...........................................
ZLOX_VOID zlox_switch_to_user_mode()
{
	// Set up our kernel stack.
	zlox_set_kernel_stack(current_task->kernel_stack + ZLOX_KERNEL_STACK_SIZE);
	
	// Set up a stack structure for switching to user mode.
	asm volatile(
		"cli\n\t"
		"mov $0x23, %ax\n\t"
		"mov %ax, %ds\n\t"
		"mov %ax, %es\n\t"
		"mov %ax, %fs\n\t"
		"mov %ax, %gs\n\t"
		"mov %esp, %eax\n\t"
		"pushl $0x23\n\t"
		"pushl %eax\n\t"
		"pushf\n\t"
		"pop %eax\n\t"	// Get EFLAGS back into EAX. The only way to read EFLAGS is to pushf then pop.
		"orl $0x200,%eax\n\t"	// Set the IF flag.
		"pushl %eax\n\t"	// Push the new EFLAGS value back onto the stack.
		"pushl $0x1B\n\t"
		"push $1f\n\t"
		"iret\n"
	"1:"
		); 
	  
}

// zlox_task.c Implements the functionality needed to multitask.
...........................................
...........................................
ZLOX_SINT32 zlox_fork()
{
...........................................
...........................................
	new_task->init_esp = current_task->init_esp;
	new_task->page_directory = directory;
	new_task->kernel_stack = zlox_kmalloc_a(ZLOX_KERNEL_STACK_SIZE);
	new_task->next = 0;
...........................................
...........................................
}

// zlox_task.c Implements the functionality needed to multitask.
...........................................
...........................................
ZLOX_VOID zlox_switch_task()
{
...........................................
...........................................

	// Change our kernel stack over.
	zlox_set_kernel_stack(current_task->kernel_stack + ZLOX_KERNEL_STACK_SIZE);

	_zlox_switch_task_do(eip,esp,ebp,current_directory->physicalAddr);
}

/*zlox_kernel.c Defines the C-code kernel entry point, calls initialisation routines.*/
......................................
......................................
//zenglOX kernel main entry
ZLOX_SINT32 zlox_kernel_main(ZLOX_MULTIBOOT * mboot_ptr, ZLOX_UINT32 initial_stack)
{
......................................
......................................

	// 初始化系统调用
	zlox_initialise_syscalls();

	// 切换到ring 3的用户模式
	zlox_switch_to_user_mode();

	zlox_syscall_monitor_write("hello world!\nwelcome to zenglOX v0.0.9!\ni'm in user world!\n");

	for(;;)
		;

	return 0;
}