在接收到数据包之后，如果判断此套接口当前正被用户进程所使用，数据包将被保存到套接口结构的sk_backlog成员的head所定义的skb缓存列表中，tail指向链表的末尾，len变量记录了当前链表中所有skb的总长度。
struct sock {
struct {
atomic_t rmem_alloc;
int len;
struct sk_buff *head;
struct sk_buff *tail;
} sk_backlog;
#define sk_rmem_alloc sk_backlog.rmem_alloc
}
TCP在创建子套接口时，将sk_backlog结构的成员head和tail都置为空，链表元素数量为零。
struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
{
struct sock *newsk;
newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
if (newsk != NULL) {
newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
newsk->sk_backlog.len = 0;
}
}
一、backlog链表添加
如下函数tcp_v4_rcv所示，函数sock_owned_by_user检查套接口是否被应用进程在使用，如果没有，执行正常的TCP接收操作；否则，将调用函数tcp_add_backlog将数据包添加到backlog链表中，在用户进程释放套接口后，内核还是会调用tcp_v4_do_rcv函数执行接收操作。
int tcp_v4_rcv(struct sk_buff *skb)
{
if (!sock_owned_by_user(sk)) {
ret = tcp_v4_do_rcv(sk, skb);
} else if (tcp_add_backlog(sk, skb)) {
goto discard_and_relse;
}
}
backlog链表的添加操作不能执行接收队列（包括sk_receive_queue和out_of_order_queue）的减小内存占用类的操作（collapse/prune），只有套接口的所有者可执行此类操作。在tcp_add_backlog函数执行链表添加操作之前，内核在最大接收缓存和发送缓存之和的基础之上，再增加64K的额外量以保证成功添加，由于系统中在sk_backlog链表中同时存储有数据的套接口属于少数情况，增加额外量不会有问题。
之后，还是要使用函数skb_condense尝试一下对skb进行空间压缩，算法很简单：如果skb的线性空间有足够的剩余，就可将其共享空间中的页面片段拷贝到线性空间中，以释放页面片段。如果线性空间中的剩余量小于页面片段的长度，或者此skb被克隆过（页面片段共享给了其它skb），不执行任何压缩。
bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb)
{
u32 limit = sk->sk_rcvbuf + sk->sk_sndbuf;
limit += 64*1024;
skb_condense(skb);
if (unlikely(sk_add_backlog(sk, skb, limit))) {
bh_unlock_sock(sk);
return true;
}
return false;
}
函数sk_add_backlog如下，如果即便内核增加了64K的缓存限额，backlog链表占用的空间与套接口接收缓存之和仍然大于限额，返回无缓存的错误。此处的qsize未考虑当前skb数据包的空间占用量，即不管其大小，只要还有空间就将其接收。但是，如果skb的空间是由系统的PF_MEMALLOC保留区分配而来，并且套接口未设置SOCK_MEMALLOC标志，即内存已经处于紧张状态，此套接口还不能够帮助释放内存，返回无内存错误。最终在函数__sk_add_backlog将数据包添加到backlog链表后，为链表的长度增加skb的truesize值。
static inline bool sk_rcvqueues_full(const struct sock *sk, unsigned int limit)
{
unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
return qsize > limit;
}
static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb, unsigned int limit)
{
if (sk_rcvqueues_full(sk, limit))
return -ENOBUFS;
/*
* If the skb was allocated from pfmemalloc reserves, only
* allow SOCK_MEMALLOC sockets to use it as this socket is
* helping free memory
*/
if (skb_pfmemalloc(skb) && !sock_flag(sk, SOCK_MEMALLOC))
return -ENOMEM;
__sk_add_backlog(sk, skb);
sk->sk_backlog.len += skb->truesize;
return 0;
}
函数__sk_add_backlog执行简单的单链表添加操作，backlog链表的尾部skb的next指针指向新添加的skb，并且，将新的skb地址赋值给backlog的尾部tail指针。
static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
{
if (!sk->sk_backlog.tail)
sk->sk_backlog.head = skb;
else
sk->sk_backlog.tail->next = skb;
sk->sk_backlog.tail = skb;
skb->next = NULL;
}
二、backlog链表处理
以上提到backlog链表中的数据最终还是由tcp_v4_do_rcv函数进行处理。由于在TCP套接口初始化时，内核已经将TCP协议结构的成员backlog_rcv回调函数指针赋予了函数tcp_v4_do_rcv的值，后续又将backlog_rcv指针赋给了套接口的sk_backlog_rcv函数指针。
struct proto tcp_prot = {
.name = "TCP",
.backlog_rcv = tcp_v4_do_rcv,
.release_cb = tcp_release_cb,
}
static int inet_create(struct net *net, struct socket *sock, int protocol, int kern)
{
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);
if (!sk)
goto out;
sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
}
backlog链表接收处理函数为sk_backlog_rcv，与链表添加时的操作对应，对于设置了SOCK_MEMALLOC标志的套接口，并且数据包skb的内存是由系统的PF_MEMALLOC保留内存区分配而来的情况，使用__sk_backlog_rcv函数处理数据包。其它情况下直接调用回调函数sk_backlog_rcv处理。
函数memalloc_noreclaim_save将为当前进程增设PF_MEMALLOC标志，memalloc_noreclaim_restore函数还原前值。
static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
{
if (sk_memalloc_socks() && skb_pfmemalloc(skb))
return __sk_backlog_rcv(sk, skb);
return sk->sk_backlog_rcv(sk, skb);
}
int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
{
BUG_ON(!sock_flag(sk, SOCK_MEMALLOC));
noreclaim_flag = memalloc_noreclaim_save();
ret = sk->sk_backlog_rcv(sk, skb);
memalloc_noreclaim_restore(noreclaim_flag);
}
三、backlog链表处理时机
以应用层进程的数据发送为例，内核的tcp_sendmsg函数在处理请求之后，调用release_sock释放套接口锁。如果在此期间接收到网络数据包，内核已将其放入了backlog链表中，在释放套接口时，就需要检查以下backlog链表，已有机会进行尽快处理。如果其尾部tail不为空，说明链表非空，调用__release_sock处理。
int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
lock_sock(sk);
ret = tcp_sendmsg_locked(sk, msg, size);
release_sock(sk);
return ret;
}
void release_sock(struct sock *sk)
{
spin_lock_bh(&sk->sk_lock.slock);
if (sk->sk_backlog.tail)
__release_sock(sk);
if (sk->sk_prot->release_cb)
sk->sk_prot->release_cb(sk);
sock_release_ownership(sk);
spin_unlock_bh(&sk->sk_lock.slock);
}
需要特别注意的是函数__release_sock存在两个嵌套的循环，内层的循环是遍历backlog链表，处理其中的每个数据包skb元素，在进入内存循环之前将backlog链表的头尾两个指针清空，并且在遍历过程中内核有可能发送重调度，如果在调度其将有新的网络数据包到来，就需要外层的循环在次对backlog链表进行判断处理。
static void __release_sock(struct sock *sk)
__releases(&sk->sk_lock.slock)
__acquires(&sk->sk_lock.slock)
{
while ((skb = sk->sk_backlog.head) != NULL) {
sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
spin_unlock_bh(&sk->sk_lock.slock);
do {
next = skb->next;
prefetch(next);
WARN_ON_ONCE(skb_dst_is_noref(skb));
skb->next = NULL;
sk_backlog_rcv(sk, skb);
cond_resched();
skb = next;
} while (skb != NULL);
spin_lock_bh(&sk->sk_lock.slock);
}
sk->sk_backlog.len = 0;
}
另外，内核定义了backlog链表flush函数，如下sk_flush_backlog，其本质上是对__release_sock函数的封装。其调用点位于TCP发送函数tcp_sendmsg_locked中，使得内核在发送大量数据时，不必等到函数退出才执行backlog链表的处理。
static inline bool sk_flush_backlog(struct sock *sk)
{
if (unlikely(READ_ONCE(sk->sk_backlog.tail))) {
__sk_flush_backlog(sk);
return true;
}
return false;
}
void __sk_flush_backlog(struct sock *sk)
{
spin_lock_bh(&sk->sk_lock.slock);
__release_sock(sk);
spin_unlock_bh(&sk->sk_lock.slock);
}
与TCP发送函数类似，在TCP的tcp_recvmsg接收函数中，如果用户进程设置了非阻塞模式接收，在拷贝完套接口接收队列sk_receive_queue中的数据之后，假设用户层提供的接收缓存长度还有余量，并且backlog链表中有数据，调用release_sock处理backlog链表，处理之后的数据可能又填充到了sk_receive_queue接收队列中，再次处理此队列时，可尽量返回给用户层要求长度的数据。
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) {
}
/* Well, if we have backlog, try to process it now yet. */
if (copied >= target && !sk->sk_backlog.tail)
break;
if (copied >= target) {
/* Do not sleep, just process backlog. */
release_sock(sk);
lock_sock(sk);
} else {
sk_wait_data(sk, &timeo, last);
}
continue;
} while (len > 0);
}
总结
对于非TCP协议套接口，例如L2TP、PPTP和PPPOE等类型套接口，其控制报文需要上送应用层处理，内核使用sk_receive_skb函数实现。最终的逻辑在函数__sk_receive_skb中。
static int l2tp_ip_recv(struct sk_buff *skb)
{
/* RFC3931: L2TP/IP packets have the first 4 bytes containing
* the session_id. If it is 0, the packet is a L2TP control
* frame and the session_id value can be discarded.
*/
if (session_id == 0) {
__skb_pull(skb, 4);
goto pass_up;
}
pass_up:
return sk_receive_skb(sk, skb, 1);
}
如下，如果套接口被用户进程使用，也是要添加到backlog链表中，否则，直接使用sk_backlog_rcv进行处理。对于以上三个类型的套接口，其backlog_rcv回调函数与TCP套接口的不同，分别为pppol2tp_backlog_recv、pptp_rcv_core和pppoe_rcv_core。
int __sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested, unsigned int trim_cap, bool refcounted)
{
if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
atomic_inc(&sk->sk_drops);
goto discard_and_relse;
}
if (!sock_owned_by_user(sk)) {
mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
rc = sk_backlog_rcv(sk, skb);
mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
} else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
bh_unlock_sock(sk);
atomic_inc(&sk->sk_drops);
goto discard_and_relse;
}
}