內核協議棧tcp層的內存管理

我們先來看tcp內存管理相關的幾個內核參數,這些都能通過proc文件系統來修改: 

///內核寫buf的最大值.
extern __u32 sysctl_wmem_max;
///協議棧讀buf的最大值
extern __u32 sysctl_rmem_max;

這兩個值在/proc/sys/net/core 下。這裏要注意，這兩個值的單位是字節。 

它們的初始化在sk_init裏面,這裏可以看到這兩個值的大小是依賴於num_physpages的，而這個值應該是物理頁數。也就是說這兩個值依賴於物理內存： 

void __init sk_init(void)
{
    if (num_physpages <= 4096) {
        sysctl_wmem_max = 32767;
        sysctl_rmem_max = 32767;
        sysctl_wmem_default = 32767;
        sysctl_rmem_default = 32767;
    } else if (num_physpages >= 131072) {
        sysctl_wmem_max = 131071;
        sysctl_rmem_max = 131071;
    }
}

而我通過搜索源碼，只有設置套接口選項的時候，纔會用到這兩個值，也就是setsockopt，optname爲SO_SNDBUF或者SO_RCVBUF時，來限制設置的值: 

case SO_SNDBUF:
        if (val > sysctl_wmem_max)
            val = sysctl_wmem_max;

接下來就是整個tcp協議棧的socket的buf限制(也就是所有的socket). 
這裏要注意，這個東西的單位都是以頁爲單位的，我們下面就會看到。 

其中sysctl_tcp_mem[0]表示整個tcp sock的buf限制.
sysctl_tcp_mem[1]也就是tcp sock內存使用的警戒線.
sysctl_tcp_mem[2]也就是tcp sock內存使用的hard limit,當超過這個限制,我們就要禁止再分配buf.
extern int sysctl_tcp_mem[3];

接下來就是針對每個sock的讀寫buf限制。 

///其中依次爲最小buf,中等buf,以及最大buf.
extern int sysctl_tcp_wmem[3];
extern int sysctl_tcp_rmem[3];

這幾個值的初始化在tcp_init裏面，這裏就能清晰的看到sysctl_tcp_mem的單位是頁。而sysctl_tcp_wmem和sysctl_tcp_rmem的單位是字節。 

void __init tcp_init(void)
{
.................................
///nr_pages就是頁。
nr_pages = totalram_pages - totalhigh_pages;
    limit = min(nr_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);
    limit = (limit * (nr_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);
    limit = max(limit, 128UL);
sysctl_tcp_mem[0] = limit / 4 * 3;
sysctl_tcp_mem[1] = limit;
sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;

/* Set per-socket limits to no more than 1/128 the pressure threshold */
///轉換爲字節。
limit = ((unsigned long)sysctl_tcp_mem[1]) << (PAGE_SHIFT - 7);
max_share = min(4UL*1024*1024, limit);

sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
sysctl_tcp_wmem[1] = 16*1024;
sysctl_tcp_wmem[2] = max(64*1024, max_share);

sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;
sysctl_tcp_rmem[1] = 87380;
sysctl_tcp_rmem[2] = max(87380, max_share);
................................
}

然後就是讀寫buf的最小值 

#define SOCK_MIN_SNDBUF 2048
#define SOCK_MIN_RCVBUF 256

最後就是當前tcp協議棧已經分配了的buf的總大小。這裏要注意，這個值也是以頁爲單位的。 

atomic_t tcp_memory_allocated

而上面的這些值如何與協議棧關聯起來呢，我們來看tcp_prot結構，可以看到這些值的地址都被放到對應的tcp_prot的域。 

struct proto tcp_prot = {
.name = "TCP",
.owner = THIS_MODULE,
...................................................
.enter_memory_pressure = tcp_enter_memory_pressure,
.sockets_allocated = &tcp_sockets_allocated,
.orphan_count = &tcp_orphan_count,
.memory_allocated = &tcp_memory_allocated,
.memory_pressure = &tcp_memory_pressure,
.sysctl_mem = sysctl_tcp_mem,
.sysctl_wmem = sysctl_tcp_wmem,
.sysctl_rmem = sysctl_tcp_rmem,
........................................................
};

而對應的sock域中的幾個值，這幾個域非常重要，我們來看他們表示的含義： 


sk_rcvbuf和sk_sndbuf,這兩個值分別代表每個sock的讀寫buf的最大限制： 

sk_rmem_alloc和sk_wmem_alloc這兩個值分別代表已經提交的數據包的字節數。 

讀buf意味着進入tcp層的數據大小，而當數據提交給用戶空間之後，這個值會相應的減去提交的大小（也就類似寫buf的sk_wmem_queued)。 

寫buf意味着提交給ip層。可以看到這個值的增加是在tcp_transmit_skb中進行的。 

而sk_wmem_queued也就代表skb的寫隊列write_queue的大小。 

還有一個sk_forward_alloc，這個值表示一個預分配置，也就是整個tcp協議棧的內存cache，第一次爲一個緩衝區分配buf的時候，我們不會直接分配精確的大小，而是按頁來分配，而分配的大小就是這個值，下面我們會看到這個。並且這個值初始是0. 

struct sock {
int sk_rcvbuf;
atomic_t sk_rmem_alloc;
atomic_t sk_wmem_alloc;
int sk_forward_alloc;
..........................
int sk_sndbuf;
///這個表示寫buf已經分配的字節長度
int sk_wmem_queued;
...........................
}

sk_sndbuf和sk_rcvbuf,這兩個的初始化在這裏： 

static int tcp_v4_init_sock(struct sock *sk)
{
..................................
    sk->sk_sndbuf = sysctl_tcp_wmem[1];
    sk->sk_rcvbuf = sysctl_tcp_rmem[1];
..........................
}

而當進入establish狀態之後,sock會自己調整sndbuf和rcvbuf.他是通過tcp_init_buffer_space來進行調整的.這個函數會調用tcp_fixup_rcvbuf和tcp_fixup_sndbuf來調整讀寫buf的大小. 

這裏有用到sk_userlock這個標記，這個標記主要就是用來標記SO_SNDBUF 和SO_RCVBUF套接口選項是否被設置。而是否設置對應的值爲： 

#define SOCK_SNDBUF_LOCK    1
#define SOCK_RCVBUF_LOCK    2

我們可以看下面的設置SO_SNDBUF 和SO_RCVBUF的代碼片斷： 

//首先設置sk_userlocks.
sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
        if ((val * 2) < SOCK_MIN_SNDBUF)
            sk->sk_sndbuf = SOCK_MIN_SNDBUF;
        else
            sk->sk_sndbuf = val * 2;

因此內核裏面的處理是這樣的，如果用戶已經通過套接字選項設置了讀或者寫buf的大小，那麼這裏將不會調整讀寫buf的大小，否則就進入tcp_fixup_XXX來調整大小。 

還有一個要注意的就是MAX_TCP_HEADER，這個值表示了TCP + IP + link layer headers 以及option的長度。 

我們來看代碼。 

static void tcp_init_buffer_space(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int maxwin;

///判斷sk_userlocks，來決定是否需要fix緩衝區大小。
    if (!(sk->sk_userlocks & SOCK_RCVBUF_LOCK))
        tcp_fixup_rcvbuf(sk);
    if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK))
        tcp_fixup_sndbuf(sk);
......................................

}

接下來來看這兩個函數如何來調整讀寫buf的大小，不過這裏還有些疑問，就是爲什麼是要和3*sndmem以及4*rcvmem： 

static void tcp_fixup_sndbuf(struct sock *sk)
{
///首先通過mss，tcp頭，以及sk_buff的大小，得到一個最小範圍的sndmem。
    int sndmem = tcp_sk(sk)->rx_opt.mss_clamp + MAX_TCP_HEADER + 16 +sizeof(struct sk_buff);

///然後取sysctl_tcp_wmem[2]和3倍的sndmem之間的最小值。
    if (sk->sk_sndbuf < 3 * sndmem)
        sk->sk_sndbuf = min(3 * sndmem, sysctl_tcp_wmem[2]);
}

static void tcp_fixup_rcvbuf(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
///這裏和上面類似，也是先得到最小的一個rcvmem段。
    int rcvmem = tp->advmss + MAX_TCP_HEADER + 16 + sizeof(struct sk_buff);

    /* Try to select rcvbuf so that 4 mss-sized segments
     * will fit to window and corresponding skbs will fit to our rcvbuf.
     * (was 3; 4 is minimum to allow fast retransmit to work.)
     */
///這裏則是通過sysctl_tcp_adv_win_scale來調整rcvmem的值。
    while (tcp_win_from_space(rcvmem) < tp->advmss)
        rcvmem += 128;
    if (sk->sk_rcvbuf < 4 * rcvmem)
        sk->sk_rcvbuf = min(4 * rcvmem, sysctl_tcp_rmem[2]);
}

ok，看完初始化，我們來看協議棧具體如何管理內存的，先來看發送端，發送端的主要實現是在tcp_sendmsg裏面，這個函數我們前面已經詳細的分析過了，我們這次只分析裏面幾個與內存相關的東西。 

來看代碼片斷： 

int tcp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
        size_t size)
{
..................................

    if (copy <= 0) {
new_segment:
    if (!sk_stream_memory_free(sk))
            goto wait_for_sndbuf;

    skb = sk_stream_alloc_skb(sk, select_size(sk),
    sk->sk_allocation);
if (sk->sk_route_caps & NETIF_F_ALL_CSUM)
        skb->ip_summed = CHECKSUM_PARTIAL;

        skb_entail(sk, skb);
        copy = size_goal;
        max = size_goal;
..................
}

可以看到這裏第一個sk_stream_memory_free用來判斷是否還有空間來供我們分配，如果沒有則跳到wait_for_sndbuf來等待buf的釋放。 

然後如果有空間供我們分配，則調用sk_stream_alloc_skb來分配一個skb，然後這個大小的選擇是通過select_size。 

最後調用skb_entail來更新相關的域。 

現在我們就來詳細看上面的四個函數,先來看第一個： 

static inline int sk_stream_memory_free(struct sock *sk)
{
    return sk->sk_wmem_queued < sk->sk_sndbuf;
}

sk_stream_memory_free實現很簡單，就是判斷當前已經分配的寫緩衝區的大小(sk_wmem_queued)是否小於當前寫緩衝區(sk_sndbuf)的最大限制。 

然後是skb_entail，這個函數主要是當我們分配完buf後，進行一些相關域的更新，以及添加skb到writequeue。 

static inline void skb_entail(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
............................
    skb_header_release(skb);
    tcp_add_write_queue_tail(sk, skb);
///增加sk_wmem_queued.
    sk->sk_wmem_queued += skb->truesize;
///這裏調整sk_forward_alloc的大小，也就是預分配buf的大小(減小).
    sk_mem_charge(sk, skb->truesize);
    if (tp->nonagle & TCP_NAGLE_PUSH)
        tp->nonagle &= ~TCP_NAGLE_PUSH;
}
///這個函數很簡單，就是將sk_forward_alloc - size.
static inline void sk_mem_charge(struct sock *sk, int size)
{
    if (!sk_has_account(sk))
        return;
    sk->sk_forward_alloc -= size;
}

然後是select_size，在看這個之前我們先來坎SKB_MAX_HEAD的實現. 
SKB_MAX_HEAD主要是得到要分配的tcp數據段（不包括頭)在一頁中最大爲多少。 

#define SKB_WITH_OVERHEAD(X)    \
    ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
#define SKB_MAX_ORDER(X, ORDER) \
    SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
#define SKB_MAX_HEAD(X)     (SKB_MAX_ORDER((X), 0))

我們帶入代碼來看，我們下面的代碼是SKB_MAX_HEAD(MAX_TCP_HEADER)，展開這個宏可以看到就是PAGE_SIZE-MAX_TCP_HEADER-SKB_DATA_ALIGN(sizeof(struct skb_shared_info).其實也就是一頁還能容納多少tcp的數據。 

static inline int select_size(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
///首先取得存儲的mss。
    int tmp = tp->mss_cache;

///然後判斷是否使用scatter–gather(前面blog有介紹)
if (sk->sk_route_caps & NETIF_F_SG) {
    if (sk_can_gso(sk))
            tmp = 0;
    else {
///然後開始計算buf的長度。
        int pgbreak = SKB_MAX_HEAD(MAX_TCP_HEADER);

///如果mss大於pgbreak,那麼說明我們一頁放不下當前需要的tcp數據，因此我們將會在skb的頁區域分配，而skb的頁區域是有限制的，因此tmp必須小於這個值。
if (tmp >= pgbreak &&
    tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)
            tmp = pgbreak;
        }
    }

    return tmp;
}

接下來來看sk_stream_alloc_skb的實現。 

1 它會調用alloc_skb_fclone來分配內存，這個函數就不詳細分析了，我們只需要知道它會從slab裏分配一塊內存，而大小爲size+max_header(上面的分析我們知道slect_size只計算數據段). 

2 如果分配成功，則調用sk_wmem_schedule來判斷我們所分配的skb的大小是否精確，是的話，就調整指針，然後返回。 

3 否則調用tcp_enter_memory_pressure設置標誌進入TCP memory pressure zone。然後再調用sk_stream_moderate_sndbuf調整sndbuf(縮小sndbuf)。 

struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp)
{
    struct sk_buff *skb;

///4字節對其
    size = ALIGN(size, 4);
///分配skb。
    skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
    if (skb) {
///得到精確的大小。
        if (sk_wmem_schedule(sk, skb->truesize)) {
///返回skb。
        skb_reserve(skb, skb_tailroom(skb) - size);
            return skb;
        }
        __kfree_skb(skb);
    } else {
///否則設置全局標記進入pressure zone
        sk->sk_prot->enter_memory_pressure(sk);
        sk_stream_moderate_sndbuf(sk);
    }
    return NULL;
}

ok,現在就來看上面的幾個函數的實現。先來看幾個簡單的。 

首先是tcp_enter_memory_pressure,這個函數很簡單，就是判斷全局標記tcp_memory_pressure,然後設置這個標記。這個標記主要是用來通知其他模塊調整的，比如窗口大小等等，詳細的話自己搜索這個值，就知道了。 

void tcp_enter_memory_pressure(struct sock *sk)
{
    if (!tcp_memory_pressure) {
        NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
///設置壓力標誌。
        tcp_memory_pressure = 1;
    }
}

然後是sk_stream_moderate_sndbuf，這個函數也是要使用sk_userlocks,來判斷是否已經被用戶設置了。可以看到如果我們自己設置過了snd_buf的話，內核就不會幫我們調整它的大小了。 

static inline void sk_stream_moderate_sndbuf(struct sock *sk)
{
    if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
///它的大小調整爲大於最小值，小於sk->sk_wmem_queued >> 1。
        sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
        sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
    }
}

最後來看最核心的一個函數sk_wmem_schedule，這個函數只是對__sk_mem_schedule的簡單封裝。這裏要知道傳遞進來的size是skb->truesize，也就是所分配的skb的真實大小。並且第一次進入這個函數，也就是分配第一個緩衝區包時，sk_forward_alloc是爲0的，也就是說，第一次必然會執行__sk_mem_schedule函數。 

static inline int sk_wmem_schedule(struct sock *sk, int size)
{
    if (!sk_has_account(sk))
        return 1;
///先比較size(也就是skb->truesize)和預分配的內存大小。如果小於等於預分配的大小，則直接返回，否則調用__sk_mem_schedule進行調整。
    return size <= sk->sk_forward_alloc ||
        __sk_mem_schedule(sk, size, SK_MEM_SEND);
}

來看__sk_mem_schedule，這個函數的功能註釋寫的很清楚： 

引用

increase sk_forward_alloc and memory_allocated

然後來看源碼。這裏在看之前，我們要知道，協議棧通過讀寫buf的使用量，劃分了3個區域，或者說標誌。不同標誌進行不同處理。這裏的區域的劃分是通過sysctl_tcp_mem，也就是prot->sysctl_mem這個數組進行的。 

///頁的大小
#define SK_MEM_QUANTUM ((int)PAGE_SIZE)

int __sk_mem_schedule(struct sock *sk, int size, int kind)
{
    struct proto *prot = sk->sk_prot;
///首先得到size佔用幾個內存頁。
    int amt = sk_mem_pages(size);
    int allocated;
///更新sk_forward_alloc，可以看到這個值是頁的大小的倍數。
    sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;

///amt+memory_allocated也就是當前的總得內存使用量加上將要分配的內存的話，現在的tcp協議棧的總得內存使用量。（可以看到是以頁爲單位的。
    allocated = atomic_add_return(amt, prot->memory_allocated);

///然後開始判斷，將會落入哪一個區域。通過上面的分析我們知道sysctl_mem也就是sysctl_tcp_mem.

///先判斷是否小於等於內存最小使用限額。
    if (allocated <= prot->sysctl_mem[0]) {
///這裏取消memory_pressure，然後返回。
        if (prot->memory_pressure && *prot->memory_pressure)
            *prot->memory_pressure = 0;
        return 1;
    }

//然後判斷Under pressure。
    if (allocated > prot->sysctl_mem[1])
//大於sysctl_mem[1]說明，已經進入pressure，一次你需要調用tcp_enter_memory_pressure來設置標誌。
        if (prot->enter_memory_pressure)
            prot->enter_memory_pressure(sk);

///如果超過的hard limit。則進入另外的處理。
    if (allocated > prot->sysctl_mem[2])
        goto suppress_allocation;

//判斷類型，這裏只有兩種類型，讀和寫。總的內存大小判斷完，這裏開始判斷單獨的sock的讀寫內存。
    if (kind == SK_MEM_RECV) {
        if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
            return 1;
    } else { /* SK_MEM_SEND */
///這裏當爲tcp的時候，寫隊列的大小隻有當對端數據確認後纔會更新，因此我們要用sk_wmem_queued來判斷。
        if (sk->sk_type == SOCK_STREAM) {
            if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
                return 1;
        } else if (atomic_read(&sk->sk_wmem_alloc) <
               prot->sysctl_wmem[0])
                return 1;
    }

///程序到達這裏說明總的內存大小在sysctl_mem[0]和sysctl_mem[2]之間，因此我們再次判斷memory_pressure
    if (prot->memory_pressure) {
        int alloc;

///如果沒有在memory_pressure區域，則我們直接返回1。
        if (!*prot->memory_pressure)
            return 1;
///這個其實也就是計算整個系統分配的socket的多少。
        alloc = percpu_counter_read_positive(prot->sockets_allocated);
///這裏假設其餘的每個sock所佔用的buf都和當前的sock一樣大的時候，如果他們的總和小於sysctl_mem[2],也就是hard limit。那麼我們也認爲這次內存請求是成功的。
        if (prot->sysctl_mem[2] > alloc *
            sk_mem_pages(sk->sk_wmem_queued +
             atomic_read(&sk->sk_rmem_alloc) +
                 sk->sk_forward_alloc))
            return 1;
    }

suppress_allocation:

///到達這裏說明，我們超過了hard limit或者說處於presure 區域。
    if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
///調整sk_sndbuf(減小).這個函數前面已經分析過了。
        sk_stream_moderate_sndbuf(sk);
///然後比較和sk_sndbuf的大小，如果大於的話，就說明下次我們再次要分配buf的時候會在tcp_memory_free阻塞住，因此這次我們返回1.
        if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
            return 1;
    }

    /* Alas. Undo changes. */
///到達這裏說明，請求內存是不被接受的，因此undo所有的操作。然後返回0.
    sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
    atomic_sub(amt, prot->memory_allocated);
    return 0;
}

接下來來看個很重要的函數skb_set_owner_w。 

顧名思義，這個函數也就是將一個skb和scok關聯起來。只不過關聯的時候更新sock相應的域。我們來看源碼： 

static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
{
    skb_orphan(skb);
///與傳遞進來的sock關聯起來
    skb->sk = sk;
///設置skb的析構函數
    skb->destructor = sock_wfree;
///更新sk_wmem_alloc域，就是sk_wmem_alloc+truesize.
    atomic_add(skb->truesize, &sk->sk_wmem_alloc);
}

ok，接下來來看個scok_wfree函數，這個函數做得基本和上面函數相反。這個函數都是被kfree_skb自動調用的。 

void sock_wfree(struct sk_buff *skb)
{
    struct sock *sk = skb->sk;
    int res;

///更新sk_wmem_alloc,減去skb的大小。
    res = atomic_sub_return(skb->truesize, &sk->sk_wmem_alloc);
    if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
///喚醒等待隊列，也就是喚醒等待內存分配。
        sk->sk_write_space(sk);
    if (res == 0)
        __sk_free(sk);
}

而skb_set_owner_w是什麼時候被調用呢，我們通過搜索代碼可以看到，它是在tcp_transmit_skb中被調用的。而tcp_transmit_skb我們知道是傳遞數據包到ip層的函數。 

而kfree_skb被調用也就是在對端已經確認完我們發送的包後纔會被調用來釋放skb。 

接下來來看接收數據的內存管理。我們主要來看tcp_rcv_established這個函數，我前面的blog已經斷斷續續的分析過了，因此這裏我們只看一些重要的代碼片斷。 

這裏我們要知道，代碼能到達下面的位置，則說明，數據並沒有直接拷貝到用戶空間。否則的話，是不會進入下面的片斷的。 

if (!eaten) {
..........................................

///如果skb的大小大於預分配的值,如果大於則要另外處理。
    if ((int)skb->truesize > sk->sk_forward_alloc)
            goto step5;
        __skb_pull(skb, tcp_header_len);
                __skb_queue_tail(&sk->sk_receive_queue, skb);
///這裏關聯skb和對應的sk，並且更新相關的域，我們下面會分析這個函數。
        skb_set_owner_r(skb, sk);
        tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
        }
...............................................

step5:
    if (th->ack && tcp_ack(sk, skb, FLAG_SLOWPATH) < 0)
        goto discard;

    tcp_rcv_rtt_measure_ts(sk, skb);

    /* Process urgent data. */
    tcp_urg(sk, skb, th);

    /* step 7: process the segment text */
///最核心的函數就是這個。我們接下來會詳細分析這個函數。
    tcp_data_queue(sk, skb);

    tcp_data_snd_check(sk);
    tcp_ack_snd_check(sk);
    return 0;

先來看skb_set_owner_r函數，這個函數關聯skb和sk其實它和skb_set_owner_w類似： 

static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
    skb_orphan(skb);
///關聯sk
    skb->sk = sk;
//設置析構函數
    skb->destructor = sock_rfree;
///更新rmem_alloc
    atomic_add(skb->truesize, &sk->sk_rmem_alloc);
///改變forward_alloc.
    sk_mem_charge(sk, skb->truesize);
}

然後是tcp_data_queue，這個函數主要用來排隊接收數據，並update相關的讀buf。由於這個函數比較複雜，我們只關心我們感興趣的部分： 

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
    struct tcphdr *th = tcp_hdr(skb);
    struct tcp_sock *tp = tcp_sk(sk);
    int eaten = -1;
.......................................
///首先判斷skb的開始序列號和我們想要接收的序列號。如果相等開始處理這個數據包(也就是拷貝到用戶空間).
    if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
        if (tcp_receive_window(tp) == 0)
            goto out_of_window;

//tp的ucopy我前面的blog已經詳細分析過了。這裏就不解釋了。
        if (tp->ucopy.task == current &&
            tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&sock_owned_by_user(sk) && !tp->urg_data)
{
///計算將要拷貝給用戶空間的大小。
            int chunk = min_t(unsigned int, skb->len,tp->ucopy.len);

///設置狀態，說明我們處於進程上下文。
            __set_current_state(TASK_RUNNING);

            local_bh_enable();
///拷貝skb
            if (!skb_copy_datagram_iovec(skb, 0, tp->ucopy.iov, chunk)) {
                tp->ucopy.len -= chunk;
                tp->copied_seq += chunk;
///更新eaten，它的默認值爲-1.
        eaten = (chunk == skb->len && !th->fin);
        tcp_rcv_space_adjust(sk);
            }
            local_bh_disable();
        }

///如果小於0則說明沒有拷貝成功，或者說就沒有進行拷貝。此時需要更新sock的相關域。
    if (eaten <= 0) {
queue_and_out:
///最關鍵的tcp_try_rmem_schedule函數。接下來會詳細分析。
    if (eaten < 0 &&
         tcp_try_rmem_schedule(sk, skb->truesize))
                goto drop;

///關聯skb和sk。到達這裏說明tcp_try_rmem_schedule成功，也就是返回0.
        skb_set_owner_r(skb, sk);
///加skb到receive_queue.
        __skb_queue_tail(&sk->sk_receive_queue, skb);
        }
///更新期待序列號。
        tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
..............................................
        }
.....................................

        tcp_fast_path_check(sk);

        if (eaten > 0)
            __kfree_skb(skb);
        else if (!sock_flag(sk, SOCK_DEAD))
            sk->sk_data_ready(sk, 0);
        return;
    }
///下面就是處理亂序包。以後會詳細分析。
......................................
}

接下來我們就來看tcp_try_rmem_schedule這個函數,這個函數如果返回0則說明sk_rmem_schedule返回1,而sk_rmem_schedule和sk_wmem_schedule是一樣的。也就是看當前的skb加入後有沒有超過讀buf的限制。並更新相關的域。： 

static inline int tcp_try_rmem_schedule(struct sock *sk, unsigned int size)
{
///首先判斷rmem_alloc(當前的讀buf字節數)是否大於最大buf字節數，如果大於則調用tcp_prune_queue調整分配的buf。否則調用sk_rmem_schedule來調整相關域（sk_forward_alloc）。
    if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||!sk_rmem_schedule(sk, size)) {

///調整分配的buf。
        if (tcp_prune_queue(sk) < 0)
            return -1;
///更新sk的相關域。
        if (!sk_rmem_schedule(sk, size)) {
            if (!tcp_prune_ofo_queue(sk))
                return -1;

            if (!sk_rmem_schedule(sk, size))
                return -1;
        }
    }
    return 0;
}

來看sk_rmem_schedule，這個函數很簡單，就是封裝了__sk_mem_schedule。而這個函數我們上面已經分析過了。 

static inline int sk_rmem_schedule(struct sock *sk, int size)
{
    if (!sk_has_account(sk))
        return 1;
    return size <= sk->sk_forward_alloc ||
        __sk_mem_schedule(sk, size, SK_MEM_RECV);
}

最後是tcp_prune_queue，這個函數主要是用來丟掉一些skb，因爲到這個函數就說明我們的內存使用已經到極限了，因此我們要合併一些buf。這個合併也就是將序列號連續的段進行合併。 

這裏我們要知道tcp的包是有序的，因此內核中tcp專門有一個隊列來保存那些Out of order segments。因此我們這裏會先處理這個隊列裏面的skb。 

然後調用tcp_collapse來處理接收隊列裏面的skb。和上面的類似。 

這裏要注意，合併的話都是按頁來合併，也就是先分配一頁大小的內存，然後將老的skb複製進去，最後free掉老的buf。 

static int tcp_prune_queue(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
..................................
///如果rmem_alloc過於大，則重新計算窗口的大小。一半都會縮小窗口。
    if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
        tcp_clamp_window(sk);
///如果處於pressure區域，則調整窗口大小。這裏也是縮小窗口。
    else if (tcp_memory_pressure)
        tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

///處理ofo隊列。
    tcp_collapse_ofo_queue(sk);
///如果接收隊列爲非空，則調用tcp_collapse來處理sk_receive_queue
    if (!skb_queue_empty(&sk->sk_receive_queue))
        tcp_collapse(sk, &sk->sk_receive_queue,
                 skb_peek(&sk->sk_receive_queue),
                 NULL,
                 tp->copied_seq, tp->rcv_nxt);
///更新全局的已分配內存的大小，也就是memory_allocated，接下來會詳細介紹這個函數。
    sk_mem_reclaim(sk);

///如果調整後小於sk_rcvbuf,則返回0.
    if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
        return 0;

......................................
    return -1;
}

來看sk_mem_reclaim函數，它只是簡單的封裝了__sk_mem_reclaim： 

static inline void sk_mem_reclaim(struct sock *sk)
{
    if (!sk_has_account(sk))
        return;
///如果sk_forward_alloc大於1頁則調用__sk_mem_reclaim，我們知道sk_forward_alloc是以頁爲單位的，因此這裏也就是和大於0一樣。
    if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
        __sk_mem_reclaim(sk);
}

這裏我們對tcp_collapse和tcp_collapse_ofo_queue對沒有詳細分析，只是簡要的描述了下。 

__sk_mem_reclaim就是真正操作的函數，它會更新memory_allocated： 

void __sk_mem_reclaim(struct sock *sk)
{
    struct proto *prot = sk->sk_prot;
//更新memory_allocated，這裏我們知道memory_allocated也是以頁爲單位的，因此需要將sk_forward_alloc轉化爲頁。
    atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,prot->memory_allocated);

//更新這個sk的sk_forward_alloc爲一頁。
    sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
///判斷是否處於pressure區域，是的話更新memory_pressure變量。
    if (prot->memory_pressure && *prot->memory_pressure &&(atomic_read(prot->memory_allocated) < （prot->sysctl_mem[0]))
        *prot->memory_pressure = 0;
}

最後看一下讀buf的釋放。這個函數會在kfree_skb中被調用。 

void sock_rfree(struct sk_buff *skb)
{

    struct sock *sk = skb->sk;
///更新rmem_alloc
    atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
///更新forward_alloc.
    sk_mem_uncharge(skb->sk, skb->truesize);
}