深入理解Linux的系统调用

浏览数：44 / 时间：2015年06月20日

　　一、什么是系统调用

　　在Linux的世界里，我们经常会遇到系统调用这一术语，所谓系统调用，就是内核提供的、功能十分强大的一系列的函数。这些系统调用是在内核中实现的，再通过一定的方式把系统调用给用户，一般都通过门(gate)陷入(trap)实现。系统调用是用户程序和内核交互的接口。
　

　　二、系统调用的作用

　　系统调用在Linux系统中发挥着巨大的作用，如果没有系统调用，那么应用程序就失去了内核的支持。

　　我们在编程时用到的很多函数，如fork、open等这些函数最终都是在系统调用里实现的，比如说我们有这样一个程序：

 1 　　#include <unistd.h>
 2 
 3 　　#include <stdlib.c>
 4 
 5 　　int main() 
 6 
 7 　　{ 
 8 
 9 　　 fork(); 
10 
11 　　 exit(0); 
12 
13 　　}

　　这里我们用到了两个函数，即fork和exit,这两函数都是glibc中的函数，但是如果我们跟踪函数的执行过程，看看glibc对fork和exit函数的实现就可以发现在glibc的实现代码里都是采用软中断的方式陷入到内核中再通过系统调用实现函数的功能的。具体过程我们在系统调用的实现过程会详细的讲到。

　　由此可见，系统调用是用户接口在内核中的实现，如果没有系统调用，用户就不能利用内核。

　　三、系统调用的现实及调用过程

　　详细讲述系统调用的之前也讲一下Linux系统的一些保护机制。

　　Linux系统在CPU的保护模式下提供了四个特权级别，目前内核都只用到了其中的两个特权级别，分别为“特权级0”和“特权级3”,级别0也就是我们通常所讲的内核模式，级别3也就是我们通常所讲的用户模式。划分这两个级别主要是对系统提供保护。内核模式可以执行一些特权指令和进入用户模式，而用户模式则不能。

　　这里特别提出的是，内核模式与用户模式分别使用自己的堆栈，当发生模式切换的时候同时要进行堆栈的切换。

　　每个进程都有自己的地址空间（也称为进程空间），进程的地址空间也分为两部分：用户空间和系统空间，在用户模式下只能访问进程的用户空间，在内核模式下则可以访问进程的全部地址空间，这个地址空间里的地址是一个逻辑地址，通过系统段面式的管理机制，访问的实际内存要做二级地址转换，即：逻辑地址线性地址物理地址。

　　系统调用对于内核来说就相当于函数，我们是关键问题是从用户模式到内核模式的转换、堆栈的切换以及参数的传递。　　

　　下面将结合内核源代码对这些过程进行分析，以下分析环境为FC2,kernel 2.6.5

　　下面是内核源代码里arch/i386/kernel/entry.S的一段代码

　　

  1 　　/* clobbers ebx, edx and ebp */ 　　 
  2 
  3 　　#define __SWITCH_KERNELSPACE \ 
  4 
  5 　　 cmpl $0xff000000, %esp; \ 
  6 
  7 　　 jb 1f; \ 
  8 
  9 　　 \ 
 10 
 11 　　 /* \ 
 12 
 13 　　 * switch pagetables and load the real stack, \ 
 14 
 15 　　 * keep the stack offset: \ 
 16 
 17 　　 */ \ 
 18 
 19 　　 \ 
 20 
 21 　　 movl $swapper_pg_dir-__PAGE_OFFSET, %edx; \ 
 22 
 23 　　 \ 
 24 
 25 　　 /* GET_THREAD_INFO(%ebp) intermixed */ \ 
 26 
 27 　　0: \ 
 28 
 29 　　 ……………………………………. \ 
 30 
 31 　　1: 　　 
 32 
 33 　　#endif 　　 
 34 
 35 　　#define __SWITCH_USERSPACE \ 
 36 
 37 　　 /* interrupted any of the user return paths? */ \ 
 38 
 39 　　 \ 
 40 
 41 　　 movl EIP(%esp), %eax; \ 
 42 
 43 　　 ……………………………………….. \ 
 44 
 45 　　 jb 22f; /* yes - switch to virtual stack */ \ 
 46 
 47 　　 /* return to userspace? */ \ 
 48 
 49 　　44: \ 
 50 
 51 　　 movl EFLAGS(%esp),%ecx; \ 
 52 
 53 　　 movb CS(%esp),%cl; \ 
 54 
 55 　　 testl $(VM_MASK 　 3),%ecx; \ 
 56 
 57 　　 jz 2f; \ 
 58 
 59 　　22: \ 
 60 
 61 　　 /* \ 
 62 
 63 　　 * switch to the virtual stack, then switch to \ 
 64 
 65 　　 * the userspace pagetables. \ 
 66 
 67 　　 */ \ 
 68 
 69 　　 \ 
 70 
 71 　　 GET_THREAD_INFO(%ebp); \ 
 72 
 73 　　 movl TI_virtual_stack(%ebp), %edx; \ 
 74 
 75 　　 movl TI_user_pgd(%ebp), %ecx; \ 
 76 
 77 　　 \ 
 78 
 79 　　 movl %esp, %ebx; \ 
 80 
 81 　　 andl $(THREAD_SIZE-1), %ebx; \ 
 82 
 83 　　 orl %ebx, %edx; \ 
 84 
 85 　　int80_ret_start_marker: \ 
 86 
 87 　　 movl %edx, %esp; \ 
 88 
 89 　　 movl %ecx, %cr3; \ 
 90 
 91 　　 \ 
 92 
 93 　　 __RESTORE_ALL; \ 
 94 
 95 　　int80_ret_end_marker: \ 
 96 
 97 　　2: 
 98 
 99 　　 
100 
101 　　#else /* !CONFIG_X86_HIGH_ENTRY */ 　　 
102 
103 　　#define __SWITCH_KERNELSPACE 
104 
105 　　#define __SWITCH_USERSPACE 　　 
106 
107 　　#endif 　　 
108 
109 　　#define __SAVE_ALL \ 
110 
111 　　…………………………………….. 　　 
112 
113 　　#define __RESTORE_INT_REGS \ 
114 
115 　　…………………………. 　　 
116 
117 　　#define __RESTORE_REGS \ 
118 
119 　　 __RESTORE_INT_REGS; \ 
120 
121 　　111: popl %ds; \ 
122 
123 　　222: popl %es; \ 
124 
125 　　.section .fixup,"ax"; \ 
126 
127 　　444: movl $0,(%esp); \ 
128 
129 　　 jmp 111b; \ 
130 
131 　　555: movl $0,(%esp); \ 
132 
133 　　 jmp 222b; \ 
134 
135 　　.previous; \ 
136 
137 　　.section __ex_table,"a";\ 
138 
139 　　 .align 4; \ 
140 
141 　　 .long 111b,444b;\ 
142 
143 　　 .long 222b,555b;\ 
144 
145 　　.previous 
146 
147 　　 
148 
149 　　#define __RESTORE_ALL \ 
150 
151 　　 __RESTORE_REGS \ 
152 
153 　　 addl $4, %esp; \ 
154 
155 　　333: iret; \ 
156 
157 　　.section .fixup,"ax"; \ 
158 
159 　　666: sti; \ 
160 
161 　　 movl $(__USER_DS), %edx; \ 
162 
163 　　 movl %edx, %ds; \ 
164 
165 　　 movl %edx, %es; \ 
166 
167 　　 pushl $11; \ 
168 
169 　　 call do_exit; \ 
170 
171 　　.previous; \ 
172 
173 　　.section __ex_table,"a";\ 
174 
175 　　 .align 4; \ 
176 
177 　　 .long 333b,666b;\ 
178 
179 　　.previous 
180 
181 　　 
182 
183 　　#define SAVE_ALL \ 
184 
185 　　 __SAVE_ALL; \ 
186 
187 　　 __SWITCH_KERNELSPACE; 
188 
189 　　 
190 
191 　　#define RESTORE_ALL \ 
192 
193 　　 __SWITCH_USERSPACE; \ 
194 
195 　　 __RESTORE_ALL; 
196

　　以上这段代码里定义了两个非常重要的宏,即SAVE_ALL和RESTORE_ALL

SAVE_ALL先保存用户模式的寄存器和堆栈信息,然后切换到内核模式,宏__SWITCH_KERNELSPACE实现地址空间的转换RESTORE_ALL的过程过SAVE_ALL的过程正好相反。　　

　　在内核原代码里有一个系统调用表：（entry.S的文件里）
　　

 1 　　ENTRY(sys_call_table) 
 2 
 3 　　 .long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */ 
 4 
 5 　　 .long sys_exit 
 6 
 7 　　 .long sys_fork 
 8 
 9 　　 .long sys_read 
10 
11 　　 .long sys_write 
12 
13 　　 .long sys_open /* 5 */ 
14 
15 　　 ……………….. 
16 
17 　　 .long sys_mq_timedreceive /* 280 */ 
18 
19 　　 .long sys_mq_notify 
20 
21 　　 .long sys_mq_getsetattr 　　 
22 
23 　　syscall_table_size=(.-sys_call_table)

　　在2.6.5的内核里，有280多个系统调用，这些系统调用的名称全部在这个系统调用表里。

　　在这个原文件里，还有非常重要的一段

　　

 1 　　ENTRY(system_call) 
 2 
 3 　　 pushl %eax # save orig_eax 
 4 
 5 　　 SAVE_ALL 
 6 
 7 　　 GET_THREAD_INFO(%ebp) 
 8 
 9 　　 cmpl $(nr_syscalls), %eax 
10 
11 　　 jae syscall_badsys 
12 
13 　　 # system call tracing in operation 
14 
15 　　 testb $(_TIF_SYSCALL_TRACE　_TIF_SYSCALL_AUDIT),TI_flags(%ebp) 
16 
17 　　 jnz syscall_trace_entry 
18 
19 　　syscall_call: 
20 
21 　　 call *sys_call_table(,%eax,4) 
22 
23 　　 movl %eax,EAX(%esp) # store the return value 
24 
25 　　syscall_exit: 
26 
27 　　 cli # make sure we don‘t miss an interrupt 
28 
29 　　 # setting need_resched or sigpending 
30 
31 　　 # between sampling and the iret 
32 
33 　　 movl TI_flags(%ebp), %ecx 
34 
35 　　 testw $_TIF_ALLWORK_MASK, %cx # current->work 
36 
37 　　 jne syscall_exit_work 
38 
39 　　restore_all: 
40 
41 　　 RESTORE_ALL

　　这一段完成系统调用的执行。

　　system_call函数根据用户传来的系统调用号，在系统调用表里找到对应的系统调用再执行。

　　从glibc的函数到系统调用还有一个很重要的环节就是系统调用号。

　　系统调用号的定义在include/asm-i386/unistd.h里

　　

 1 　　#define __NR_restart_syscall 0 
 2 
 3 　　#define __NR_exit 1 
 4 
 5 　　#define __NR_fork 2 
 6 
 7 　　#define __NR_read 3 
 8 
 9 　　#define __NR_write 4 
10 
11 　　#define __NR_open 5 
12 
13 　　#define __NR_close 6 
14 
15 　　#define __NR_waitpid 7 
16 
17 　　…………………………………..

　　每一个系统调用号都对应有一个系统调用

　　接下来就是系统调用宏的展开

　　

 1 //没有参数的系统调用的宏展开 
 2 　 
 3 
 4 　　#define _syscall0(type,name) \ 
 5 
 6 　　type name(void) \ 
 7 
 8 　　{ \ 
 9 
10 　　long __res; \ 
11 
12 　　__asm__ volatile ("int $0x80" \ 
13 
14 　　 : "=a" (__res) \ 
15 
16 　　 : "0" (__NR_##name)); \ 
17 
18 　　__syscall_return(type,__res); \ 
19 
20 　　} 　　 
21 
22 　　 
23 
24 //　　带一个参数的系统调用的宏展开 
25 　　 
26 
27 　　#define _syscall1(type,name,type1,arg1) \ 
28 
29 　　type name(type1 arg1) \ 
30 
31 　　{ \ 
32 
33 　　long __res; \ 
34 
35 　　__asm__ volatile ("int $0x80" \ 
36 
37 　　 : "=a" (__res) \ 
38 
39 　　 : "0" (__NR_##name),"b" ((long)(arg1))); \ 
40 
41 　　__syscall_return(type,__res); \ 
42 
43 　　} 　 
44 
45 //　　两个参数 
46  
47 
48 　　#define _syscall2(type,name,type1,arg1,type2,arg2) \ 　　 
49 
50 //　　三个参数的 
51 
52 
53 　　#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 　　 
54 
55 //　　四个参数的 
56  
57 
58 　　#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 　　 
59 
60 //　　五个参数的 
61 
62 　　#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 
63 
64 　　 type5,arg5) \ 
65 　　 
66 
67 //　　六个参数的 
68  
69 
70 　　#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 
71 
72 　　 type5,arg5,type6,arg6) \ 
73 
74 　　_res); \

　　从这段代码我们可以看出int $0x80通过软中断开触发系统调用，当发生调用时，函数中的name会被系统系统调用名所代替。然后调用前面所讲的system_call。这个过程里包含了系统调用的初始化，系统调用的初始化原代码在：

　　arch/i386/kernel/traps.c中

　　每当用户执行int 0x80时，系统进行中断处理，把控制权交给内核的system_call。　　

　　整个系统调用的过程可以总结如下：

　　1．执行用户程序(如:fork)

　　2．根据glibc中的函数实现，取得系统调用号并执行int $0x80产生中断。

　　3．进行地址空间的转换和堆栈的切换，执行SAVE_ALL。（进行内核模式）

　　4．进行中断处理，根据系统调用表调用内核函数。

　　5．执行内核函数。

　　6．执行RESTORE_ALL并返回用户模式　　

　　解了系统调用的实现及调用过程，我们可以根据自己的需要来对内核的系统调用作修改或添加。

深入理解Linux的系统调用【转】,古老的榕树,5-wow.com

郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

深入理解Linux的系统调用