《操作系统真象还原》 第十六篇：实现系统调用

第十六篇：实现系统调用

系统调用实现框架

系统调用分为两部分，一部分是暴露给用户进程的接口函数，另一部分是与之对应的内核具体实现

系统调用实现流程如下：

• 用中断门实现系统调用，模仿linux用0x80号中断作为系统调用的入口
• 在IDT中安装0x80号中断对应的描述符，在该描述符中注册系统调用对应的中断处理例程
• 建立系统调用子功能表syscall_table，利用eax寄存器中的子功能号在该表中索引相应的处理函数
• 用宏实现用户空间的系统调用接口，用寄存器传递参数，eax为子功能号，ebx保存第一个参数，ecx保存第二个参数，edx保存第三个参数

增加0x80号中断描述符

//初始化中断描述符表
void init_idt() {
	int i,lastindex = IDT_DESC_CNT - 1;
	for (i = 0; i < IDT_DESC_CNT; i++) {
		init_idt_desc(&idt[i], IDT_DESC_ATTR_DPL0, intr_entry_table[i]);
	}
	//系统调用的中断描述符单独处理
	//描述符特权级别、为3，才能从用户态直接
	init_idt_desc(&idt[lastindex], IDT_DESC_ATTR_DPL3, syscall_handler);
	
	put_str("idt _desc_init done\n");	
}

实现系统调用接口

//无参数的系统调用
#define _syscall0(NUMBER) ({	\
	int rtnval;					\
	asm volatile (				\
		"int $0x80"				\
		: "=a" (rtnval)			\
		: "a" (NUMBER)			\
		:"memory"				\
	);							\
	rtnval;						\
})


//一个参数的系统调用
#define _syscall1(NUMBER, ARG1) ({ 	\
	int rtnval;						\
	asm volatile (					\
		"int $0x80"					\
		: "=a" (rtnval)				\
		: "a" (NUMBER), "b" (ARG1)	\
		:"memory"					\
	);								\
	rtnval;							\
})

//两个参数的系统调用
#define _syscall2(NUMBER, ARG1, ARG2)({			\
	int rtnval;									\
	asm volatile (								\
		"int $0x80"								\
		: "=a" (rtnval)							\
		: "a" (NUMBER), "b" (ARG1), "c" (ARG2)	\
		:"memory"								\
	);											\
	rtnval;										\
})

//三个参数的系统调用
#define _syscall3(NUMBER, ARG1, ARG2, ARG3) ({				\
	int rtnval;												\
	asm volatile (											\
		"int $0x80"											\
		: "=a" (rtnval)										\
		: "a" (NUMBER), "b" (ARG1), "c" (ARG2), "d" (ARG3)	\
		:"memory"											\
	);														\
	rtnval;													\
})

增加0x80号中断处理例程

;0x80号中断处理程序
[bits 32]
extern syscall_table
section .text
global syscall_handler
syscall_handler:
;第一步：保存上下文环境
	push 0	;压入error_code，使栈中格式一致
	
	push ds
	push es
	push fs
	push gs
	pushad
	;pushad压入顺序：EAX，ECX，EDX，EBX，ESP，EBP，ESI，EDI
	
	push 0x80	;压入中断号，保持格式统一
	
;第二步：为系统调用子功能传入参数
	push edx	;系统调用中第三个参数
	push ecx	;系统调用中第二个参数
	push ebx	;系统调用中第一个参数
	
;第三步：调用子功能处理函数
	call [syscall_table + eax*4]
	add esp, 12 	;跨过以上三个参数

;第四步：将返回值传入eax
	mov [esp + 8*4], eax	;将返回值赋值给上面保存的eax地址处
	jmp intr_exit			;从中断中返回，恢复上下文

初始化系统调用和实现sys_getpid

//返回当前任务的pid
uint32_t sys_getpid(void) {
	//put_str("sys_getpid");
	return running_thread()->pid;
}

添加系统调用getpid

enum SYSCALL_NR {
	SYS_GETPID,
};

//返回当前任务的pid
uint32_t getpid(void) {
	return _syscall0(SYS_GETPID);	
}

实现系统调用write

用户接口：

//打印字符串str
uint32_t write(char* str) {
	return _syscall1(SYS_WRITE, str);
}

内核实现：

//打印字符串str(未实现文件系统前的版本）
uint32_t sys_write(char* str) {
	console_put_str(str);
	return strlen(str);
}

实现printf

printf是vsprintf和write的封装其中vsprintf对字符串进行解析，write将解析后的字符串打印到屏幕上。

vsprintf的实现如下：

//将整型转换成字符串
void itoa(uint32_t value, char** buf_ptr_addr, uint8_t base) {
	//求模
	uint32_t m = value % base;
	//取整
	uint32_t i = value / base;
	
	//如果不为0则递归调用
	if (i) itoa(i, buf_ptr_addr, base);
	
	//根据大小将其转换为字符
	if (m < 10) {
		**buf_ptr_addr = m + '0';
	} else {
		**buf_ptr_addr = m - 10 + 'A';
	}
	(*buf_ptr_addr)++;
}

//将参数ap按照格式format输出到字符串str，并返回替换后的str长度
uint32_t vsprintf(char* str, const char* format, va_list ap) {
	char* dst = str;
	const char* src = format;
	
	//用于临时存储转换后的变量
	int32_t arg_int;
	char* arg_str;
	//循环直至'\0'
	while (*src) {
		if (*src != '%') {
			*dst = *src;
			dst++;
			src++;
			continue;
		}
		//跳过%
		src++;
		switch (*src) {
			case 'x':
				arg_int = va_arg(ap, int);
				itoa(arg_int, &dst, 16);
				break;
			
			case 's':
				arg_str = va_arg(ap, char*);
				strcpy(dst, arg_str);
				dst += strlen(arg_str);
				break;
			
			case 'c':
				*dst = va_arg(ap, char);
				dst++;
				break;
				
			case 'd':
				arg_int = va_arg(ap, int);
				if (arg_int < 0) {
					*dst = '-';
					dst++;
					arg_int = 0 - arg_int;
				}
				itoa(arg_int, &dst, 10);
				break;
				
		} 
		//继续下一个字符
		src++;
	}
	return strlen(str);
}

printf的实现如下:

//格式化输出字符串format
uint32_t printf(const char* format, ...) {
	//创建并初始化va_list指针
	va_list args;
	va_start(args, format);
	
	char buf[1024] = {0};
	//调用解析函数
	vsprintf(buf, format, args);
	va_end(args);
	//调用系统调用，并返回写了多少个字符
	return write(buf);
}