Socket与系统调用深度分析
系统调用
在一开始，应用程序是可以直接控制硬件的，这就需要程序员有很高的编程能力，否则一旦程序出了问题，会将整个系统Crash。
在现在的操作系统中，用户程序运行在用户态，而要进行诸如Socket、磁盘I/O这样的一些操作，这需要切换到内核态，再进行进行相应的操作，而这一过程则是系统调用system call。有了操作系统分离了内核和用户态，应用程序就无法直接进行硬件资源的访问，需要经过系统调用来进行。
每次的系统调用，都会从用户态转换到内核态，运行完任务后，回到用户态。这中间的过程需要上下文切换（保存寄存器信息），也就是切换状态是需要消耗资源和时间的。
Socket
Socket是程序实现端到端通信的地址，互联网中每台设备有自己的IP地址，但每台设备上运行着许多程序。同时不同的程序都可能有通信的需求，这就需要一个套接字(Socket)来区分不同的程序。
一个套接字由IP地址和端口号组成。
IP address: port
实验
开启上次实验编译好的MenuOS系统
上次实验编译了一个带调试功能，且带有TCP服务器和客户端的MenuOS系统
进入LinuxKernel目录，启动虚拟机。
jett@ubuntu:~$ cd LinuxKernel
jett@ubuntu:~/LinuxKernel$ qemu-system-i386 -kernel linux-5.4.2/arch/x86/boot/bzImage -initrd rootfs.img -append "root=/dev/sda init=/init nokaslr" -s -S
进入调试
这时候虚拟机进入停止在一个黑屏界面，等待gdb的接入和下一步指令。
新开一个终端窗口，进入gdb调试。
接着分别
- 导入符号表
- 连接调试服务器
- 设置断点
jett@ubuntu:~/LinuxKernel$ gdb
(gdb) file ~/LinuxKernel/linux-5.4.2/vmlinux
Reading symbols from ~/LinuxKernel/linux-5.4.2/vmlinux...done.
(gdb) target remote:1234
Remote debugging using :1234
0x0000fff0 in ?? ()
(gdb) break start_kernel
Breakpoint 1 at 0xc1db5885: file init/main.c, line 576.
然后输入c让系统继续执行，执行到断点start_kernel ()则说明成功。
(gdb) c
Continuing.
Breakpoint 1, start_kernel () at init/main.c:576
576 {
添加新断点sys_bind, sys_listen, sys_socketcall
(gdb) break sys_bind
Breakpoint 2 at 0xc179beb0: file net/socket.c, line 1656.
(gdb) break sys_listen
Breakpoint 3 at 0xc179bf60: file net/socket.c, line 1688.
(gdb) break sys_socketcall
Breakpoint 4 at 0xc179ce00: file net/socket.c, line 2818.
c让系统继续执行
(gdb) c
Continuing.
Breakpoint 4, __se_sys_socketcall (call=1, args=-1075909056) at net/socket.c:2818
2818 SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
系统进入sys_socketcall断点，查看虚拟机窗口，可以看到虚拟机正在启动本地换回接口
再次继续执行，可以看到总共进了三次sys_socketcall，另外两次分别是启动以太网口和建立连接，这个在上周就已经发现了。
接着成功进入系统，可以查看之前编译进系统的TCP服务端和客户端
在MenuOS中输入replyhi启动TCP服务端
sys_socketcall
可以在gdb中发现再次进入sys_socketcall断点
Breakpoint 4, __se_sys_socketcall (call=1, args=-1075910240) at net/socket.c:2818
2818 SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
可以看到，断点停在__se_sys_socketcall中，位置是net/socket.c的2818行，找到函数如下：
2818 SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2819 {
2820 unsigned long a[AUDITSC_ARGS];
2821 unsigned long a0, a1;
2822 int err;
2823 unsigned int len;
2824
2825 if (call < 1 || call > SYS_SENDMMSG)
2826 return -EINVAL;
2827 call = array_index_nospec(call, SYS_SENDMMSG + 1);
2828
2829 len = nargs[call];
2830 if (len > sizeof(a))
2831 return -EINVAL;
2832
2833 /* copy_from_user should be SMP safe. */
2834 if (copy_from_user(a, args, len))
2835 return -EFAULT;
2836
2837 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2838 if (err)
2839 return err;
2840
2841 a0 = a[0];
2842 a1 = a[1];
2843
2844 switch (call) {
2845 case SYS_SOCKET:
2846 err = __sys_socket(a0, a1, a[2]);
2847 break;
2848 case SYS_BIND:
2849 err = __sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2850 break;
2851 case SYS_CONNECT:
2852 err = __sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2853 break;
2854 case SYS_LISTEN:
2855 err = __sys_listen(a0, a1);
2856 break;
2857 case SYS_ACCEPT:
2858 err = __sys_accept4(a0, (struct sockaddr __user *)a1,
2859 (int __user *)a[2], 0);
2860 break;
2861 ...
2930 default:
2931 err = -EINVAL;
2932 break;
2933 }
2934 return err;
2935 }
函数内部主体是一个switch语句，根据我们的call参数来进行选择，通过gdb我们可以看到，这时(call=1, args=-1075910240)，具体要根据1是哪个case来追踪调用。
可以在gdb中输入n(next)来继续往下执行，跟踪这次调用进入到哪个case，也可以去找case的定义。
而这些case的定义并不在socket.c中。我们可以在/LinuxKernel/linux-5.4.2/include/linux下找到socket.h文件。
#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) */
所以实质则是进入了__sys_socket(a0, a1, a[2]);函数内。
__sys_socket
Continuing
Breakpoint 5, __sys_socket (family=2, type=1, protocol=0) at net/socket.c:1492
1492 {
输入s(step in)进入函数调用，或者直接查看net/socket.c的1492行。
int __sys_socket(int family, int type, int protocol)
{
int retval;
struct socket *sock;
int flags;
/* Check the SOCK_* constants for consistency. */
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
flags = type & ~SOCK_TYPE_MASK;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
type &= SOCK_TYPE_MASK;
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
return retval;
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}
函数sock_create创建了一个对应类型的套接字，sock_map_fd将套接字连接到一个文件描述符中返回。
socket_create
继续进入socket_create函数：
(gdb) step
sock_create (res=<optimized out>, protocol=<optimized out>, type=<optimized out>,
family=<optimized out>) at net/socket.c:1511
1511 retval = sock_create(family, type, protocol, &sock);
函数调用了__sock_create函数
int sock_create(int family, int type, int protocol, struct socket **res)
{
return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}
__sock_create
设置断点，进入函数查看
Breakpoint 7, __sock_create (net=0xc1d60dc0 <init_net>, family=2, type=1, protocol=0,
res=0xc71e7f40, kern=0) at net/socket.c:1349
1349 {
__sock_create函数定义如下：
int __sock_create(struct net *net, int family, int type, int protocol,
struct socket **res, int kern)
{
int err;
struct socket *sock;
const struct net_proto_family *pf;
// 检查协议地址和socket类型
if (family < 0 || family >= NPROTO)
return -EAFNOSUPPORT;
if (type < 0 || type >= SOCK_MAX)
return -EINVAL;
if (family == PF_INET && type == SOCK_PACKET) {
pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)
",
current->comm);
family = PF_PACKET;
}
err = security_socket_create(family, type, protocol, kern);
if (err)
return err;
// 分配socket对象
sock = sock_alloc();
if (!sock) {
net_warn_ratelimited("socket: no more sockets
");
return -ENFILE;
}
sock->type = type;
#ifdef CONFIG_MODULES
if (rcu_access_pointer(net_families[family]) == NULL)
request_module("net-pf-%d", family);
#endif
rcu_read_lock();
// 得到相应的协议族的操作
pf = rcu_dereference(net_families[family]);
err = -EAFNOSUPPORT;
if (!pf)
goto out_release;
if (!try_module_get(pf->owner))
goto out_release;
rcu_read_unlock();
// 使用指针函数创建套接字
err = pf->create(net, sock, protocol, kern);
if (err < 0)
goto out_module_put;
if (!try_module_get(sock->ops->owner))
goto out_module_busy;
module_put(pf->owner);
err = security_socket_post_create(sock, family, type, protocol, kern);
if (err)
goto out_sock_release;
*res = sock;
return 0;
out_module_busy:
err = -EAFNOSUPPORT;
out_module_put:
sock->ops = NULL;
module_put(pf->owner);
out_sock_release:
sock_release(sock);
return err;
out_release:
rcu_read_unlock();
goto out_sock_release;
}
其中sock_alloc函数：该函数分配一个新的inode与其绑定的套接字对象
struct socket *sock_alloc(void)
{
struct inode *inode;
struct socket *sock;
inode = new_inode_pseudo(sock_mnt->mnt_sb);
if (!inode)
return NULL;
sock = SOCKET_I(inode);
inode->i_ino = get_next_ino();
inode->i_mode = S_IFSOCK | S_IRWXUGO;
inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid();
inode->i_op = &sockfs_inode_ops;
return sock;
}
接着pf = rcu_dereference(net_families[family]);得到相应的协议族操作net_family_ops。
这里的指针函数指向inet_family_ops，相当于调用inet_family_ops.create
所以综上__sock_create函数进行了
- 协议类型的检查
- 创建套接字对象
- 根据不同的协议族类型，使用函数指针初始化对应的套接字
- 做了各种错误处理
- 返回套接字
整个sys_socketcall调用的主要过程
sys_socketcall
|
switch:
case SYS_SOCKET:
__sys_socket
|
+---sock_create
| |
| +---__sock_create
| |
| +---sock_alloc()
| +---rcu_dereference(net_families[family])
| +---pf->create(net, sock, protocol, kern)
+---sock_map_fd
case SYS_BIND:
...
继续执行
对下列case中的函数调用打上断点，这里还可以发现，系统调用中的send和sendto都是通过__sys_sendto系统调用来实现的，recv同样。
(gdb) b sys_socketcall
Breakpoint 10 at 0xc179ce00: file net/socket.c, line 2818.
(gdb) b __sys_socket
Breakpoint 11 at 0xc179ba70: file net/socket.c, line 1492.
(gdb) b __sys_bind
Breakpoint 12 at 0xc179bde0: file net/socket.c, line 1634.
(gdb) b __sys_connect
Breakpoint 13 at 0xc179c1c0: file net/socket.c, line 1811.
(gdb) b __sys_listen
Breakpoint 14 at 0xc179bed0: file net/socket.c, line 1668.
(gdb) b __sys_accept4
Breakpoint 15 at 0xc179bf70: file net/socket.c, line 1707.
(gdb) b __sys_sendto
Breakpoint 16 at 0xc179c480: file net/socket.c, line 1923.
(gdb) b __sys_recvfrom
Breakpoint 17 at 0xc179c5e0: file net/socket.c, line 1984.
gdb捕获了4次sys_socketcall，分别是
- SYS_SOCKET
- SYS_BIND
- SYS_LISTEN
- SYS_ACCEPT
正好对应TCP服务端中应用程序的4个过程，然后阻塞等待客户端请求
在MenuOS中，启动客户端hello
gdb捕获了6次sys_socketcall，分别是
- SYS_SOCKET(客户端)
- SYS_CONNECT(客户端)
- SYS_SEND(客户端)
- SYS_RECV(服务端)
- SYS_SEND(服务端)
- SYS_RECV(客户端)
作者：SA19225176，万有引力丶
参考资料来源：USTC Socket与系统调用深度分析