内核在协议栈接收处理完输入包以后，要能通知到用户进程，让用户进程能够收到并处理这些数据。进程和内核配合有很多种方案，第一种是同步阻塞的方案，第二种是多路复用方案。本文以epoll为例

部分内容来源于 《深入理解Linux网络》、《Linux内核源码分析TCP实现》

socket

在网络编程中，套接字（Socket）是用于描述计算机网络中通信端点的抽象概念。它允许应用程序在网络上进行数据传输，通过特定的 API 与底层协议（如 TCP 或 UDP）交互。套接字可以分为流式套接字（用于 TCP 连接，提供可靠的字节流通信）和数据报套接字（用于 UDP 连接，提供无连接的不可靠通信）。常见操作包括创建套接字、绑定地址、监听连接、接受和发送数据等。

int socket(int domain, int type, int protocol);

创建完socket之后，内核其实在内部创建了一系列的对象，部分对象如上所示。

创建流程

接下来解析socket的创建流程以及其大体包含哪些内容：

首先是socket系统调用，调用__sys_socket，其中首先调用sock_create创建socket。

SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
    return __sys_socket(family, type, protocol);
}

/**
    family: 常用AF_INET(ipv4)，AF_UNIX(本地)，AF_INET6(ipv6)
    type: SOCK_STREAM,SOCK_DGRAM,SOCK_RAW
*/
int __sys_socket(int family, int type, int protocol)
{
    int retval;
    struct socket *sock;
    int flags;

    // 创建socket
    retval = sock_create(family, type, protocol, &sock);

    // 将socket和文件描述符关联，并返回对应描述符
    return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}

初始化socket

sock_create是创建socket的主要位置，其中sock_create又调用了_sock_create。

int __sock_create(struct net *net, int family, int type, int protocol,
             struct socket **res, int kern)
{
    struct socket *sock;
    const struct net_proto_family *pf;

    sock = sock_alloc();
    // 获取协议族
    pf = rcu_dereference(net_families[family]);
    // 调用协议族的create函数
    pf->create(net, sock, protocol, kern);
    ...
}

在_sock_create里，首先调用sock_alloc来分配一个struct sock内核对象，接着获取协议族的操作函数表，并调用其create方法。对于AF_INET协议族来说，执行到的是inet_create方法。

// file: net/ipv4/af_inet.c

static struct inet_protosw inetsw_array[] =
{   
    // 可以看到tcp对应的type和protocol
    {
        .type =       SOCK_STREAM,
        .protocol =   IPPROTO_TCP,
        .prot =       &tcp_prot,
        .ops =        &inet_stream_ops,
        .flags =      INET_PROTOSW_PERMANENT |
                  INET_PROTOSW_ICSK,
    },
}

static int inet_create(struct net *net, struct socket *sock, int protocol,
               int kern)
{
    struct inet_protosw *answer;

 /* look for the requested type/protocol pair. */
lookup_protocol:

    /**
        每个type都有一个链表，里面对应不同协议的对象
        例如：type为SOCK_DGRAM的链表，protocol包含UDP，ICMP等
    */
    list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
        // 更据protocol匹配,得到anser
        if (protocol == answer->protocol) {
            if (protocol != IPPROTO_IP)
                break;
        } else
        ......
    }
    
    // 将 inet_stream_ops 赋到 socket->ops 上
    sock->ops = answer->ops;
    
    // 获得 tcp_prot
    answer_prot = answer->prot;
    
    // 分配 sock 对象，并把 tcp_prot 赋到 sock->sk_prot 上
    sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);

    // 初始化，且sock->sk = sk;
    sock_init_data(sock, sk);

}

在inet _create中，根据类型SOCK_STREAM查找到对于TCP定义的操作方法实现集合inet_stream _ops和tcp_prot，并把它们分别设置到socket- >ops和sock->sk_prot上，如图下图所示。

再往下看到了sock_init_data。在这个方法中将sock中的sk _data ready函数指针进行了初始化，设置为默认sock_def_readable。

// file: net/core/sock.c

void sock_init_data(struct socket *sock, struct sock *sk) {
    sk->sk_data_ready = sock_def_readable;
    sk->sk_write_space = sock_def_write_space;
    sk->sk_error_report = sock_def_error_report;
}

当软中断上收到数据包时会通过调用sk_data_ready函数指针来唤醒在sock上等待的进程。至此，一个tcp对象就算创建完成了，这里花费了一次socket系统调用的开销。

与sockfs关联

创建完成后将socket和文件描述符关联，并返回对应描述符。关于socket和文件描述符关联，实际上Linux中存在sockfs的虚拟文件系统专门用来管理套接字，会创建并关联对应inode，将socket视为文件管理。

// file: net/socket.c

/**
    创建sock时实际sockfs创建inode，和socket关联
 */
struct socket *sock_alloc(void)
{
    struct inode *inode;
    struct socket *sock;

    inode = new_inode_pseudo(sock_mnt->mnt_sb);
    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;
}


static int sock_map_fd(struct socket *sock, int flags)
{
    struct file *newfile;
    // 从当前进程files表中获取未使用fd
    int fd = get_unused_fd_flags(flags);

    //通过sockfs创建一个于传入socket关联的file
    newfile = sock_alloc_file(sock, flags, NULL);

    if (!IS_ERR(newfile)) {
    // 将fd与socket对应file关联
        fd_install(fd, newfile);
        return fd;
    }
}

/**
    为socket创建file,并关联
*/
struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
{
    struct file *file;

    if (!dname)
        dname = sock->sk ? sock->sk->sk_prot_creator->name : "";

    file = alloc_file_pseudo(SOCK_INODE(sock), sock_mnt, dname,
                O_RDWR | (flags & O_NONBLOCK),
                &socket_file_ops);

    // sock和file互相关联
    sock->file = file;
    file->private_data = sock;
    return file;
}

小结

socket套接字创建流程如下：

• 系统调用：用户程序通过调用 socket() 系统调用请求创建一个新的socket。

• 进入内核态：系统调用被转发到内核中的处理函数。

• 分配socket结构：内核分配一个 struct socket 结构体，用于描述该socket的状态和属性。

• 分配sock结构：分配一个 struct sock 结构体，表示与网络协议相关的信息。

• 初始化socket数据：调用 sock_init_data() 函数初始化 struct sock 中的各种回调函数。

• 协议族和协议的注册：根据传入的协议族和类型选择合适的协议。在TCP/IP协议栈中，调用 inet_create() 或类似函数来创建对应的协议对象。

• 绑定sockfs：将刚创建的socket结构体与sockfs绑定。sockfs是Linux内核中用于处理套接字的虚拟文件系统。这个过程通常在 socket 创建后完成，使得该socket可以被视为文件描述符。在这个阶段，内核会设置socket的操作和协议相关的功能，以便为后续的操作（如bind()、connect()等）做好准备。

• 分配端口和地址：如果是流式socket（如TCP），内核将分配一个本地端口和地址，以便后续的连接请求。

• 返回socket描述符：一旦所有的初始化工作完成，内核会返回一个文件描述符给用户程序，表示新创建的socket。

• 后续操作：用户可以使用返回的socket描述符进行后续的操作，例如绑定地址 (bind())、监听连接 (listen()) 和接受连接 (accept()) 等。

同步阻塞I/O

从用户进程创建socket，到一个网络包抵达网卡被用户进程接收，同步阻塞IO总体上的流程如图所示。

等待接收消息

ssize_t recv(int sockfd, void buf[.len], size_t len,int flags);
ssize_t recvfrom(int sockfd, void buf[restrict .len], size_t len,
                        int flags,
                        struct sockaddr *_Nullable restrict src_addr,
                        socklen_t *_Nullable restrict addrlen);

recv会执行recvform系统调用。进入系统调用后，用户进程就进入了内核态，执行一系列的内核协议层函数，然后到socket对象的接收队列中查看是否有数据，没有的话就把自己添加到socket对应的等待队列里。最后让出CPU，操作系统会选择下一个就绪状态的进程来执行。整个流程如下图：

SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
        unsigned int, flags, struct sockaddr __user *, addr,
        int __user *, addr_len)
{
    return __sys_recvfrom(fd, ubuf, size, flags, addr, addr_len);
}

int __sys_recvfrom(int fd, void __user *ubuf, size_t size, unsigned int flags,
           struct sockaddr __user *addr, int __user *addr_len)
{
    struct socket *sock;
    struct iovec iov;
    struct msghdr msg;
    struct sockaddr_storage address;

    // 将用户空间缓冲区转换为内核空间可以使用的iovec
    err = import_single_range(READ, ubuf, size, &iov, &msg.msg_iter);

    // 通过fd获取socket对象
    sock = sockfd_lookup_light(fd, &err, &fput_needed);

    msg.msg_control = NULL;
    msg.msg_controllen = 0;
    ...

    // 接收数据并通过msg.msg_iter写入用户缓冲区
    err = sock_recvmsg(sock, &msg, flags);

    //addr不为NULL时获取对等方地址
    if (err >= 0 && addr != NULL) {
        move_addr_to_user(&address,msg.msg_namelen, addr, addr_len);
    }

}

通过查找当前进程文件表可以获取fd对应的file对象，之前讲过file和socket关联，从而获取对应socket。在sock_recvmsg函数中会从socket中获取数据并写入用户缓冲区。

static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
                     int flags)
{
    return INDIRECT_CALL_INET(sock->ops->recvmsg, inet6_recvmsg,
                  inet_recvmsg, sock, msg, msg_data_left(msg),
                  flags);
}

const struct proto_ops inet_stream_ops = {
    .recvmsg       = inet_recvmsg,
};

最终会调用到sock_recvmsg_nosec函数，其中又会调用sock->ops->recvmsg，在这里即调用inet_recvmsg。而在inet_recvmsg中又会调用sock成员的函数sk->sk_prot->recvmsg，即tcp_recvmsg。

int inet_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
         int flags)
{
    struct sock *sk = sock->sk;
    err = INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg,
                  sk, msg, size, flags & MSG_DONTWAIT,
                  flags & ~MSG_DONTWAIT, &addr_len);
}

struct proto tcp_prot = {
    .recvmsg        = tcp_recvmsg,
    ...
};

tcp_recvmsg函数会从sock结构体的接收队列中获取skbuff并拷贝数据到用户缓冲区。

//file: net/ipv4/tcp.c

int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
        int flags, int *addr_len)
{
    do {
            // 在循环中不断从接收队列获取数据
            last = skb_peek_tail(&sk->sk_receive_queue);
            skb_queue_walk(&sk->sk_receive_queue, skb) {
                last = skb;
                offset = *seq - TCP_SKB_CB(skb)->seq;
                if (offset < skb->len)
                    goto found_ok_skb;
                if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
                    goto found_fin_ok;
                ...
            }
            ...
            if (copied >= target) {
                /* Do not sleep, just process backlog. */
                release_sock(sk);
                lock_sock(sk);
            } else {
                // 没有拷贝足够数据，等待，阻塞当前进程
                sk_wait_data(sk, &timeo, last);
            }

            found_ok_skb:
                // 将skbuff内核态数据拷贝到用户缓冲区
                used = skb->len - offset;
                skb_copy_datagram_msg(skb, offset, msg, used);
        } while (len > 0)
}

skb_queue_walk函数在读取sock对象下的接收队列，如果数据不够多则调用sk_wait_data。

sk_wait_data函数会阻塞进程，其内部如下：

// file:net/core/sock.c

int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
{
    DEFINE_WAIT_FUNC(wait, woken_wake_function);
    int rc;

    // 向sock等待队列添加等待项
    add_wait_queue(sk_sleep(sk), &wait);
    sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
    // 等待条件为接收队列尾部元素改变，陷入阻塞
    rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
    sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
    remove_wait_queue(sk_sleep(sk), &wait);
    return rc;
}

其将当前进程的等待项添加到与 socket (sk) 相关联的等待队列中。sk_sleep(sk) 返回一个指向与该 socket 相关的睡眠队列的指针。之后设置 socket 的状态位，以指示当前进程正在等待数据。

之后调用 sk_wait_event，该函数会检查条件表达式（即接收队列尾部元素是否改变）并可能导致阻塞。如果条件不满足，进程将进入休眠状态，直到有其他进程唤醒它。
timeo 参数可以指定超时值，在指定时间内如果条件仍未满足，进程将被唤醒。

当有数据到达 socket 或者其他条件发生变化时，其他进程会调用相应的唤醒函数，如 wake_up()，从而将这个等待队列中的进程唤醒。在退出之前，函数会清除设置的状态位，并从等待队列中移除当前进程的等待项。

整个过程涉及一次进程上下文转换。

软中断模块唤醒进程

前文讲到了网络包到网卡后是怎么被网卡接收，最后再交由软中断处理的，这里直接从TCP协议的接收函数tcp _v4_rcv看起。

软中断（也就是Linux里的ksoftirqd线程）里收到数据包以后，发现是TCP包就会执行tcp_v4_rcv函数。

int tcp_v4_rcv通过IP和端口获取对应的struct sock对象，进一步调用tcp_v4_do_rcv，主要看其中对ESTABLISHED状态下的数据处理——tcp_rcv_established，在其中会进行TCP协议的相关处理，之后将处理完成的sk_buff加入sock对象的接收队列中，然后执行sk->sk_data_ready(sk)。在socket创建部分我们知道该函数指针指向sock_def_readable函数，在其中获取sock对象的等待队列，唤醒等待的进程。

// file:net/ipv/tcp_ipv4.c
int tcp_v4_rcv(struct sk_buff *skb)
{
    th = (const struct tcphdr *)skb->data; // 获取tcp header
    iph = ip_hdr(skb);  // 获取ip header

    // 根据数据包的ip，端口信息找到对应struct sock
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,th->dest, sdif, &refcounted);

    ...
    if (!sock_owned_by_user(sk)) {
        // 调用tcp_v4_do_rcv进一步处理
        ret = tcp_v4_do_rcv(sk, skb);
    }
}
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct sock *rsk;

    // ESTABLISHED状态下的数据处理
    if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
        tcp_rcv_established(sk, skb);
        return 0;
    }
}

// file: net/ipve/tcp_input.c
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
{
    // 一系列处理
    ......
    // 将处理好的sk_buff放入sock对象的接收队列
    tcp_queue_rcv(sk, skb, &fragstolen);

    // 出发就绪事件
    tcp_data_ready(sk);
}

void tcp_data_ready(struct sock *sk)
{
    ...
    sk->sk_data_ready(sk);
}

// file: net/core/sock.c
static void sock_def_readable(struct sock *sk)
{
    struct socket_wq *wq;

    rcu_read_lock();
    wq = rcu_dereference(sk->sk_wq);
    if (skwq_has_sleeper(wq))
        wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
                        EPOLLRDNORM | EPOLLRDBAND);
    sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
    rcu_read_unlock();
}

sock_def_readable函数中wake_up_interruptible_sync_poll宏的内容如下，其中nr_exclusive参数传入1，代表即使多个进程阻塞在同一个sock上也只唤醒一个进程，避免“惊群”。

#define wake_up_interruptible_sync_poll(x, m)                   \
    __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, poll_to_key(m))

void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode,
            int nr_exclusive, void *key) {}

小结

同步阻塞方式接收网络包的整个过程分为两部分：

第一部分是自己的代码所在的进程，调用的socket()函数会进入内核态创建必要内核对象。recv()函数在进入内核态以后负责查看接收队列，以及在没有数据可处理的时候把当前进程阻塞掉，让出CPU。

第二部分是硬中断、软中断上下文（系统线程ksoftirqd）。在这些组件中，将包处理完后会放到socket的接收队列中。然后根据socket内核对象找到其等待队列中正在因为等待而被阻塞掉的进程，把它唤醒。

异步阻塞

在Linux上多路复用方案有select、poll、epoll。它们三个中的epoll的性能表现是最优秀的，能支持的并发量也最大。所以把epoll作为要拆解的对象，深入揭秘内核是如何实现多路的IO管理的。

epoll解析

小结

epoll的数据结构：

• rb_root rbr，这是红黑树的根节点，存储着所有添加到 epoll 中的事件，也就是这个 epoll 监控的事件。
• list_head rdllist 这是一个双向链表，保存着将要通过 epoll_wait 返回给用户的、满足条件的事件。

epoll的操作： 调用 epoll_create 建立一个 epoll 对象（在 epoll 文件系统中给这个句柄分配资源）、调用 epoll_ctl 向 epoll 对象中添加连接的套接字、调用 epoll_wait 收集发生事件的连接。

当进程调用 epoll_create 方法时，内核会创建一个 eventpoll 对象，也就是应用程序中的 epfd（epoll 文件描述符） 所代表的对象。eventpoll 对象也是文件系统中的一员，和socket一样也有一个等待队列。

创建epoll对象 eventpoll 之后，可以使用 epoll_ctl 添加或者删除所要监听的socket。内核会将eventpoll添加到需要监听的socket的等待队列中。当socket收到数据后，中断回调程序会操作eventpoll对象，而不是直接操作进程。

在 eventpoll 对象中存在就绪列表，rdlist（双向链表保存着将要通过 epoll_wait 返回给用户满足条件的事件）。中断回调程序会给eventpoll的就绪列表添加socket的引用。eventpoll对象相当于是socket和进程之间的中介，socket的数据接收并不直接影响进程，而是通过改变eventpoll的就绪列表来改变进程状态。

epoll_wait的返回条件也是根据rdlist的状态进行判断：如果rdlist已经引用了socket，那么epoll_wait直接返回（把发生的事件的集合从内核复制到 events数组中）；如果rdlist为空，阻塞进程。

（对于epoll，操作系统只需要将进程放入eventpoll这一个对象的等待队列中；而对于select，操作系统则需要将进程放入到socket列表中的所有socket对象的等待队列中。）

疑问点

多路复用epoll为什么就能提高网络性能?

epoll高性能最根本的原因是极大程度地减少了无用的进程上下文切换，让进程更专注地处理网络请求。

在内核的硬、软中断上下文中，包从网卡接收过来进行处理，然后放到socket的接收队列。再找到socket关联的epitem，并把它添加到epoll对象的就绪链表中。

在用户进程中，通过调用epoll_wait来查看就绪链表中是否有事件到达，如果有，直接取走进行处理。处理完毕再次调用epoll_wait。在高并发的实践中，只要连接足够多，epoll_wait根本不会让进程阻塞。用户进程会一直处理，直到epoll_wait里实在没活儿可干的时候才主动让出CPU。这是epoll高效的核心原因所在。

红黑树仅仅是提高了epoll查找、添加、删除socket时的效率而已，不算epoll在高并发场景高性能的根本原因。

epoll也是阻塞的?

很多人以为只要一提到阻塞，就是性能差，其实这就冤枉了阻塞。阻塞说的是进程因为等待某个事件而主动让出CPU挂起的操作。

例如，一个epoll对象下添加了一万个客户端连接的socket。假设所有这些socket上都还没有数据达到，这个时候进程调用epoll_wait发现没有任何事情可干。这种情况下用户进程就会被阻塞掉，而这种情况是完全正常的，没有工作需要处理，那还占着CPU是没有道理的。

阻塞不会导致低性能，过多过频繁的阻塞才会。epoll的阻塞和它的高性能并不冲突。