从linux5.9看网络层的设计
前言：很久没有看内核的代码了，假期开始看一下，之前看了一下0.11和1.2.13的代码，虽然大致了解了一些原理，但是毕竟比较旧了，再者很多功能还没有实现，比如epoll，所以这次选取的是5.9的版本，再也不怕过时了，当然，现在内核的代码量级非常大，不可能看得完也不可能都看，只是选取自己感兴趣的一些点看一下。看内核代码，总的来说是非常有趣的，不仅是因为知其然知其所以然，而且看到朴素的c语言，还有世界级大佬写代码的思路、思想，甚至注释，都是非常有意思的事情。
今天分析的内容是从socket函数开始，看看linux网络层的设计。下面我们看一下我们平时写网络编程代码时的用法。
#include <sys/socket.h>int fd = socket(...);bind(fd, ...);lisnten(fd);我们看到网络编程中的一系列函数都是来自sys/socket.h这个头文件。这个是glibc提供的，glibc通过系统调用的方式使用操作系统提供的API。
网络层API的调用
在网络层设计中，内核并没有给每一个网络函数都提供一个系统调用，而是提供了一个统一的入口socketcall，也就是说，我们使用的网络函数，透过glibc，最后到达socketcall入口，然后进行分发，我们来看一下代码。
// call就是调用方使用的函数SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args){ unsigned long a[AUDITSC_ARGS];
unsigned long a0, a1;
int err;
unsigned int len;
call = array_index_nospec(call, SYS_SENDMMSG + 1);
len = nargs[call];
if (copy_from_user(a, args, len))
return -EFAULT;
err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
if (err)
return err;
a0 = a[0];
a1 = a[1];
switch (call) {
case SYS_SOCKET:
err = __sys_socket(a0, a1, a[2]);
break;
case SYS_BIND:
err = __sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
break;
// 忽略很多其他case
default:
err = -EINVAL;
break;
}
return err;}我们看到socketcall的逻辑就是分发。下面我们以socket函数为例，继续分析网络层的设计。socket是linux网络编程中最重要的概念，socket又叫套接字，他是内核设计者对底层协议的抽象，然后提供给用户的入口，他类似工厂模式，当我们调用socket函数的时候，传入对应的参数，就可以得到不同类型的socket，对调用方来说简化了网络编程的难度，而在抽象的底层，socket包含了非常多复杂的逻辑，比如TCP、UDP、IP协议的实现。我们来看看面对复杂的网络协议，内核设计者是如何设计网络层的架构的。
网络层和文件系统的关系
我们知道Linux万物皆文件，socket也不例外，当调用socket函数的时候，我们拿到的不是socket本身，而是一个文件描述符fd。那么网络层是如何和文件系统关联起来的呢？这得益于Linux的VFS（虚拟文件系统），VFS为文件系统抽象了一套API，实现了该系列API就可以把对应的资源当作文件使用，我们来看看网络层中关于这部分的实现。我们知道文件系统有以下关系。
我们来看看inode和socket是如何关联起来的。以下是网络层中，关于超级块接口的实现
static const struct super_operations sockfs_ops = {
.alloc_inode = sock_alloc_inode,
.free_inode = sock_free_inode,
.statfs = simple_statfs,};当调用socket函数的时候就需要新建一个inode，然后就会调用sock_alloc_inode。
struct socket_alloc {
struct socket socket;
struct inode vfs_inode;};
static struct inode *sock_alloc_inode(struct super_block *sb){ struct socket_alloc *ei;
ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
// 忽略初始化字段的逻辑
return &ei->vfs_inode;}我们看到sock_alloc_inode函数的逻辑非常简单，就是分配一个socket_alloc结构体，socket_alloc结构体中有两个字段，分别是socket和inode，inode是给文件系统使用的，socket是网络层使用的。所以有以下关系。
网络层的初始化
从socket函数的定义中我们看到有family和type两个参数，这两个属性都会对应不同的实现。我们先看看family的实现。
static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;net_families是个结构体数组，那么值是什么呢？net_families的值是通过sock_register设置的。
int sock_register(const struct net_proto_family *ops){
int err;
spin_lock(&net_family_lock);
// 把ops加入到数组中
rcu_assign_pointer(net_families[ops->family], ops);
spin_unlock(&net_family_lock);
return err;}那么哪里会调用sock_register呢？在网络层初始化的时候会调用inet_init，在inet_init中会调用sock_register。
static const struct net_proto_family inet_family_ops = {
.family = PF_INET,
.create = inet_create,
.owner = THIS_MODULE,};
static int __init inet_init(void) { (void)sock_register(&inet_family_ops);}接着我们看看type的实现。
static struct inet_protosw inetsw_array[] ={
{
.type = SOCK_STREAM,
.protocol = IPPROTO_TCP,
// 给sock结构体使用
.prot = &tcp_prot,
// 给socket结构体使用
.ops = &inet_stream_ops,
.flags = INET_PROTOSW_PERMANENT |
INET_PROTOSW_ICSK,
},
{
.type = SOCK_DGRAM,
.protocol = IPPROTO_UDP,
.prot = &udp_prot,
.ops = &inet_dgram_ops,
.flags = INET_PROTOSW_PERMANENT,
},
{
.type = SOCK_DGRAM,
.protocol = IPPROTO_ICMP,
.prot = &ping_prot,
.ops = &inet_sockraw_ops,
.flags = INET_PROTOSW_REUSE,
},
{
.type = SOCK_RAW,
.protocol = IPPROTO_IP, /* wild card */
.prot = &raw_prot,
.ops = &inet_sockraw_ops,
.flags = INET_PROTOSW_REUSE,
}};在网络层初始化的时候会注册以上的定义。
for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
inet_register_protosw(q);我们看一下inet_register_protosw
void inet_register_protosw(struct inet_protosw *p){
struct list_head *lh;
struct inet_protosw *answer;
int protocol = p->protocol;
struct list_head *last_perm;
spin_lock_bh(&inetsw_lock);
last_perm = &inetsw[p->type];
list_for_each(lh, &inetsw[p->type]) {
answer = list_entry(lh, struct inet_protosw, list);
if ((INET_PROTOSW_PERMANENT & answer->flags) == 0)
break;
if (protocol == answer->protocol)
goto out_permanent;
last_perm = lh;
}
list_add_rcu(&p->list, last_perm);}inet_register_protosw主要是把inet_protosw结构体逐个加入到队列中，后面会用到。接下来我们就可以分析socket函数的实现了。
socket函数的实现
socket函数对应的实现是__sys_socket。
int __sys_socket(int family, int type, int protocol){
int retval;
struct socket *sock;
int flags;
/*
type这个字段中一部分数据是标记协议的类型的，比如流式类型、数据包类型，
另一部分数据是标记socket的特性的，比如非阻塞SOCK_NONBLOCK，这个是新
内核支持的，以前需要使用两个函数完成
*/
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;
// 获取一个fd
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));}socket函数实现中，主要分为两个部分，分别是sock_create和sock_map_fd。sock_create顾名思义是用于创建一个socket结构体的。
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
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结构体
sock = sock_alloc();
sock->type = type;
rcu_read_lock();
// 根据socket类型(协议簇类型)拿到对应的处理函数集
pf = rcu_dereference(net_families[family]);
pf->create(net, sock, protocol, kern);
*res = sock;
return 0;}__sock_create函数调用sock_alloc分配一个结构体
struct socket *sock_alloc(void){
struct inode *inode;
struct socket *sock;
// 申请一个inode
inode = new_inode_pseudo(sock_mnt->mnt_sb);
// inode和socket在同一个结构体中，取出来
sock = SOCKET_I(inode);
// 设置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;}
struct inode *new_inode_pseudo(struct super_block *sb){ struct inode *inode = alloc_inode(sb);
if (inode) {
spin_lock(&inode->i_lock);
inode->i_state = 0;
spin_unlock(&inode->i_lock);
INIT_LIST_HEAD(&inode->i_sb_list);
}
return inode;}
static struct inode *alloc_inode(struct super_block *sb){ const struct super_operations *ops = sb->s_op;
struct inode *inode;
// alloc_inode指向sock_alloc_inode函数
if (ops->alloc_inode)
inode = ops->alloc_inode(sb);
return inode;}
static struct inode *sock_alloc_inode(struct super_block *sb){ struct socket_alloc *ei;
ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
return &ei->vfs_inode;}sock_alloc申请了一个socket_alloc结构体，然后返回socket_alloc结构体中的socket结构体。接着我们看看又做了什么操作。
// 根据socket类型拿到对应的处理方式
pf = rcu_dereference(net_families[family]);
pf->create(net, sock, protocol, kern);前面我们已经分析过net_families，这里会调family对应的create函数。
static int inet_create(struct net *net, struct socket *sock, int protocol,
int kern){
struct sock *sk;
struct inet_protosw *answer;
struct inet_sock *inet;
struct proto *answer_prot;
unsigned char answer_flags;
int try_loading_module = 0;
int err;
sock->state = SS_UNCONNECTED;
/* Look for the requested type/protocol pair. */
lookup_protocol:
err = -ESOCKTNOSUPPORT;
rcu_read_lock();
// 遍历找到对应类型的处理方式
list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
err = 0;
/* Check the non-wild match. */
if (protocol == answer->protocol) {
if (protocol != IPPROTO_IP)
break;
} else {
/* Check for the two wild cases. */
if (IPPROTO_IP == protocol) {
protocol = answer->protocol;
break;
}
if (IPPROTO_IP == answer->protocol)
break;
}
err = -EPROTONOSUPPORT;
}
// 操作函数集
sock->ops = answer->ops;
answer_prot = answer->prot;
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);
// 关联socket和sock结构体
sock_init_data(sock, sk);
if (sk->sk_prot->init) {
err = sk->sk_prot->init(sk);
}}struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
struct proto *prot, int kern){
struct sock *sk;
// 创建一个sock结构体
sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
if (sk) {
sk->sk_family = family;
// 赋值函数集
sk->sk_prot = sk->sk_prot_creator = prot;
}
return sk;}inet_create函数主要的逻辑主要是根据type找到对应协议的处理函数集，然后把对应的函数集赋值给socket结构体（后面会用到），接着创建一个sock结构体并把对应的函数集合赋值给sock结构体。接着把sock和socket结构体关联起来。最后调用sock的init函数。我们以UDP为例。
int udp_init_sock(struct sock *sk){
skb_queue_head_init(&udp_sk(sk)->reader_queue);
sk->sk_destruct = udp_destruct_sock;
return 0;}只是做了一些初始化的处理。最后形成以下架构。
很多同学应该都知道Linux万物皆文件的哲学思想，当我们调用socket拿到一个结构体后，并不是把这个结构体返回给调用方，而是返回一个文件描述符fd。这个fd就像一个索引一样，后续就可以通过该fd找到对应的socket结构体。我们看看是怎么处理的。
static int sock_map_fd(struct socket *sock, int flags){
struct file *newfile;
// 获取一个可用的fd
int fd = get_unused_fd_flags(flags);
// 获取一个可用的file结构体
newfile = sock_alloc_file(sock, flags, NULL);
// 关联fd和file结构体
if (!IS_ERR(newfile)) {
fd_install(fd, newfile);
return fd;
}
put_unused_fd(fd);
return PTR_ERR(newfile);}至此网络层的整体架构就分析完了，我们再看一下这种架构的好处是什么，比如我们后续会调用bind函数。
int __sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen){
struct socket *sock;
struct sockaddr_storage address;
int err, fput_needed;
// 根据fd找到对应的socket结构体
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (sock) {
err = move_addr_to_kernel(umyaddr, addrlen, &address);
if (!err) {
err = security_socket_bind(sock,
(struct sockaddr *)&address,
addrlen);
if (!err)
// 调用函数集的bind函数
err = sock->ops->bind(sock,
(struct sockaddr *)
&address, addrlen);
}
fput_light(sock->file, fput_needed);
}
return err;}我能看到后续的调用的网络函数中，会调用底层对应的函数，当我们新增一个协议的时候，只需要实现对应的API就可以。我们看到整个网络层的实际中，主要分为socket层、af_inet层和具体协议层（TCP、UDP等）。当我使用网络编程的时候，首先会创建一个socket结构体（socket层），socket结构体是最上层的抽象，然后通过协议簇类型创建一个对应的sock结构体，sock是协议簇抽象（af_inet层），同一个协议簇下又分为不同的协议类型，比如TCP、UDP（具体协议层），然后根据socket的类型（流式、数据包）找到对应的操作函数集并赋值到socket和sock结构体中，后续的操作就调用对应的函数就行，调用某个网络函数的时候，会从socket层到af_inet层，af_inet做了一些封装，必要的时候调用底层协议（TCP、UDP）对应的函数。而不同的协议只需要实现自己的逻辑就能加入到网络协议中。
总结，网络层的设计VFS有点相似，通过在上层定义抽象的API，底层实现具体的API，这样就可以灵活地拓展。但是总的来说，网络层的实现是非常复杂的，尤其到了新版的内核，本文做了个大致的介绍，后续有时间继续深入分析。