Socket与系统调用深度分析

1、系统调用

用户态和内核态的区分：

  在 CPU 的所有指令中，有些指令是非常危险的，如果错用，将导致系统崩溃，比如清内存、设置时钟等。如果允许所有的程序都可以使用这些指令，那么系统崩溃的概率将大大增加。所以，CPU 将指令分为特权指令和非特权指令，对于那些危险的指令，只允许操作系统及其相关模块使用，普通应用程序只能使用那些不会造成灾难的指令。比如 Intel 的 CPU 将特权等级分为 4 个级别：Ring0~Ring3。其实 Linux 系统只使用了 Ring0 和 Ring3 两个运行级别(Windows 系统也是一样的)。当进程运行在 Ring3 级别时被称为运行在用户态，而运行在 Ring0 级别时被称为运行在内核态。在内核态下，进程运行在内核地址空间中，此时 CPU 可以执行任何指令。运行的代码也不受任何的限制，可以自由地访问任何有效地址，也可以直接进行端口的访问。

  在用户态下，进程运行在用户地址空间中，被执行的代码要受到 CPU 的诸多检查，它们只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址，且只能对任务状态段(TSS)中 I/O 许可位图(I/O Permission Bitmap)中规定的可访问端口进行直接访问。对 32 位操作系统而言，它的寻址空间（虚拟地址空间，或叫线性地址空间）为 4G（2的32次方）。也就是说一个进程的最大地址空间为 4G。操作系统的核心是内核(kernel)，它独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证内核的安全，现在的操作系统一般都强制用户进程不能直接操作内核。具体的实现方式基本都是由操作系统将虚拟地址空间划分为两部分，一部分为内核空间，另一部分为用户空间。针对 Linux 操作系统而言，最高的 1G 字节(从虚拟地址 0xC0000000 到 0xFFFFFFFF)由内核使用，称为内核空间。而较低的 3G 字节(从虚拟地址 0x00000000 到 0xBFFFFFFF)由各个进程使用，称为用户空间。 

系统调用的意义：

操作系统为用户态进程与硬件设备进行交互提供了一组接口——系统调用:

1.把用户从底层的硬件编程中解放了出来;

2.极大地提高了系统的安全性使用户程序具有可移植性，具体硬件已经被抽象接口所替代。

 

操作系统提供的API和系统调用的关系:

 

 

2、gdb跟踪系统调用

对于socket，所有的socket系统调用的总入口是sys_socketcall()

 

/* net/socket.c */
asmlinkage long sys_socket(int, int, int);
asmlinkage long sys_socketpair(int, int, int, int __user *);
asmlinkage long sys_bind(int, struct sockaddr __user *, int);
asmlinkage long sys_listen(int, int);
asmlinkage long sys_accept(int, struct sockaddr __user *, int __user *);
asmlinkage long sys_connect(int, struct sockaddr __user *, int);
asmlinkage long sys_getsockname(int, struct sockaddr __user *, int __user *);
asmlinkage long sys_getpeername(int, struct sockaddr __user *, int __user *);
asmlinkage long sys_sendto(int, void __user *, size_t, unsigned,
                struct sockaddr __user *, int);
asmlinkage long sys_recvfrom(int, void __user *, size_t, unsigned,
                struct sockaddr __user *, int __user *);
asmlinkage long sys_setsockopt(int fd, int level, int optname,
                char __user *optval, int optlen);
asmlinkage long sys_getsockopt(int fd, int level, int optname,
                char __user *optval, int __user *optlen);
asmlinkage long sys_shutdown(int, int);
asmlinkage long sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
asmlinkage long sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags);

 其中各接口编号如下

#include 
#include 

#define NPROTO        AF_MAX

#define SYS_SOCKET    1        /* sys_socket(2)        */
#define SYS_BIND    2        /* sys_bind(2)            */
#define SYS_CONNECT    3        /* sys_connect(2)        */
#define SYS_LISTEN    4        /* sys_listen(2)        */
#define SYS_ACCEPT    5        /* sys_accept(2)        */
#define SYS_GETSOCKNAME    6        /* sys_getsockname(2)        */
#define SYS_GETPEERNAME    7        /* sys_getpeername(2)        */
#define SYS_SOCKETPAIR    8        /* sys_socketpair(2)        */
#define SYS_SEND    9        /* sys_send(2)            */
#define SYS_RECV    10        /* sys_recv(2)            */
#define SYS_SENDTO    11        /* sys_sendto(2)        */
#define SYS_RECVFROM    12        /* sys_recvfrom(2)        */
#define SYS_SHUTDOWN    13        /* sys_shutdown(2)        */
#define SYS_SETSOCKOPT    14        /* sys_setsockopt(2)        */
#define SYS_GETSOCKOPT    15        /* sys_getsockopt(2)        */
#define SYS_SENDMSG    16        /* sys_sendmsg(2)        */
#define SYS_RECVMSG    17        /* sys_recvmsg(2)        */
#define SYS_ACCEPT4    18        /* sys_accept4(2)        */
#define SYS_RECVMMSG    19        /* sys_recvmmsg(2)        */
#define SYS_SENDMMSG    20        /* sys_sendmmsg(2)        */

 

我们采用gdb跟踪在Menuos下的命令replyhi和hello的具体系统调用过程，首先查看一下replyhi相关代码。

在replyhi函数中，依次调用了InitializeService()、ServiceStart()、RecvMsg()、SendMsg()、ServiceStop()、ShutdownService()函数

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;
}

下面是replyhi调用的InitializeService()函数，其中又调用了PrepareSocket()函数和InitServer()函数，用到了socket()、bind()、listen()接口。

#define InitializeService()                             
        PrepareSocket(IP_ADDR,PORT);                    
        InitServer();

#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)

在下列被调用到的函数中用到了accept()、recv()、send()、close()接口。

#define ServiceStart()                                  
        int newfd = accept( sockfd,                     
                    (struct sockaddr *)&clientaddr,     
                    &addr_len);                         
        {                                               
            fprintf(stderr,"Accept Error,%s:%d\n",      
                            __FILE__,__LINE__);         
        }        

#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));                
        }
#define ServiceStop()                                   
        close(newfd)；
#define ShutdownService()                               
        close(sockfd);
        

至此我们知道了replyhi中所用到的socket中相关的接口

然后看一下hello的相关代码

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 OpenRemoteService() 
PrepareSocket(IP_ADDR,PORT); 
InitClient(); 
int newfd = sockfd;

#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;

}

hello涉及的相关系统调用为 socket，connect，send，recv

 

下面我们通过gdb跟踪其在内核中的系统调用

在Menuos中输入replyhi命令，观察其系统调用

 

 接下来输入hello，观察其系统调用

 

 

通过实验可知，在replyhi中，调用的接口编号call分别为1、2、4、5，分别涉及socket、bind、listen、accept，在hello中，调用的接口编号call分别为1、3、10、9、9、10、5，分别涉及socket、connect、recv、send、send、recv、accept，结果与预想一致，至此完成对replyhi/hello的追踪。