Socket与系统调用深度分析

Socket与系统调用深度分析

〇，linux系统调用

　　本次实验的主要内容是从socket接口入手，通过跟踪相关函数在内核中的运行过程了解socket相关的系统调用是如何工作的。那么首当其冲需要解决的问题就是，什么是系统调用？socket等程序接口又是如何使用系统调用来实现自身功能的呢？

　　但凡学过操作系统的人都不难理解，操作系统分为用户态和内核态，应用程序一般工作在用户态，而操作系统则通过系统调用为工作在其上的进程提供服务：

　　

 　　正如上图所示，运行在用户态的函数xyz()通过中断进入内核态，再通过系统调用处理函数调用相关的服务历程。

一，分析用户函数

　　要分析socket接口与系统调用之间的关系，首先就要找出socket究竟调用了哪些系统调用。根据上一小节的内容，我们可以从对应的函数入手，找出相应的系统调用。

　　打开lab3中的main.c文件，在main函数中找到如下代码：

    MenuConfig("replyhi", "Reply hi TCP Service", StartReplyhi);
    MenuConfig("hello", "Hello TCP Client", Hello);

　　按照函数调用的关系依次查找，如StartReplyhi（）到Replyhi再到syswrapper.h中，找到如下代码：

#include<arpa/inet.h> /* internet socket */

/**/

#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
",        
                            __FILE__,__LINE__);         
            close(sockfd);                              
            return -1;                                  
        }                                               
        listen(sockfd,MAX_CONNECT_QUEUE); 

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

　　至此我们已经找到了如socket()，listen()，bind()以及close()等几个函数，通过结合linux系统调用表（https://github.com/mengning/linux/blob/master/arch/x86/entry/syscalls/syscall_32.tbl）和其他网上资料，我们可以发现Linux 内核为所有与 socket 有关的操作提供了一个统一的系统调用入口，但是在用户程序界面上则通过 C 语言程序库 c.lib 提供诸多库函数，看起来好像都是独立的系统调用一样。内核中为 socket 设置的总入口为 sys_socketcall()，其代码在 net/socket.c 中，而该函数实际上则调用的是SYSCALL_DEFINE2：

 1 /*与socket相关的系统调用总入口。 */
 2 /*
 3 *函数的第一个参数 call 即为具体的操作码，而参数 args 为指向一个数组的指针，可以根据具体操作码的不同，确定从用户空间复制参数的数量；
 4 */
 5 asmlinkage long sys_socketcall(int call, unsigned long __user *args)
 6 {
 7     unsigned long a[6];
 8     unsigned long a0,a1;
 9     int err;
10 
11     if(call<1||call>SYS_RECVMSG)
12         return -EINVAL;
13 
14     /* copy_from_user should be SMP safe. */
15     if (copy_from_user(a, args, nargs[call]))
16         return -EFAULT;
17 
18     a0=a[0];
19     a1=a[1];
20 
21     switch(call) 
22     {
23         case SYS_SOCKET:
24             err = sys_socket(a0,a1,a[2]);
25             break;
26         case SYS_BIND:
27             err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);
28             break;
29         case SYS_CONNECT:
30             err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
31             break;
32         case SYS_LISTEN:
33             err = sys_listen(a0,a1);
34             break;
35         case SYS_ACCEPT:
36             err = sys_accept(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
37             break;
38         case SYS_GETSOCKNAME:
39             err = sys_getsockname(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
40             break;
41         case SYS_GETPEERNAME:
42             err = sys_getpeername(a0, (struct sockaddr __user *)a1, (int __user *)a[2]);
43             break;
44         case SYS_SOCKETPAIR:
45             err = sys_socketpair(a0,a1, a[2], (int __user *)a[3]);
46             break;
47         case SYS_SEND:
48             err = sys_send(a0, (void __user *)a1, a[2], a[3]);
49             break;
50         case SYS_SENDTO:
51             err = sys_sendto(a0,(void __user *)a1, a[2], a[3],
52                      (struct sockaddr __user *)a[4], a[5]);
53             break;
54         case SYS_RECV:
55             err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
56             break;
57         case SYS_RECVFROM:
58             err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
59                        (struct sockaddr __user *)a[4], (int __user *)a[5]);
60             break;
61         case SYS_SHUTDOWN:
62             err = sys_shutdown(a0,a1);
63             break;
64         case SYS_SETSOCKOPT:
65             err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
66             break;
67         case SYS_GETSOCKOPT:
68             err = sys_getsockopt(a0, a1, a[2], (char __user *)a[3], (int __user *)a[4]);
69             break;
70         case SYS_SENDMSG:
71             err = sys_sendmsg(a0, (struct msghdr __user *) a1, a[2]);
72             break;
73         case SYS_RECVMSG:
74             err = sys_recvmsg(a0, (struct msghdr __user *) a1, a[2]);
75             break;
76         default:
77             err = -EINVAL;
78             break;
79     }
80     return err;

　　通过解读上述代码并对照相关的系统调用标，我们似乎已经找到了相关代码的系统调用入口，接下来我们可以通过gdb来验证我们的猜想。

二，跟踪系统调用

　　在gdb中，对sys_socketcall,sys_bind,sys_listen设置断点，并跟踪，结果如下：

　　上图的结果在两点上不符合我们的预期或者说值得探究：一，对与sys_bind和sys_listen的跟踪没有反馈；二，sys_socketcall在启动qemu是即被调用，且每次的调用次数（即call的值）又代表什么。

　　针对第一个问题，我们注意到每次跟踪sys_socketcall时，都会定位到这样一个函数即SYSCALL_DEFINE2()

通过查阅资料可知，实际上对sys_socketcall的调用是通过该函数实现的，而该函数的代码如下：

  1 SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
  2 {
  3     unsigned long a[AUDITSC_ARGS];
  4     unsigned long a0, a1;
  5     int err;
  6     unsigned int len;
  7 
  8     if (call < 1 || call > SYS_SENDMMSG)
  9         return -EINVAL;
 10     call = array_index_nospec(call, SYS_SENDMMSG + 1);
 11 
 12     len = nargs[call];
 13     if (len > sizeof(a))
 14         return -EINVAL;
 15 
 16     /* copy_from_user should be SMP safe. */
 17     if (copy_from_user(a, args, len))
 18         return -EFAULT;
 19 
 20     err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
 21     if (err)
 22         return err;
 23 
 24     a0 = a[0];
 25     a1 = a[1];
 26 
 27     switch (call) {
 28     case SYS_SOCKET:
 29         err = __sys_socket(a0, a1, a[2]);
 30         break;
 31     case SYS_BIND:
 32         err = __sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
 33         break;
 34     case SYS_CONNECT:
 35         err = __sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
 36         break;
 37     case SYS_LISTEN:
 38         err = __sys_listen(a0, a1);
 39         break;
 40     case SYS_ACCEPT:
 41         err = __sys_accept4(a0, (struct sockaddr __user *)a1,
 42                     (int __user *)a[2], 0);
 43         break;
 44     case SYS_GETSOCKNAME:
 45         err =
 46             __sys_getsockname(a0, (struct sockaddr __user *)a1,
 47                       (int __user *)a[2]);
 48         break;
 49     case SYS_GETPEERNAME:
 50         err =
 51             __sys_getpeername(a0, (struct sockaddr __user *)a1,
 52                       (int __user *)a[2]);
 53         break;
 54     case SYS_SOCKETPAIR:
 55         err = __sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
 56         break;
 57     case SYS_SEND:
 58         err = __sys_sendto(a0, (void __user *)a1, a[2], a[3],
 59                    NULL, 0);
 60         break;
 61     case SYS_SENDTO:
 62         err = __sys_sendto(a0, (void __user *)a1, a[2], a[3],
 63                    (struct sockaddr __user *)a[4], a[5]);
 64         break;
 65     case SYS_RECV:
 66         err = __sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
 67                      NULL, NULL);
 68         break;
 69     case SYS_RECVFROM:
 70         err = __sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
 71                      (struct sockaddr __user *)a[4],
 72                      (int __user *)a[5]);
 73         break;
 74     case SYS_SHUTDOWN:
 75         err = __sys_shutdown(a0, a1);
 76         break;
 77     case SYS_SETSOCKOPT:
 78         err = __sys_setsockopt(a0, a1, a[2], (char __user *)a[3],
 79                        a[4]);
 80         break;
 81     case SYS_GETSOCKOPT:
 82         err =
 83             __sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
 84                      (int __user *)a[4]);
 85         break;
 86     case SYS_SENDMSG:
 87         err = __sys_sendmsg(a0, (struct user_msghdr __user *)a1,
 88                     a[2], true);
 89         break;
 90     case SYS_SENDMMSG:
 91         err = __sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2],
 92                      a[3], true);
 93         break;
 94     case SYS_RECVMSG:
 95         err = __sys_recvmsg(a0, (struct user_msghdr __user *)a1,
 96                     a[2], true);
 97         break;
 98     case SYS_RECVMMSG:
 99         if (IS_ENABLED(CONFIG_64BIT) || !IS_ENABLED(CONFIG_64BIT_TIME))
100             err = __sys_recvmmsg(a0, (struct mmsghdr __user *)a1,
101                          a[2], a[3],
102                          (struct __kernel_timespec __user *)a[4],
103                          NULL);
104         else
105             err = __sys_recvmmsg(a0, (struct mmsghdr __user *)a1,
106                          a[2], a[3], NULL,
107                          (struct old_timespec32 __user *)a[4]);
108         break;
109     case SYS_ACCEPT4:
110         err = __sys_accept4(a0, (struct sockaddr __user *)a1,
111                     (int __user *)a[2], a[3]);
112         break;
113     default:
114         err = -EINVAL;
115         break;
116     }
117     return err;
118 }

　　其代码逻辑大致与sys_socket相同，即通过switch分支进入不同的分支处理，而在各个分支处理下，我们不难发现，实际上，系统中真正调用的是形如__sys_listen这样的函数，对于这样的发现，我们同样通过gdb跟踪进行验证。

　　我们首先将涉及到的系统调用都打上断点，接着重复之前的步骤加以跟踪，结果如下：

　　结果证明我们此时的猜想并没有错误，之前的问题也得到解决：涉及到socket的系统调用都使用统一的入口sys_socketcall，再通过SYSCALL_DEFINE2进入不同的分支，调用不同的系统调用，如在本次实验中，就包括sys_socket，sys_bind，sys_listen，sys_connect，sys_accept4等等。

三，函数分析与对不同协议的封装

　　socket接口可以实现对与不同协议的封装，具体这一机制是如何实现的，我们可以通过根据对上文中提到的内核函数进行分析略知一二：

 1 asmlinkage long sys_socket(int family, int type, int protocol)
 2 {
 3     int retval;
 4     struct socket *sock;
 5 
 6     /* 根据协议族、套口类型、传输层协议创建套口 */
 7     retval = sock_create(family, type, protocol, &sock);
 8     if (retval < 0)
 9         goto out;
10 
11     /* 为创建的套接口分配一个文件描述符并进行绑定 */
12     retval = sock_map_fd(sock);
13     if (retval < 0)
14         goto out_release;　　　　/* 根据是否成功帮顶选择是否释放  */
15 
16 out:
17     return retval;
18 
19 out_release:
20     sock_release(sock);
21     return retval;
22 }

　　根据上述代码，我们接着找到sock_creat：

 1 /**
 2  * 创建一个套接口
 3  *  family:     套接口协议族
 4  *  type:       套接口类型
 5  *  protocol:       传输层协议
 6  *  res:            输出参数，创建成功的套接口指针
 7  *  kern:       由内核还是应用程序创建。
 8  */
 9 static int __sock_create(int family, int type, int protocol, struct socket **res, int kern)
10 {
11     int err;
12     struct socket *sock;
13 
14     if (family < 0 || family >= NPROTO)/* 参数合法性检测 */
15         return -EAFNOSUPPORT;
16     if (type < 0 || type >= SOCK_MAX)
17         return -EINVAL;
18     /**
19      * IPV4协议族的SOCK_PACKET类型套接口已经不被支持
20      * 为兼容旧程序，转换为PF_PACKET 
21 */
22     if (family == PF_INET && type == SOCK_PACKET) {
23         static int warned; 
24         if (!warned) {
25             warned = 1;
26             printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)
", current->comm);
27         }
28         family = PF_PACKET;
29     }
30 
31     /* 由安全模块对创建过程进行审计 */
32     err = security_socket_create(family, type, protocol, kern);
33     if (err)
34         return err;
35 
36 #if defined(CONFIG_KMOD)
37     if (net_families[family]==NULL)/* 相应的协议族在内核中尚不存在，加载模块以支持该协议族 */
38     {
39         request_module("net-pf-%d",family);
40     }
41 #endif
42 
43     /* 等待，直到锁被释放 */
44     net_family_read_lock();
45     if (net_families[family] == NULL) {/* 如果协议族仍然不存在，说明不支持此协议族 */
46         err = -EAFNOSUPPORT;
47         goto out;
48     }
49 
50 
51     if (!(sock = sock_alloc())) {/* 分配与inode关联的套接口 */
52         printk(KERN_WARNING "socket: no more sockets
");
53         err = -ENFILE;      
54         goto out;
55     }
56 
57     sock->type  = type;/* 设置套接口类型。 */
58 
59     err = -EAFNOSUPPORT;
60     if (!try_module_get(net_families[family]->owner))/* 增加对协议族模块的引用，如果失败则退出 */
61         goto out_release;
62 
63     /* 调用协议族的创建方法，对IPV4来说，调用的是inet_create */
64     if ((err = net_families[family]->create(sock, protocol)) < 0)
65         goto out_module_put;
66     if (!try_module_get(sock->ops->owner)) {/* 增加传输层模块的引用计数 */
67         sock->ops = NULL;
68         goto out_module_put;
69     }
70     /* 增加了传输层模块的引用计数后，可以释放协议族的模块引用计数 */
71     module_put(net_families[family]->owner);
72     *res = sock;
73     /* 通知安全模块，对创建过程进行检查。 */
74     security_socket_post_create(sock, family, type, protocol, kern);
75 
76 out:
77     net_family_read_unlock();
78     return err;
79 out_module_put:
80     module_put(net_families[family]->owner);
81 out_release:
82     sock_release(sock);
83     goto out;
84 }

　　高亮部分显示，在sock_creat中调用协议族的创建方法创建一个套接口，对IPV4来说，就是调用inet_create。通过这样的方法，实现了对于不同的协议的封装。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/imerliu/p/12060563.html