Linux内核创建socket的过程

当我们调用socket()这个系统调用的时候，Linux内核究竟做了哪些事情呢？
Ok，就让我们来看看这socket背后的故事吧。

1.用户程序首先调用socket()系统调用，其原型为:
int socket(int domain, int type, int protocol)

2.我们调用的socket()系统调用其实是glic这个库提供的，glic内部会执行实际的系统调用。
我们可以看一下glic的内部实现。
文件sysdeps/unix/sysv/linux/i386/socket.S

点击(此处)折叠或打开

1. .globl __socket
   
2. ENTRY (__socket)
   
3. #if defined NEED_CANCELLATION && defined CENABLE
   
4.     SINGLE_THREAD_P
   
5.     jne 1f
   
6. #endif
   
7. 
   
8.     /* 保存ebx寄存器的值 */
   
9.     movl %ebx, %edx
   
10.     cfi_register (3, 2)
11. 
    
12.     /* 把系统调用的调用号放到eax寄存器里 */
13.     movl $SYS_ify(socketcall), %eax
14. 
    
15.     /* 传给syscall的第一个参数是子code，用来识别是哪一个socket系统调用 */
16.     movl $P(SOCKOP_,socket), %ebx
17. 
    
18.     /* 第二个参数是用户态传递的参数数组的地址 */
    
19.     lea 4(%esp), %ecx
    
20. 
    
21.     /* 执行系统调用 */
    
22.     ENTER_KERNEL
    
23. 
    
24.     /* 恢复ebx寄存器 */
    
25.     movl %edx, %ebx
    
26.     cfi_restore (3)
    
27. 
    
28.     /* 如果发生了错误，%eax小于0 */
    
29.     cmpl $-125, %eax
    
30.     jae SYSCALL_ERROR_LABEL
    
31. 
    
32.     /* 成功的话返回系统调用的结果 */
    
33. L(pseudo_end):
    
34.     ret

为了节约系统调用号，在2.4以后的内核中，已经把所有的socket相关的系统调用，比如connect(),send()等等，都统一封装在一个内核函数sys_socketcall()里，执行系统调用的时候，需要传递一个SOCKOP_XXX(sysdeps/unix/sysv/linux/socketcall.h)来识别是哪个socket函数 。

3.当内核收到系统调用的命令以后，会从eax寄存器中取出系统调用号，然后在sys_call_table
这个表中查找对应的处理系统调用的函数 ，具体过程不再赘述。
内核会调用sys_socketcall()来处理 。
文件net/socket.c

点击(此处)折叠或打开

1. asmlinkage long sys_socketcall(int call, unsigned long __user *args)
   
2. {
   
3.     unsigned long a[6];
   
4.     unsigned long a0, a1;
   
5.     int err;
   
6. 
   
7.     if (call < 1 || call > SYS_ACCEPT4)
   
8.         return -EINVAL;
   
9. 
   
10.     /* 调用copy_from_user函数，从用户空间的内存地址拷贝参数到内核空间 */
    
11.     if (copy_from_user(a, args, nargs[call]))
    
12.         return -EFAULT;
    
13. 
    
14.     err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
    
15.     if (err)
    
16.         return err;
    
17. 
    
18.     a0 = a[0];
    
19.     a1 = a[1];
    
20. 
    
21.     switch (call) {
    
22.     case SYS_SOCKET:
    
23.         err = sys_socket(a0, a1, a[2]);
    
24.         break;
    
25.     case SYS_BIND:
    
26.         err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
    
27.         break;
    
28.     case SYS_CONNECT:
    
29.         err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
    
30.         break;
    
31.     case SYS_LISTEN:
    
32.         err = sys_listen(a0, a1);
    
33.         break;
    
34.     case SYS_ACCEPT:
    
35.         err = sys_accept4(a0, (struct sockaddr __user *)a1,
    
36.                  (int __user *)a[2], 0);
    
37.         break;
    
38.     case SYS_GETSOCKNAME:
    
39.         err =
    
40.          sys_getsockname(a0, (struct sockaddr __user *)a1,
    
41.                  (int __user *)a[2]);
    
42.         break;
    
43.     case SYS_GETPEERNAME:
    
44.         err =
    
45.          sys_getpeername(a0, (struct sockaddr __user *)a1,
    
46.                  (int __user *)a[2]);
    
47.         break;
    
48.     case SYS_SOCKETPAIR:
    
49.         err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
    
50.         break;
    
51.     case SYS_SEND:
    
52.         err = sys_send(a0, (void __user *)a1, a[2], a[3]);
    
53.         break;
    
54.     case SYS_SENDTO:
    
55.         err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
    
56.                  (struct sockaddr __user *)a[4], a[5]);
    
57.         break;
    
58.     case SYS_RECV:
    
59.         err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
    
60.         break;
    
61.     case SYS_RECVFROM:
    
62.         err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
    
63.                  (struct sockaddr __user *)a[4],
    
64.                  (int __user *)a[5]);
    
65.         break;
    
66.     case SYS_SHUTDOWN:
    
67.         err = sys_shutdown(a0, a1);
    
68.         break;
    
69.     case SYS_SETSOCKOPT:
    
70.         err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
    
71.         break;
    
72.     case SYS_GETSOCKOPT:
    
73.         err =
    
74.          sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
    
75.                  (int __user *)a[4]);
    
76.         break;
    
77.     case SYS_SENDMSG:
    
78.         err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
    
79.         break;
    
80.     case SYS_RECVMSG:
    
81.         err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
    
82.         break;
    
83.     case SYS_ACCEPT4:
    
84.         err = sys_accept4(a0, (struct sockaddr __user *)a1,
    
85.                  (int __user *)a[2], a[3]);
    
86.         break;
    
87.     default:
    
88.         err = -EINVAL;
    
89.         break;
    
90.     }
    
91.     return err;
    
92. }

可以看到，sys_socketcall会通过call这个参数来判断执行哪个socket动作。
因为我们调用的是socket()系统调用，所以会执行sys_socket()这个函数。

4.内核调用sys_socket()来处理创建socket的系统调用。
文件net/socket.c

点击(此处)折叠或打开

1. asmlinkage long sys_socket(int family, int type, int protocol)
   
2. {
   
3.     int retval;
   
4.     struct socket *sock;
   
5.     int flags;
   
6. 
   
7.     /* Check the SOCK_* constants for consistency. */
   
8.     BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
   
9.     BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
   
10.     BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
    
11.     BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
    
12. 
    
13.     flags = type & ~SOCK_TYPE_MASK;
    
14.     if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
    
15.         return -EINVAL;
    
16.     type &= SOCK_TYPE_MASK;
    
17. 
    
18.     if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
    
19.         flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
    
20. 
    
21.     /* 实际创建socket */
    
22.     retval = sock_create(family, type, protocol, &sock);
    
23.     if (retval < 0)
    
24.         goto out;
    
25. 
    
26.     /* 把创建的socket映射到文件描述符 */
    
27.     retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
    
28.     if (retval < 0)
    
29.         goto out_release;
    
30. 
    
31. out:
    
32.     /* It may be already another descriptor 8) Not kernel problem. */
    
33.     return retval;
    
34. 
    
35. out_release:
    
36.     sock_release(sock);
    
37.     return retval;
    
38. }

可以看到，实际创建socket的函数是sock_create() ,接下来就让我们好好研究一下这个函数。