系统调用的实现

系统调用的实现

什么是操作系统的接口

接口其实是一种抽象，操作系统的接口其实就是一个个函数，知道它的功能然后直接调用就行，而不用管它内核里面是怎么实现的，因为这个函数是系统调用的，所以也称为系统调用。比如：write()、read()等等。

系统调用的实现

前面说的是操作系统的接口，说白了就是一个个函数，调用它们就可以使用相应的功能。那这些系统调用到底是如何实现的呢？下面就来解解密。解决三个问题：

1. 用户程序能不能直接调用系统内核

2. 如果不能直接调用，为什么？如何实现的

3. 用户程序如何才能调用系统内核

1，用户程序能不能直接调用系统内核

不能，如果能的话，那么你从网上下载一段程序就可能进入系统内核获取你的root密码，那么还有什么安全感呢？

2，如果不能直接调用，为什么？如何实现的

但是操作系统和用户程序都是在内存里面，在内存里面是可以交换数据的呀？那为什么就不能直接使用jmp、mov或者函数调用直接进入操作系统内核呢？怎么实现的呢？

实现方法：利用硬件设计将内核程序与用户程序进行隔离，内核程序的所在的那段内存程称为核心态，用户程序所在的那段内存叫用户态。用户态的程序不能直接访问核心态的数据。

实现手段：利用CS的低两位CPL和DS的低两位DPL来实现隔离。首先在head.s里面建立gdt表的时候就将内核段DPL置为0，如下图系统段描述符也就是gdt表中的表项，看看其中的45-46位就是DPL位了。

而CPL(Current Privilege Level)是当前指令的特权级，如果是在用户态，那么CPL就为3（如果是核心态就是0）；在访问某个地址的时候，要看有没有权限访问，0的特权级是高于3，如果CPL的特权级小于等于DPL的特权级，那么就不能访问；注意：如果CPL=DPL是可以访问的；比如CPL=0（说明是内核态），DPL=3（说明是用户态），CPL的特权级大于DPL的特权级，所以能访问。也就是说内核态能访问内存的任意区域。这个隔离对于跳转指令（jmp、mov）同样有效。

详细的请看这里DPL,RPL,CPL 之间的联系和区别.

3，用户程序如何才能调用系统内核

用户态访问内核态只能通过一种途径，那就是中断，int指令将使CS中的CPL从3变为0，这样就可以访问了（即进入内核），这是用户程序发起的调用内核代码的唯一方式。并且这个中断号只能是0x80.

系统调用的核心：

1. 用户程序中包含一段包含int指令的代码

2. 操作系统中有中断函数表，从中可以获取中断服务函数入口地址

3. 操作系统执行中断服务函数

具体实现：以printf为例

首先c代码里面的printf是这样的，printf(“%d”,a);在printf()内部其实是调用了系统函数write函数，而write的函数头其实是这样的

ssize_t write(int fd, const void *buf, size_t count);

fd：文件描述符；

buf：指定的缓冲区，即指针，指向一段内存单元；

nbyte：要写入文件指定的字节数；

返回值：写入文档的字节数（成功）；-1（出错）

可以看到，printf函数的形参和write函数的形参是不一样的。

那么printf(“%d”,a)要调用write函数的话，参数肯定对不上，那么该怎么办呢？要对printf的形参进行处理，使其符合write函数的格式，或者说换一种方式调用。在printf函数里面调用write如下所示

# include <unisted.h>
_syscall3(int, write, int, fd, const char* buf, off_t, count)
//可以看到其实利用的是_syscall3这个宏，这个宏的定义如下
#define _syscall3(type,name,atype,a,btype,b,ctype,c)\
type name(atype a, btype b, ctype c)\
//type=int,name=write,atype=int,a=fd,btype=const char * ,b=buf,ctype=off_t,c=count;
{ long __res;\
__asm__ volatile(“int 0x80”:”=a”(__res):””(__NR_##name),
”b”((long)(a)),”c”((long)(b)),“d”((long)(c)))); if(__res>=0) return
(type)__res; errno=-__res; return -1;}

这里需要注意的是int0x80这个中断；前面已经说过在head.s里面会重新建立gdt表idt表，之后中断就是表示根据中断号查那个表，然后获取中断服务函数的入口地址，int0x80这个中断就是进入操作系统内核，这是上层应用进入操作系统的唯一手段，int 0x80相当于是操作系统的一个门户，接着看_syscall3宏定义下面的代码

long __res;\
__asm__ volatile(“int 0x80”:”=a”(__res):””(__NR_##name),
"b"((long)(a)),"c"((long)(b)),"s"((long)(c)))); if(__res>=0) return 
(type)__res; errno=-__res; return -1;

__NR_write赋值给eax这个寄存器，__NR_write称为系统调用号，后面有大用。

//在linux/inlcude/unistd.h中
#define __NR_write 4  

不熟悉内嵌汇编的盆友看看这几篇博文

• c语言内嵌汇编
• 内嵌汇编学习
• 内嵌汇编简介

什么是系统调用号呢？所有的系统调用都是通过int 0x80这个中断来
调用的，那么如何区分是write调用还是read调用或者是其他调用呢？

就是根据这个系统调用号来区分的，__NR_write表示write调用，会接着执行write对应的内核代码，__NR_read表示read调用，同理，其他的系统调用号也是如此。

"b"((long)(a)),"c"((long)(b)),"d"((long)(c))

就是把形参的a、b、c依次赋值给ebx、ecx、edx三个寄存器；输入完成之后就通过int 0x80这个中断号进入操作系统，int 0x80这条指令执行完之后，eax中就会存放int 0x80的返回值，然后将这个返回值赋值给__res，__res就是int write()这个系统调用的返回值。write这个系统调用也就结束了。

总结一下**_syscall3**这个宏的用法：
调用这个宏可以理解为调用一个函数，宏的定义：

#define _syscall3(type,name,atype,a,btype,b,ctype,c)

type 表示函数返回值，name表示函数名，后面分别是三个形参的类型和行参名。
name不同，系统调用号不同，所以调用**_syscall3之后执行的代码不同，在宏里面通过
int 0x80进入系统内核并将指条指令的结果存在eax**寄存器中，然后返回到宏的调用处。

具体再扒一下：

前面说的int 0x80都是用“这条指令“来表示了，那么int 0x80到底
是什么呢？int 0x80是进入中断服务函数的一条指令。
int 指令首先要查idt表转去哪里执行。

void sched_init(void)
{ set_system_gate(0x80,&system_call); }12

int 0x80对应的中断处理程序就是system_call，从这个init就知道这是一个初始化，0x80这个中断就是用后面这个system_call来处理，那么系统是怎么设置的呢？通过set_system_gate这个宏。

//在linux/include/asm/system.h中
#define set_system_gate(n, addr) \
_set_gate(&idt[n],15,3,addr); //idt是中断向量表基址123

set_system_gate这个宏又调用了**_set_gate**这个宏，

//在linux/include/asm/system.h中
#define _set_gate(gate_addr, type, dpl, addr)\
__asm__(“movw %%dx,%%ax\n\t” “movw %0,%%dx\n\t”\
“movl %%eax,%1\n\t” “movl %%edx,%2”:\
:”i”((short)(0x8000+(dpl<<13)+type<<8))),“o”(*(( \
char*)(gate_addr))),”o”(*(4+(char*)(gate_addr))),\
“d”((char*)(addr),”a”(0x00080000))1234567

这里我也看不懂，但是我知道**_set_gate这个宏的作用就是建立一个类似这样的下图表，处理函数入口点偏移system_call**,DPL就是3，段选择符就是0x0008,即CS是8。

用户态的程序如果要进入内核，必须使用0x80号中断，那么就必须先要进入idt表。用户态的CPL=3，且idt表的DPL故意设置成3，因此能够跳到idt表，跳到idt表中之后就能找到之后程序跳转的地方，也就是中断服务函数的起始地址，CS就是段选择符（8），ip就是”处理函数入口点偏移“。记不记得setup.s里面有一行

jmpi 0,8

这条指令表示根据gdt表跳转到内核代码的地址0处。CS=8，ip=system_call就是跳到内核的system_call这个函数；另外如果CS=8，那么CPL=0，因为CPL是CS最低两位。也就是说当前程序的特权级变了，变成内核态的了。完整流程：初始化的时候0x80号中断的DPL设成3，让用户态的代码能跳进来，跳进来之后根据CS=8将CPL设为0，到了内核态，到了内核态就什么都能干了，将来int 0x80返回的之后，CS最后两位肯定变成3，变成用户态。

中断处理函数system_call到底做了什么呢？

//在linux/kernel/system_call.s中
nr_system_calls=72
.globl _system_call
_system_call: cmpl $nr_system_calls-1,%eax
ja bad_sys_call
push %ds push %es push %fs
pushl %edx pushl %ecx pushl %ebx //调用的参数
movl $0x10,%edx mov %dx,%ds mov %dx,%es //内核数据
movl $0x17,%edx mov %dx,%fs //fs可以找到用户数据
call _sys_call_table(,%eax,4) //a(,%eax,4)=a+4*eax
pushl %eax //返回值压栈，留着ret_from_sys_call时用
... //其他代码
ret_from_sys_call: popl %eax, 其他pop, iret1234567891011121314

前面都是压栈和赋值，接着调用了_sys_call_table(,%eax,4)。
$$a(,\%eax,4)=a+4\ast eax$$

$$\_sys\_call\_table(,\%eax,4)=\_sys\_call\_table+4\ast \%eax$$

这是一种寻址方式。eax是系统调用号，那**_sys_call_table**是什么？

//在include/linux/sys.h中
fn_ptr sys_call_table[]=
{sys_setup, sys_exit, sys_fork, sys_read, sys_write,
...};
//在include/linux/sched.h中
typedef int (fn_ptr*)();1234567

sys_call_table是一个fn_ptr类型的全局函数表，fn_ptr是一个函数指针，4个字节，这就是_sys_call_table+4*%eax；这里为什么要*4的原因，sys_call_table的每一项都是4个字节，然后就可以根据eax来知道要调用的真正中断服务函数的入口地址了，对于write系统函数来说，就是sys_write。

总结一下系统调用的实现：

$$printf->\_syscall3->write->int0x80->system\_call->sys\_call\_table->sys\_write$$
printf通用_syscall3这个宏调用write函数，在write函数里面用system_call来处理int 0x80,在system_call中会调用system_call_table这个表，根据eax中存储的系统调用号就可以找到真正的sys_write了。