Socket与系统调用深度分析

本实验讲述的是一个简单的socket网络应用程序，如何一步步的执行到内核。基于这个实验，来大概分析一下，socket网络程序从用户态到内核态的流程。

 

实验环境是ubuntu18.04，但是用qemu加载linux-5.0.1内核，内核配置是采用x86_64defconfig，并分别制作简易的32位menusOS和64位menuOS，用gdb跟踪内核代码，看看执行过程是怎样的。

 

我们从上层到下层来看：

一、应用层

menuOS是一个简单的菜单系统，里面加入了简单网络应用，我们主要跟踪网络应用程序。首先来看一下简单网络程序代码：

完整代码在这，可以下载下来看看

https://github.com/mengning/menu.git

本实验用的是lab3代码。

下面来简单看下网络程序代码

int main()
{
    BringUpNetInterface();
    PrintMenuOS();
    SetPrompt("MenuOS>>");
    MenuConfig("version","MenuOS V1.0(Based on Linux 3.18.6)",NULL);
    MenuConfig("quit","Quit from MenuOS",Quit);
    MenuConfig("replyhi", "Reply hi TCP Service", StartReplyhi);
    MenuConfig("hello", "Hello TCP Client", Hello);
    ExecuteMenu();
}

int Replyhi()
{
    char szBuf[MAX_BUF_LEN] = "\0";
    char szReplyMsg[MAX_BUF_LEN] = "hi\0";
    InitializeService();
    while (1)
    {
        ServiceStart();
        RecvMsg(szBuf);
        SendMsg(szReplyMsg);
        ServiceStop();
    }
    ShutdownService();
    return 0;
}

int StartReplyhi(int argc, char *argv[])
{
    int pid;
    /* fork another process */
    pid = fork();
    if (pid < 0)
    {
        /* error occurred */
        fprintf(stderr, "Fork Failed!");
        exit(-1);
    }
    else if (pid == 0)
    {
        /*     child process     */
        Replyhi();
        printf("Reply hi TCP Service Started!\n");
    }
    else
    {
        /*     parent process     */
        printf("Please input hello...\n");
    }
}

int Hello(int argc, char *argv[])
{
    char szBuf[MAX_BUF_LEN] = "\0";
    char szMsg[MAX_BUF_LEN] = "hello\0";
    OpenRemoteService();
    SendMsg(szMsg);
    RecvMsg(szBuf);
    CloseRemoteService();
    return 0;
}

#define PrepareSocket(addr,port)                        \
        int sockfd = -1;                                \
        struct sockaddr_in serveraddr;                  \
        struct sockaddr_in clientaddr;                  \
        socklen_t addr_len = sizeof(struct sockaddr);   \
        serveraddr.sin_family = AF_INET;                \
        serveraddr.sin_port = htons(port);              \
        serveraddr.sin_addr.s_addr = inet_addr(addr);   \
        memset(&serveraddr.sin_zero, 0, 8);             \
        sockfd = socket(PF_INET,SOCK_STREAM,0);
        
#define InitServer()                                    \
        int ret = bind( sockfd,                         \
                        (struct sockaddr *)&serveraddr, \
                        sizeof(struct sockaddr));       \
        if(ret == -1)                                   \
        {                                               \
            fprintf(stderr,"Bind Error,%s:%d\n",        \
                            __FILE__,__LINE__);         \
            close(sockfd);                              \
            return -1;                                  \
        }                                               \
        listen(sockfd,MAX_CONNECT_QUEUE); 

#define InitClient()                                    \
        int ret = connect(sockfd,                       \
            (struct sockaddr *)&serveraddr,             \
            sizeof(struct sockaddr));                   \
        if(ret == -1)                                   \
        {                                               \
            fprintf(stderr,"Connect Error,%s:%d\n",     \
                __FILE__,__LINE__);                     \
            return -1;                                  \
        }
/* public macro */               
#define InitializeService()                             \
        PrepareSocket(IP_ADDR,PORT);                    \
        InitServer();
        
#define ShutdownService()                               \
        close(sockfd);
         
#define OpenRemoteService()                             \
        PrepareSocket(IP_ADDR,PORT);                    \
        InitClient();                                   \
        int newfd = sockfd;
        
#define CloseRemoteService()                            \
        close(sockfd); 
              
#define ServiceStart()                                  \
        int newfd = accept( sockfd,                     \
                    (struct sockaddr *)&clientaddr,     \
                    &addr_len);                         \
        if(newfd == -1)                                 \
        {                                               \
            fprintf(stderr,"Accept Error,%s:%d\n",      \
                            __FILE__,__LINE__);         \
        }        
#define ServiceStop()                                   \
        close(newfd);
        
#define RecvMsg(buf)                                    \
       ret = recv(newfd,buf,MAX_BUF_LEN,0);             \
       if(ret > 0)                                      \
       {                                                \
            printf("recv \"%s\" from %s:%d\n",          \
            buf,                                        \
            (char*)inet_ntoa(clientaddr.sin_addr),      \
            ntohs(clientaddr.sin_port));                \
       }
       
#define SendMsg(buf)                                    \
        ret = send(newfd,buf,strlen(buf),0);            \
        if(ret > 0)                                     \
        {                                               \
            printf("send \"hi\" to %s:%d\n",            \
            (char*)inet_ntoa(clientaddr.sin_addr),      \
            ntohs(clientaddr.sin_port));                \
        }

上面其实就是一个简单的TCP网络程序，实现的是一个Hello/hi的功能，当在命令行输入replyhi，hello，会执行相关socketAPI接口，主要就是socket，bind，listen，accept，send，recv，connect，close这几个函数。

应用层写的socke函数，先是调用了libc库中对应的函数，32位libc库中对应函数有一句汇编指令 int $0x80，这是陷入内核的指令，0x80是系统调用的中断号，64位libc库中对应函数的汇编指令是system_call，我们都来跑一下。

 

先不用qemu加载内核，先在ubuntu上用gdb跟踪一下程序在应用层如何陷入内核。

为了简单，我们不修改Makefile，直接编译，先来编译成32位程序，如下：

gcc -o main *.c -g -m32 -lpthread -static
gdb main

 

先在ubuntu上调试main函数，跟踪由应用层陷入内核过程。

先在socket加断点，然后打开汇编代码窗口，逐步跟踪汇编，一直输入si，直到出现int $0x80

 

 

再来看下本机ubuntu的内核版本

这就说明了32位程序在64位内核版本下陷入内核的指令是int $0x80

 

下面来看一下64位程序在64位内核版本下陷入内核的指令是什么？

只需要将编译命令改一下

gcc -o main *.c -g -m64 -lpthread -static
gdb main

 

其他步骤一致，结果如下

64位程序陷入内核的汇编指令是syscall。

 

二、内核处理过程

接下来跟踪内核，跟踪socket，bind，listen等函数对应的内核处理函数是什么？

同样，分别跟踪32位应用程序和64位程序分别对应的内核处理函数。

首先来跟踪32位应用程序对应的内核处理函数。

make rootfs
cd ..
qemu-system-x86_64 -kernel ../linux-5.0.1/arch/x86_64/boot/bzImage -initrd rootfs.img -append "root=/dev/sda init=/init nokaslr" -s -S

 

 

 再打开一个终端，进入linux-5.0.1目录

gdb
file vmlinux
target remote:1234

 

 

 查看32位系统调用列表

 

 

b sys_socketcall

 提示未定义，于是尝试下后面的函数名，看意思是兼容32的socket函数。

__ia32_compat_sys_socketcall

 接下来，输入c

 

过程中提示遇到断点，输入c，或者等到MenuOS启动再加断点也可以。

我们在MenuOS输入replyhi

replyhi

 

 查看net/compat.c源码

 

 找到处理各种socket接口代码，再加个断点，加在859行，然后看看调用了哪些接口

 说明首先调用的是__sys_socket函数

 

 接着又调用__sys_bind函数

 

 接着又调用__sys_listen，后面的跟踪方法类似，并且跟应用代码调用顺序保持一致。

 

下面再来看下，64位应用程序socket API对应的内核处理函数是什么？

查看64位系统调用列表

 

 

 重新制作rootfs，修改Makefile，生成64位的MenuOS

#
# Makefile for linuxnet/lab3
#

CC_PTHREAD_FLAGS             = -lpthread
CC_FLAGS                     = -c 
CC_OUTPUT_FLAGS                 = -o
CC                           = gcc
RM                           = rm
RM_FLAGS                     = -f

TARGET  =   main
OBJS    =   linktable.o  menu.o main.o

all:    $(OBJS)
    $(CC) $(CC_OUTPUT_FLAGS) $(TARGET) $(OBJS) 
rootfs:
    gcc -o init linktable.c menu.c main.c -m64 -static -lpthread #将-m32改成-m64
    find init | cpio -o -Hnewc |gzip -9 > ../rootfs.img
    #qemu-system-x86_64 -kernel ../../linux-5.0.1/arch/x86/boot/bzImage -initrd ../rootfs.img
.c.o:
    $(CC) $(CC_FLAGS) $<

clean:
    $(RM) $(RM_FLAGS)  $(OBJS) $(TARGET) *.bak init

make rootfs
cd ..
qemu-system-x86_64 -kernel ../linux-5.0.1/arch/x86/boot/bzImage -initrd rootfs.img -append "root=/dev/sda init=/init nokaslr" -s -S

 

其他操作基本一致，还在另外一个终端输入同样的命令

file vmlinux
target remote:1234
c

然后 Ctrl+C中断，进入gdb

按照64位系统调用列表，在__x64_sys_socket，__x64_sys_bind，__x64_sys_listen等函数加断点

b __x64_sys_socket
b __x64_sys_bind
b __x64_sys_listen
b __x64_sys_accept
b __x64_sys_sendmsg
b __x64_sys_recvmsg
c

 

然后在MenuOS里输入replyhi，在gdb调试窗口输入c

 

 

 

 

 

 但是却没有在__x64_sys_sendmsg和__x64_sys_recvmsg停止，猜测可能内核读写调的不是这两个函数，于是在__x64_sys_read和__x64_sys_write两个函数加断点，再跟踪看看

b __x64_sys_read
b __x64_sys_write

 

 

 结果在__x64_sys_read和__x64_sys_write停止了，说明recv和send对应的内核函数是__x64_sys_read和__x64_sys_write。

这样对32位和64位应用程序在64位内核上，从应用层陷入内核，以及socket相关API对应的内核处理函数都跟踪完了。

 

 接下来来看一下稍微深层的函数

 

 由代码可知，应用层的socket，bind，listen等函数，在内核中对应的函数是__sys_socket，__sys_bind，__sys_listen等函数，再来看看__sys_socket，__sys_bind，__sys_listen这三个函数的定义，在socket.c文件里定义了

 

 

 

 

 

由代码可以看出，在__sys_socket函数中，根据参数初始化了sock结构体，在__sys_bind和__sys_listen等函数中调用了sock->ops->bind函数和sock->op->listen函数。

 

可以看出这是多态，在__sys_socket函数中根据输入参数初始化了sock结构体，然后在__sys_bind和__sys_listen函数里调用sock->ops->bind和sock->ops->listen函数，这是内核处理函数内部通过“多态机制”对不同的网络协议进行的封装方法。

 

以上就是简述一下socketAPI调用流程的大致过程，都是手敲，如有错误还请指教！