从JOS源码了解系统调用

        首先何为系统调用？根据维基百科的解释：a system call is how a program requests a service from an operating system's kernel. 简意就是用户程序对操作系统内核服务的请求。我们知道用户程序所能做的事情很有限，比如我们不能自己写代码直接操作硬盘，不能自己写代码控制控制台的输入输出等等，那怎么办呢？办法就是请求操作系统帮我们完成，毕竟操作系统掌控着所有的计算资源，因此对它来说，控制硬盘，显示器啦肯定都是不在话下的。

       其实我们平时写的很多用户程序都用到系统调用，只不过由于一般编程语言都会把系统调用封装在标准库里面，所以我们没有发觉。因此系统调用很多时候对我们来说就是简单的调用函数。比如c语言中，我们最常用的pritf格式化输出函数就需要用到系统调用，毕竟将一些东西显示到显示器上还不是那么容易的～

      下面以JOS操作系统的源码来了解一下系统调用，以及他是怎么封装在函数当中的。

     首先假如我们编写了以下用户程序

// hello, world
#include <inc/lib.h>

void
main(int argc, char **argv)
{
	cprintf("hello, world!\n");
}

首先需要调用打印函数，看一下打印函数的实现

int
cprintf(const char *fmt, ...)
{
	va_list ap;
	int cnt;

	va_start(ap, fmt);
	cnt = vcprintf(fmt, ap);
	va_end(ap);

	return cnt;
}

打印函数需要调用 vcprintf 函数，接着看vcprintf 函数的实现

int
vcprintf(const char *fmt, va_list ap)
{
	struct printbuf b;

	b.idx = 0;
	b.cnt = 0;
	vprintfmt((void*)putch, &b, fmt, ap);
	sys_cputs(b.buf, b.idx);

	return b.cnt;
}

可以看到vcprintf需要调用两个函数：vprintfmat 和 sys_cputs 

以下是vprintfmat 函数的代码

void
vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list ap)//caller : vprintfmt((void*)putch, &cnt, fmt, ap);
{
	register const char *p;
	register int ch, err;
	unsigned long long num;
	int base, lflag, width, precision, altflag;
	char padc;

	while (1) {
		while ((ch = *(unsigned char *) fmt++) != '%') {
			if (ch == '\0')
				return;
			putch(ch, putdat);
		       }

		// Process a %-escape sequence
		padc = ' ';
		width = -1;
		precision = -1;
		lflag = 0;
		altflag = 0;
	reswitch:
		switch (ch = *(unsigned char *) fmt++) {

		// flag to pad on the right
		case '-':
			padc = '-';
			goto reswitch;

		// flag to pad with 0's instead of spaces
		case '0':
			padc = '0';
			goto reswitch;

		// width field
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			for (precision = 0; ; ++fmt) {
				precision = precision * 10 + ch - '0';
				ch = *fmt;
				if (ch < '0' || ch > '9')
					break;
			}
			goto process_precision;

		case '*':
			precision = va_arg(ap, int);
			goto process_precision;

		case '.':
			if (width < 0)
				width = 0;
			goto reswitch;

		case '#':
			altflag = 1;
			goto reswitch;

		process_precision:
			if (width < 0)
				width = precision, precision = -1;
			goto reswitch;

		// long flag (doubled for long long)
		case 'l':
			lflag++;
			goto reswitch;

		// character
		case 'c':
			putch(va_arg(ap, int), putdat);
			break;

		// error message
		case 'e':
			err = va_arg(ap, int);
			if (err < 0)
				err = -err;
			if (err >= MAXERROR || (p = error_string[err]) == NULL)
				printfmt(putch, putdat, "error %d", err);
			else
				printfmt(putch, putdat, "%s", p);
			break;

		// string
		case 's':
			if ((p = va_arg(ap, char *)) == NULL)
				p = "(null)";
			if (width > 0 && padc != '-')
				for (width -= strnlen(p, precision); width > 0; width--)
					putch(padc, putdat);
			for (; (ch = *p++) != '\0' && (precision < 0 || --precision >= 0); width--)
				if (altflag && (ch < ' ' || ch > '~'))
					putch('?', putdat);
				else
					putch(ch, putdat);
			for (; width > 0; width--)
				putch(' ', putdat);
			break;

		// (signed) decimal
		case 'd':
			num = getint(&ap, lflag);
			if ((long long) num < 0) {
				putch('-', putdat);
				num = -(long long) num;
			}
			base = 10;
			goto number;

		// unsigned decimal
		case 'u':
			num = getuint(&ap, lflag);
			base = 10;
			goto number;

		// (unsigned) octal
		case 'o':
			num = getuint(&ap,lflag);
                        base = 8;
                        goto number;
			break;

		// pointer
		case 'p':
			putch('0', putdat);
			putch('x', putdat);
			num = (unsigned long long)
				(uintptr_t) va_arg(ap, void *);
			base = 16;
			goto number;

		// (unsigned) hexadecimal
		case 'x':
			num = getuint(&ap, lflag);
			base = 16;
		number:
			printnum(putch, putdat, num, base, width, padc);
			break;

		// escaped '%' character
		case '%':
			putch(ch, putdat);
			break;

		// unrecognized escape sequence - just print it literally
		default:
			putch('%', putdat);
			for (fmt--; fmt[-1] != '%'; fmt--)
				/* do nothing */;
			break;
		}
	}
}

从vprintfmat函数的代码可以看出，他主要调用的是putch，所以下面再让我们看一下putch的代码

static void
putch(int ch, struct printbuf *b)
{
	b->buf[b->idx++] = ch;
	if (b->idx == 256-1) {
		sys_cputs(b->buf, b->idx);
		b->idx = 0;
	}
	b->cnt++;
}

可以看到putch中主要掉用的是sys_cputs 函数，是不是似曾相识？回头看一下vcprintf函数，就会看到sys_cputs 函数！因此抛开细节，sys_cputs函数是关键！

好了让我们看看sys_cputs函数的真面目

void
sys_cputs(const char *s, size_t len)
{
	syscall(SYS_cputs, 0, (uint32_t)s, len, 0, 0, 0);
}

大吃一惊，我还以为他会是几百行呢。原来它也是调用了另一个函数 ： syscall

不过看这个函数名称，好像离我们的系统调用很近了！

好，我们接着看下面的syscall函数源码

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

	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;
}

非常遗憾是看不懂的一段内联汇编，没事我们可以看看汇编后的汇编代码

 800a18:	55                   	push   %ebp
  800a19:	89 e5                	mov    %esp,%ebp
  800a1b:	57                   	push   %edi
  800a1c:	56                   	push   %esi
  800a1d:	53                   	push   %ebx


	asm volatile("int %1\n"
  800a1e:	b8 00 00 00 00       	mov    $0x0,%eax
  800a23:	8b 4d 0c             	mov    0xc(%ebp),%ecx
  800a26:	8b 55 08             	mov    0x8(%ebp),%edx
  800a29:	89 c3                	mov    %eax,%ebx
  800a2b:	89 c7                	mov    %eax,%edi
  800a2d:	89 c6                	mov    %eax,%esi
  800a2f:	cd 30                	int    $0x30

简单看一下这段代码，前面部分是建立栈帧。asm volatile部分的代码从 0x800ale地址开始。前面都是寄存器操作，看后面，有一个int 30，软中断。通过JOS源码可以知道，JOS的IDT对应的系统调用号是0x30。 这样我们就可以理解int 30 了！

其实我之前一直不太理解的问题是，int 30之后 系统怎么知道程序请求的具体是哪一个系统调用呢？我也知道是通过eax寄存器中的参数确定，但我不知道用户进程是怎么设置eax中的参数的，如今读了JOS源码才算知道。原来，对于用户进程调用的库函数，所有的库函数都有一个公共的接口(这里就是syscall函数)，于是就可以通过这个接口，设置eax寄存器中的参数，使得各个库函数分别对应到各自的系统调用中。而这一切对用户程序来说都是透明的，他根本不知道什么是eax。

PS：以上代码源自MIT JOS系统源码