JOS之中断和系统调用

int
sys_cgetc(void)
{
	return syscall(SYS_cgetc, 0, 0, 0, 0, 0, 0);
}

static inline int32_t
syscall(int num, int check, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	int32_t ret;

	// Generic system call: pass system call number in AX,
	// up to five parameters in DX, CX, BX, DI, SI.
	// Interrupt kernel with T_SYSCALL.
	//
	// The "volatile" tells the assembler not to optimize
	// this instruction away just because we don't use the
	// return value.
	//
	// The last clause tells the assembler that this can
	// potentially change the condition codes and arbitrary
	// memory locations.

	asm volatile("int %1\n"
		     : "=a" (ret)
		     : "i" (T_SYSCALL),
		       "a" (num),
		       "d" (a1),
		       "c" (a2),
		       "b" (a3),
		       "D" (a4),
		       "S" (a5)
		     : "cc", "memory");

	if(check && ret > 0)
		panic("syscall %d returned %d (> 0)", num, ret);

	return ret;
}

SETGATE(idt[T_DIVIDE], 0, GD_KT, trap_handler_divide, 0);
SETGATE(idt[T_DEBUG], 0, GD_KT, trap_handler_debug, 0);
SETGATE(idt[T_NMI], 0, GD_KT, trap_handler_nmi, 0);

/* Use TRAPHANDLER_NOEC for traps where the CPU doesn't push an error code.
 * It pushes a 0 in place of the error code, so the trap frame has the same
 * format in either case.
 */
#define TRAPHANDLER_NOEC(name, num)					\
	.globl name;							\
	.type name, @function;						\
	.align 2;							\
	name:								\
	pushl $0;							\
	pushl $(num);							\
	jmp _alltraps

struct Trapframe {
	struct PushRegs tf_regs; // all registers that pushed by `pusha` instruction
	uint16_t tf_es;
	uint16_t tf_padding1;
	uint16_t tf_ds;
	uint16_t tf_padding2;
	uint32_t tf_trapno;
	/* below here defined by x86 hardware */
	uint32_t tf_err;
	uintptr_t tf_eip;
	uint16_t tf_cs;
	uint16_t tf_padding3;
	uint32_t tf_eflags;
	/* below here only when crossing rings, such as from user to kernel */
	uintptr_t tf_esp;
	uint16_t tf_ss;
	uint16_t tf_padding4;
} __attribute__((packed));

.global _alltraps
_alltraps:
	# build trap frame
	pushl %ds
	pushl %es
	pushal

	# set up ds es
	movw $GD_KD, %ax
	movw %ax, %ds
	movw %ax, %es
	# call trap(tf)
	pushl %esp
	call trap

static void
trap_dispatch(struct Trapframe *tf)
{
	// Handle processor exceptions.
	switch (tf->tf_trapno)
	{
	case T_PGFLT:
		/* code */
		page_fault_handler(tf);
		return;
	case T_BRKPT:
	case T_DEBUG:
		monitor(tf);
		return;
	case T_SYSCALL:
		syscall_handler(tf);
		return;
	
	default:
		break;
	}

	...
}

void syscall_handler(struct Trapframe *tf)
{
	int num = tf->tf_regs.reg_eax;
	int a1  = tf->tf_regs.reg_edx;
	int a2  = tf->tf_regs.reg_ecx;
	int a3  = tf->tf_regs.reg_ebx;
	int a4  = tf->tf_regs.reg_edi;
	int a5  = tf->tf_regs.reg_esi;
	int ret = syscall(num, a1, a2, a3, a4, a5);

	// when resume user process, it can get return
	// value directly by accessing %eax
	tf->tf_regs.reg_eax = ret;
}

// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	switch (syscallno) {
		case SYS_cputs:
			sys_cputs((char*)a1, a2);
			return 0;
		case SYS_cgetc:
			return sys_cgetc();
		case SYS_getenvid:
			return sys_getenvid();
		case SYS_env_destroy:
			return sys_env_destroy(a1);
	default:
		return -E_INVAL;
	}
}

static int
sys_cgetc(void)
{
	return cons_getc();
}