原文链接：https://mp.weixin.qq.com/s/QvHP2dsUdKEVmW12QqzpDw

原作者：编程杂技

前言：很久没有看内核的代码了，假期开始看一下，之前看了一下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，这样就可以灵活地拓展。但是总的来说，网络层的实现是非常复杂的，尤其到了新版的内核，本文做了个大致的介绍，后续有时间继续深入分析。