云社区 博客 博客详情
云社区 博客 博客详情

Linux操作系统分析 | 深入理解系统调用

不鸭冲鸭 发表于 2020-05-27 19:31:28 05-27 19:31
不鸭冲鸭 发表于 2020-05-27 19:31:28 2020/05/27
0
0

【摘要】 实验要求1、找一个系统调用,系统调用号为学号最后2位相同的系统调用2、通过汇编指令触发该系统调用3、通过gdb跟踪该系统调用的内核处理过程4、重点阅读分析系统调用入口的保存现场、恢复现场和系统调用返回,以及重点关注系统调用过程中内核堆栈状态的变化    实验环境及配置 VMware®Workstation15Pro Ubuntu16.04.3LTS64位操作系统  一、基本理论...

实验要求

1、找一个系统调用,系统调用号为学号最后2位相同的系统调用

2、通过汇编指令触发该系统调用

3、通过gdb跟踪该系统调用的内核处理过程

4、重点阅读分析系统调用入口的保存现场、恢复现场和系统调用返回,以及重点关注系统调用过程中内核堆栈状态的变化

 


 

 

 

实验环境及配置

 

VMware® Workstation 15 Pro

 

Ubuntu 16.04.3 LTS

64位操作系统

 

 

一、基本理论

1、Linux 的系统调用

当用户态进程调用一个系统调用时,CPU切换到内核态并开始执行 system_call (entry_INT80_32 或 entry_SYSCALL_64)  汇编代码,其中根据系统调用号调用对应的内核处理函数。

具体来说,进入内核后,开始执行对应的中断服务程序 entry_INT80_32 或者 entry_SYSCALL_64。

2、触发系统调用的方法

(1)使用C库函数触发系统调用

以time系统调用为例:

(2)使用 int &0x80 或者 syscall 汇编代码触发系统调用

以time系统调用为例。

32位系统:

 

64位系统:

 

二、通过汇编指令触发一个系统调用

1、选择一个系统调用

(1)步骤:

 Linux源代码中的 syscall_32.tbl 和 syscall_64.tbl 分别定义了 32位x86 和 64位x86-64的系统调用内核处理函数。

由于我的 Linux 系统是64位的,所以进入Linux源代码中:

~/arch/x86/entry/syscalls/syscall_64.tbl

可以查看系统调用表,如下图所示:

我的学号最后两位为50,所以选择 50号 系统调用。

(2)listen 函数

a. 作用

listen 函数用于监听来自客户端的 tcp socket 的连接请求,一般在调用 bind 函数之后、调用 accept 函数之前调用 listen 函数。

b. 函数原型

#include 
int listen(int sockfd, int backlog)

参数 sockfd:被 listen 函数作用的套接字

参数 backlog:侦听队列的长度

返回值:

成功 失败 错误信息
0 -1

EADDRINUSE:另一个socket 也在监听同一个端口

EBADF:参数sockfd为非法的文件描述符。

ENOTSOCK:参数sockfd不是文件描述符。

EOPNOTSUPP:套接字类型不支持listen操作

2、通过汇编指令触发系统调用

(1)新建服务器端程序:server.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
	int sockfd,new_fd,listen_result;
	struct sockaddr_in my_addr;
	struct sockaddr_in their_addr;
	int sin_size;
	//建立TCP套接口
	if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
	{
		printf("create socket error");
		perror("socket");
		exit(1);
	}
	//初始化结构体,并绑定2323端口
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(2328);
	my_addr.sin_addr.s_addr = INADDR_ANY;
	bzero(&(my_addr.sin_zero),8);
	//绑定套接口
	if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
	{
		perror("bind socket error");
		exit(1);
	}
	//创建监听套接口, 监听队列长度为10
        //listen_result = listen(sockfd,10);
        asm volatile(
            "movl $0xa,%%edi\n\t"    //listen函数的第二个参数
            "movl %1,%%edi\n\t"      //listen函数的第一个参数
            "movl $0x32,%%eax\n\t"   //将系统调用号50存入eax寄存器
            "syscall\n\t"
            "movq %%rax,%0\n\t"
            :"=m"(listen_result)
            :"g"(sockfd)
        );
        if(listen_result == 0)
        {
            printf("listen is being called\n");
        }
	if(listen_result ==-1)
	{
		perror("listen");
		exit(1);
	}

	//等待连接
	while(1)
	{
		sin_size = sizeof(struct sockaddr_in);

		printf("server is run.\n");
		//如果建立连接,将产生一个全新的套接字
		if((new_fd = accept(sockfd,(struct sockaddr *)&their_addr,&sin_size))==-1)
		{
			perror("accept");
			exit(1);
		}
		printf("accept success.\n");
		//生成一个子进程来完成和客户端的会话,父进程继续监听
		if(!fork())
		{
			printf("create new thred success.\n");
			//读取客户端发来的信息
			int numbytes;
			char buff[256];
			memset(buff,0,256);
			if((numbytes = recv(new_fd,buff,sizeof(buff),0))==-1)
			{
			perror("recv");
			exit(1);
			}
			printf("%s",buff);
			//将从客户端接收到的信息再发回客户端
			if(send(new_fd,buff,strlen(buff),0)==-1)
				perror("send");
			close(new_fd);
			exit(0);
		}
		close(new_fd);
	}
	close(sockfd);
}

其中对 listen() 函数的调用采用了内嵌汇编指令的形式,即:

        asm volatile(
            "movl $0xa,%%edi\n\t"    //listen函数的第二个参数
            "movl %1,%%edi\n\t"      //listen函数的第一个参数
            "movl $0x32,%%eax\n\t"   //将系统调用号50存入eax寄存器
            "syscall\n\t"
            "movq %%rax,%0\n\t"
            :"=m"(listen_result)
            :"g"(sockfd)
        );

 asm volatile 内联汇编格式

            asm volatile(

                 "Instruction List"

                 : Output

                 : Input

                 : Clobber/Modify

              );

a. asm 用来声明一个内联汇编表达式,任何内联汇编表达式都是以它开头,必不可少。

b. volatile 是可选的,如果选用,则向GCC声明不对该内联汇编进行优化。

c. Instruction List 是汇编指令序列,如果有多条指令时:

    可以将多条指令放在一队引号中,用 ; 或者 \n 将它们分开;

    也可以一条指令放在一对引号中,每条指令一行。

d. Output 用来指定内联汇编语句的输出,相当于系统函数的返回值,格式为:

    "=a"(initval)

e. Input 用来指定当前内联汇编语句的输入,相当于系统函数的参数(当该参数为使用C语言的变量的值时,采用这种方法),格式为:

    "constraint(variable)"

 

 

可以看到,如果使用库函数触发函数调用的话,应该是被注释掉的语句:

        listen_result = listen(sockfd,10);

该函数有两个参数,分别是变量 sockfd 和 常量10,返回值为 listen_result,按照上述规定完成汇编指令触发系统调用。

 

(2)新建客户端程序:client.c

#include 
#include 

#include 
#include 
#include 

#include 

int main(int argc,char *argv[])
{

	int sockfd,numbytes;
 	char buf[100];

	struct sockaddr_in their_addr;
//建立一个TCP套接口 if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1) { perror("socket"); printf("create socket error.建立一个TCP套接口失败"); exit(1); } //初始化结构体,连接到服务器的2323端口 their_addr.sin_family = AF_INET; their_addr.sin_port = htons(2328); // their_addr.sin_addr = *((struct in_addr *)he->h_addr); inet_aton( "127.0.0.1", &their_addr.sin_addr ); bzero(&(their_addr.sin_zero),8); //和服务器建立连接 if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1) { perror("connect"); exit(1); } //向服务器发送数据 if(send(sockfd,"hello!socket.",6,0)==-1) { perror("send"); exit(1); } //接受从服务器返回的信息 if((numbytes = recv(sockfd,buf,100,0))==-1) { perror("recv"); exit(1); } buf[numbytes] = '/0'; printf("Recive from server:%s",buf); //关闭socket close(sockfd); return 0; }

 

(3)对两个程序分别编译、链接

a. 代码如下:

gcc -o server server.c -static
gcc -o client client.c  -static

格式:gcc -o file file.c

将文件 file.c 编译成可执行文件 file

参数 -static:强制使用静态库链接

参数 -m32:在64位机器上输出32位代码时,需要加上 -32

b. 结果如下:

执行代码前:

 

可以看出文件夹中目前只有 server.c 和 client.c。

执行代码后:

发现文件夹中已经生成了我们想要的可执行文件 server 和 client。

 

(4)执行可执行文件

a. 启动 server,表明服务器端启动

代码如下:

sudo  ./server

服务器端启动,结果如下:

可以看到输出 “listen is being called”,表明我们想要调用的系统函数 listen() 已经被成功触发,即系统调用成功。

此时服务器端就等待客户端与其建立链接并通信。

b. 再启动一个终端充当客户端,在该终端中启动 client,表明客户端启动

代码如下:

sudo ./client

客户端启动,结果如下:

 

可以看到客户端的终端输出 ”Recive from server:hello!0",表明客户端与服务器端已成功建立连接,并且客户端收到了服务器端发回的信息。

c. 此时,服务器端的信息为:

服务器端继续 listen 来自客户端的信息。

如果我们再在另外一个终端内使用 sudo ./client 启动一个客户端,服务器端也会有相应启动成功的信息生成:

 

三、通过gdb跟踪该系统调用的内核处理过程

1、环境配置

(1)安装开发工具

sudo apt install build-essential
sudo apt install qemu # install QEMU
sudo apt install libncurses5-dev bison flex libssl-dev libelf-dev
sudo apt install axel

以上工具在第一次实验时已经进行了安装。

(2)下载内核源代码

 

axel -n 20 https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.4.34.tar.xz
xz -d linux-5.4.34.tar.xz
tar -xvf linux-5.4.34.tar
cd linux-5.4.34

 

(3)配置内核选项

 

make defconfig # Default configuration is based on 'x86_64_defconfig'
make menuconfig
# 打开debug相关选项
Kernel hacking --->
    Compile-time checks and compiler options --->
        [*] Compile the kernel with debug info
        [*] Provide GDB scripts for kernel debugging
    [*] Kernel debugging
# 关闭KASLR,否则会导致打断点失败
Processor type and features ---->
    [] Randomize the address of the kernel image (KASLR)

 

(4)编译内核

 

make -j$(nproc) # nproc gives the number of CPU cores/threads available

 

(5)启动qemu

 

#测试⼀下内核能不能正常加载运⾏,因为没有⽂件系统最终会kernel panic
qemu-system-x86_64 -kernel arch/x86/boot/bzImage

 

(6)制作内存根文件系统

a. 下载解压:

axel -n 20 https://busybox.net/downloads/busybox-1.31.1.tar.bz2
tar -jxvf busybox-1.31.1.tar.bz2
cd busybox-1.31.1

b. 配置编译、安装:

 

make menuconfig
#记得要编译成静态链接,不⽤动态链接库。
Settings --->
    [*] Build static binary (no shared libs)
#然后编译安装,默认会安装到源码⽬录下的 _install ⽬录中。
make -j$(nproc) && make install

 

c. 制作内存根文件系统镜像:

在 linux-5.4.34 目录下创建 rootfs 文件夹

 

mkdir rootfs
cd rootfs
cp ../busybox-1.31.1/_install/* ./ -rf
mkdir dev proc sys home
sudo cp -a /dev/{null,console,tty,tty1,tty2,tty3,tty4} dev/

 

d. 准备 init 脚本文件放在根文件系统根目录下(rootfs/init):

新建名为 init 的文档文件,添加如下内容到init文件

#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
echo "Wellcome Liu JianingOS!"
echo "--------------------"
cd home
/bin/sh

    给init脚本添加可执行权限

 

chmod +x init

 

e. 打包成内存根文件系统镜像

find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../rootfs.cpio.gz

f. 测试挂在根文件系统,看内核启动完成后是否执行 init 脚本

返回到 linux-5.4.34目录下,启动qemu

qemu-system-x86_64 -kernel arch/x86/boot/bzImage -initrd rootfs.cpio.gz

结果如下:

说明 init 脚本被执行。

 

2、跟踪调试 Linux 内核

(1)根据第二部分的内容编写利用汇编指令触发系统调用的代码

在 rootfs/home 目录下分别创建两个名为 server.c 和 client.c 的文件,并存入第二部分相应的代码。

(2)使用 gcc 编译成可执行文件 server 和 client

 

gcc -o server server.c -static
gcc -o client client.c -static

 

  

 

(3)重新打包内存根文件系统镜像

 

find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../rootfs.cpio.gz

 

(4)使用 gdb 跟踪调试

方法:

使用 gdb 跟踪调试内核时,在启动 qemu 命令上添加两个参数:

a. -s

作用:

  • 在TCP 1234 端口上创建了一个 gdb-server(如果不想使用1234端口,可以用 -gdb tcp:xxxx 来替代 -s 选项)
  • 打开另外一个窗口,用 gdb 把带符号表的内核镜像 vmlinux 加载进来
  • 然后连接 gdb server,设置断点跟踪内核

b. -S

作用:

  • 表示启动时暂停虚拟机,等待 gdb 执行 continue 指令(可以简写为c)。

步骤:

a. 使用纯命令行启动 qemu

 

qemu-system-x86_64 -kernel arch/x86/boot/bzImage -initrd rootfs.cpio.gz -S -s -nographic -append "console=ttyS0"

 

用该命令启动qemu,可以看到虚拟机一启动就暂停了,终端停留在下面的界面:

  

 

参数:-nographic -append "console=ttyS0" 

启动时不会弹出 qemu 虚拟机窗口,可以在纯命令行下启动虚拟机。

【可以通过 killall qemu-system-x86_64 命令强制关闭虚拟机】

b. 在打开一个终端窗口,进入 linux-5.4.34 目录下,加载内核镜像:

 

gdb vmlinux

 

  

 

 

c. 连接 gdb server,即在 gdb 中运行下方代码:

 

(gdb) target remote:1234

 

  

 

d. 给文章中使用的系统调用设置断点

方法:

(gdb) b 系统调用函数名

上文可知,我选择的系统调用函数为 listen(),具体信息如下:

代码如下:

(gdb) b __x64_sys_listen

e. 输入 (gdb) c 指令继续运行程序

此时,第一个打开的终端的内容为:

f. 运行编译好的可执行代码 server,使用 gdb 进行单步调试

在第一个终端中输入如下代码:

/home # ls
/home # ./server

此时第二个终端内容为:

在第二个终端中输入:

 

(gdb) n

 

结果为: 

 

报错:

GDB 远程调试错误:Remote 'g' packet reply is too long

解决方法:

重新下载 gdb,并修改其中 remote.c 文件内容

由 http://ftp.gnu.org/gnu/gdb/ 下载 gdb的较新版本,此处我下载的是 gdb-7.8.tar.gz,并将其放在了 /home/linux 目录下

进入 /home/linux 目录下,对该文件进行解压缩

tar zxvf gdb-7.8.tar.gz

修改 gdb-7.8/gdb 目录下的 remote.c 文件内容:

 

 

将如上图所以的两行原有代码注释掉,然后添加如下的代码:
if (buf_len > 2 * rsa->sizeof_g_packet) {  
      rsa->sizeof_g_packet = buf_len ;  
      for (i = 0; i < gdbarch_num_regs (gdbarch); i++)  
      {  
         if (rsa->regs->pnum == -1)  
         continue;  
  
         if (rsa->regs->offset >= rsa->sizeof_g_packet)  
         rsa->regs->in_g_packet = 0;  
         else  
         rsa->regs->in_g_packet = 1;  
      }  
}  

在 gdb-7.8 目录下执行以下命令安装 gdb:

./configure
make
make install

至此,我们再重复上述步骤就可以使用 gdb 对程序设置断点,并且进行单步调试。

(5)使用 gdb 对程序进行单步调试

gdb操作指令:

(gdb) l       查看代码情况
(gdb) n      单步执行
(gdb) step  进入函数内部
(gdb) bt     查看堆栈

重新安装并调整 gdb 之后,按照步骤(4)中的 a - f 依次执行。

a. 当第一个终端运行可执行文件server之后,即:

/home # ./server

第二个终端内容为:

可以看出断点位置。

b. 查看堆栈信息

在第二个终端中输入命令:

 

(gdb) bt

 

查看当前堆栈信息,如下所示:

 

c. 单步调试

在第二个终端输入如下命令,进行单步调试:

 

(gdb) n

 

结果如下:

 

 

 

 

 

四、分析总结

1、使用 (gdb) bt 查看当前堆栈情况

根据结果显示,函数调用可以分为4层:

顶层: __x64_sys_listen       作用:开放给用户态使用的系统调用函数接口

第二层:do_syscall_64       作用:获取系统调用号,从而调用系统函数

第三层:entry_syscall_64   作用:保存现场工作,调用第二层的 do_syscall_64

第四层:操作系统

 

2、根据单步调试结果从顶层往下依次查看

(1)断点定位

 

 

 断点定位为:

/home/linux/linux-5.4.34/net/socket.c 1688

执行以下代码,前往相应位置查看:

cd linux/linux-5.4.34/net
cat -n socket.c

结果为:

 

 

 进入  __sys_listen(fd, backlog) 函数查看:

int __sys_listen(int fd, int backlog)
{
    struct socket *sock;
    int err, fput_needed;
    int somaxconn;

    sock = sockfd_lookup_light(fd, &err, &fput_needed);
    if (sock) {
        somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
        if ((unsigned int)backlog > somaxconn)
            backlog = somaxconn;

        err = security_socket_listen(sock, backlog);
        if (!err)
            err = sock->ops->listen(sock, backlog);

        fput_light(sock->file, fput_needed);
    }
    return err;
}

(2)执行 do_syscall_64 函数

 

 

 该函数定位在:

/home/linux/linux-5.4.34/arch/x86/entry/common.c 的第300行

 

 

 (3)执行 entry_SYSCALL_64 函数

 

 

 该函数定位在:

/home/linux/linux-5.4.34/arch/x86/entry/entry_64.S 的第184行

 

3、系统调用总结

(1)用户态的程序代码 server.c 中的内嵌汇编指令 syscall 触发系统调用

 

 

 (2)通过 MSR 寄存器找到函数入口

中断函数入口为:

/home/linux/linux/-5.4.34/arch/entry/entry_64.S 第145行 ENTRY(entry_SYSCALL_64) 函数,这个函数为 x86_64 系统进行系统调用的通用入口。

ENTRY函数如下:

 

 

 a. swapgs

使用 swapgs 指令和 下面一系列的压栈动作来保存现场。

b. call do_syscall_64

调用 do_syscall_64 查找系统调用表,获得所要使用的系统调用号。

(3)跳转执行 do_syscall_64

跳转到 /home/linux/linux-5.4.34/x86/entry/common.c 下的 do_system_64函数

 

a. regs->ax = sys_call_table[nr](regs)

从系统调用表中获得系统调用号,并将其存在到 ax 寄存器中,然后去执行系统调用函数。

b. syscall_return_slowpath(regs)

用于系统调用函数执行结束后,恢复现场

(4)跳转执行系统系统函数 listen

 

 

 

跳转到 /home/linux/linux-5.4.34/net/socket.c 函数,开始执行函数;

(5)恢复现场

函数执行完成后,需要进行现场恢复,因此再次回到:

/home/linux/linux/-5.4.34/arch/x86/entry/entry_64.S 

进行现场的恢复。

至此,整个系统调用完成。

 

参考文章:

https://blog.csdn.net/u013920085/article/details/20574249

https://blog.csdn.net/yangbodong22011/article/details/60399728

https://blog.csdn.net/barry283049/article/details/42970739

文章来源: www.cnblogs.com,作者:,版权归原作者所有,如需转载,请联系作者。

原文链接:https://www.cnblogs.com/liujianing0421/p/12971722.html

登录后可下载附件,请登录或者注册

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:huaweicloud.bbs@huawei.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
评论文章 //点赞 收藏 0
点赞
分享文章到微博
分享文章到朋友圈

评论 (0)


0/1000
评论

登录后可评论,请 登录注册

评论

您还没有写博客的权限!

温馨提示

您确认删除评论吗?

确定
取消
温馨提示

您确认删除评论吗?

删除操作无法恢复,请谨慎操作。

确定
取消
温馨提示

您确认删除博客吗?

确定
取消

确认删除

您确认删除博客吗?

确认删除

您确认删除评论吗?

温馨提示

登录超时或用户已下线,请重新登录!!!

确定
取消