#179 Linux 内核分析 之四:使用库函数API和嵌入汇编两种方式使用同一个系统调用

说明

欧长坤 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 这学期学校恰好有操作系统的课程,上个学习就开始寻思研究研究Linux内核代码,恰好MOOC有这个课程,遂选了此课。

一、准备工作

本周的实验比起前三周的实验稍微容易得多。我们可以在http://codelab.shiyanlou.com/xref/linux-3.18.6/arch/x86/syscalls/syscall_32.tbl中查看系统调用号。

二、分析

在这里,我们决定使用sysinfo这个库函数API,首先,我们得会使用这个API。

在 Linux 中,sysinfo可以用来获取系统相关信息的结构体。 函数声明和原型如下所示:

1
2
#include <sys/sysinfo.h>
int sysinfo(struct sysinfo *info);

那么,这个sysinfo的结构体长什么样?

1
2
3
4
5
6
7
8
9
10
11
12
struct sysinfo {                  
long uptime;
unsigned long loads[3]; // 启动到现在经过的时间
unsigned long totalram; // 总的可用的内存大小
unsigned long freeram; // 还未被使用的内存大小
unsigned long sharedram; // 共享的存储器的大小
unsigned long bufferram; // 缓冲区大小
unsigned long totalswap; // 交换区大小
unsigned long freeswap; // 还可用的交换区大小
unsigned short procs; // 当前进程数目
char _f[22]; // 64字节的补丁结构
};

其实我们都并不关心这个sysinfo的结构到底长什么样,我们目前所关心的是如何能够成功的调用。 实际上看到这里,我们已经能够完成使用库函数调用的C代码了。

那么怎么用汇编来实现呢? 我们得知道sysinfo的系统调用号是多少,容易知道sysinfo的系统调用号是116。所以,嵌入汇编时的值应该为0x74。

三、实验过程

我们先写好使用库函数API调用的版本,使用vi来编辑一个syscall.c的代码:

1
ouchangkun@ubuntu:~/Works/syscall$ vi syscall.c

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <sys/sysinfo.h>

int main() {
struct sysinfo sys_info;
int error;
error = sysinfo(&amp;sys_info); // 在这里,我们完成了对sysinfo这个库函数API的调用
printf("code error=%d\n",error);

printf("Uptime = %lds\n"
"Load: 1 min%ld / 5 min %ld / 15 min %ld\n"
"RAM: total %ld / free %ld / shared%ld\n"
"Memory in buffers = %ld\n"
"Swap: total%ld / free%ld\n"
"Number of processes = %d\n",
sys_info.uptime,
sys_info.loads[0], sys_info.loads[1], sys_info.loads[2],
sys_info.totalram, sys_info.freeram, sys_info.sharedram,
sys_info.bufferram,
sys_info.totalswap, sys_info.freeswap,
sys_info.procs);
return 0;
}

接下来编译和执行都不用说,然后就是输出结果:

1
2
3
4
5
6
7
8
9
10
ouchangkun@ubuntu:~/Works/syscall$ gcc syscall.c -o syscall -m32
ouchangkun@ubuntu:~/Works/syscall$ ./syscall
code error=0
Uptime = 1020s
Load: 1 min2336 / 5 min 2432 / 15 min 3008
RAM: total 1038680064 / free 74907648 / shared0
Memory in buffers = 31862784
Swap: total1071640576 / free1070592000
Number of processes = 425
ouchangkun@ubuntu:~/Works/syscall$

至此,我们完成了一个使用库函数调用的版本。

好,那么我们现在要来编写嵌入汇编的版本。

正常情况下,我们一般会对老师编写time函数的汇编版本产生下面的疑惑: 在老师的代码中,

1
2
3
4
5
asm volatile(
"mov $0,%%ebx\n\t"
"mov $0x80,%%eax\n\t"
...
);

最开始这一行: mov $0,%%ebx 为什么要将%%ebx清零呢?

事实上在系统调用时,system_call是linux系统调用的入口点。每个系统调用至少有一个参数,那就是eax,它负责传递系统调用号,同时获取返回值。 除了eax外,还允许至多6个参数,分别是ebx,ecx,edx,esi,edi,ebp。 另一方面,容易观察到,实际上time()函数除了自身的传入系统调用号(同时接收返回值)外,还传入了一个参数NULL。 结合上面的叙述,应该可以猜到,其实代码mov $0,%%ebx\n\t是相当于向ebx传入了一个参数NULL,也就是0

同理,对于sysinfo这个库函数API,它也有一个返回值,表示是否成功,并且传递进来一个参数sys_info来接收系统的相关信息。因此,我们可以编写下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// syscall_asm.c
#include <stdio.h>
#include <sys/sysinfo.h>

int main() {
struct sysinfo sys_info;
int error;
//error = sysinfo(&amp;sys_info);
asm volatile(
"movl %1, %%ebx\n\t"
"movl $0x74, %%eax\n\t" // sysinfo 的系统调用号是 116 所以十六进制为 0x74
"int $0x80\n\t"
"movl %%eax, %0"
: "=m" (error) // eax来负责传递返回值,我们同样用error来接收
: "b" (&amp;sys_info) // sysinfo的地址作为参数,传递进ebx中作为参数被修改接收系统信息
);

printf("code error=%d\n",error);

printf("Uptime = %lds\n"
"Load: 1 min%ld / 5 min %ld / 15 min %ld\n"
"RAM: total %ld / free %ld / shared%ld\n"
"Memory in buffers = %ld\n"
"Swap: total%ld / free%ld\n"
"Number of processes = %d\n",
sys_info.uptime,
sys_info.loads[0], sys_info.loads[1], sys_info.loads[2],
sys_info.totalram, sys_info.freeram, sys_info.sharedram,
sys_info.bufferram,
sys_info.totalswap, sys_info.freeswap,
sys_info.procs);
return 0;
}

所以,最后的执行结果我们可以看到,是一样的:

1
2
3
4
5
6
7
8
9
ouchangkun@ubuntu:~/Works/syscall$ gcc syscall_asm.c -o syscall_asm -m32
ouchangkun@ubuntu:~/Works/syscall$ ./syscall_asm
code error=0
Uptime = 3227s
Load: 1 min288 / 5 min 2176 / 15 min 2976
RAM: total 1038680064 / free 111718400 / shared0
Memory in buffers = 86638592
Swap: total1071640576 / free1047654400
Number of processes = 422

四、总结

我们来总结一下: 一般的,进程是不能访问内核的。它不能访问内核所占内存空间也不能调用内核函数。CPU硬件决定了这些(这就是为什么它被称作“保护模式”)。系统调用是这些规则的一个唯一例外。其原理是进程先用适当的值填充寄存器,然后调用一个特殊的指令(系统调用号),这个指令会跳到一个事先定义的内核中的一个位置(显然,这个位置是用户进程可读但是不可写的)。在Intel CPU中,这个由中断0x80实现。硬件知道一旦你跳到这个位置,你就不是在限制模式下运行的用户,而是作为操作系统的内核,所以你就可以为所欲为了。 进程可以跳转到的内核位置叫做sysem_call。这个过程检查系统调用号,这个号码告诉内核进程请求哪种服务。然后,它查看系统调用表(sys_call_table)找到所调用的内核函数入口地址。接着,就调用函数,等返回后,做一些系统检查,最后返回到进程(或到其他进程,如果这个进程时间用尽)。 调用内核的参数传递最多涉及七个寄存器:eax,ebx,ecx,edx,esi,edi,ebp。其中,eax用来传入系统调用号,并用来接收返回值。其他六个参数作为函数的输入或输出参数被传递进去。

如果我的文章对你起到了帮助,你可以选择金额不限的捐助,帮助我写出更多的文章。