我們結合源碼進行仔細分析：

接收端調(diào)用的是＿＿sys＿recvfrom函數(shù)：

＿＿sys＿recvfrom函數(shù)具體如下：

發(fā)現(xiàn)它調(diào)用了sock＿recvmsg函數(shù)：

發(fā)現(xiàn)它調(diào)用了sock＿recvmsg＿nosec函數(shù)：

發(fā)現(xiàn)它調(diào)用了inet＿recvmsg函數(shù)：

最后調(diào)用的是tcp＿recvmsg這個系統(tǒng)調(diào)用。至此接收端調(diào)用分析完畢。

下面用gdb打斷點進行驗證：

驗證結果剛好符合我們的調(diào)研。

4 傳輸層流程

4．1 發(fā)送端

傳輸層的最終目的是向它的用戶提供高效的、可靠的和成本有效的數(shù)據(jù)傳輸服務，主要功能包括 （1）構造 TCP segment （2）計算 checksum （3）發(fā)送回復（ACK）包 （4）滑動窗口（sliding windown）等保證可靠性的操作。TCP 協(xié)議棧的大致處理過程如下圖所示：

TCP 棧簡要過程：

tcp＿sendmsg 函數(shù)會首先檢查已經(jīng)建立的 TCP connection 的狀態(tài)，然后獲取該連接的 MSS，開始 segement 發(fā)送流程。

構造 TCP 段的 playload：它在內(nèi)核空間中創(chuàng)建該 packet 的 sk＿buffer 數(shù)據(jù)結構的實例 skb，從 userspace buffer 中拷貝 packet 的數(shù)據(jù)到 skb 的 buffer。

構造 TCP header。

計算 TCP 校驗和（checksum）和 順序號 （sequence number）。

TCP 校驗和是一個端到端的校驗和，由發(fā)送端計算，然后由接收端驗證。其目的是為了發(fā)現(xiàn)TCP首部和數(shù)據(jù)在發(fā)送端到接收端之間發(fā)生的任何改動。如果接收方檢測到校驗和有差錯，則TCP段會被直接丟棄。TCP校驗和覆蓋 TCP 首部和 TCP 數(shù)據(jù)。

TCP的校驗和是必需的

發(fā)到 IP 層處理：調(diào)用 IP handler 句柄 ip＿queue＿xmit，將 skb 傳入 IP 處理流程。

UDP 棧簡要過程：

UDP 將 message 封裝成 UDP 數(shù)據(jù)報

調(diào)用 ip＿append＿data（） 方法將 packet 送到 IP 層進行處理。

下面我們結合代碼依次分析：

根據(jù)我們對應用層的追查可以發(fā)現(xiàn)，傳輸層也是先調(diào)用send（）－＞sendto（）－＞sys＿sento－＞sock＿sendmsg－＞sock＿sendmsg＿nosec，我們看下sock＿sendmsg＿nosec這個函數(shù)：

在應用層調(diào)用的是inet＿sendmsg函數(shù)，在傳輸層根據(jù)后面的斷點可以知道，調(diào)用的是sock－＞ops－sendmsg這個函數(shù)。而sendmsg為一個宏，調(diào)用的是tcp＿sendmsg，如下；

struct proto tcp＿prot ＝ ｛
   ．name            ＝ ＂TCP＂，
   ．owner            ＝ THIS＿MODULE，
   ．close            ＝ tcp＿close，
   ．pre＿connect        ＝ tcp＿v4＿pre＿connect，
   ．connect        ＝ tcp＿v4＿connect，
   ．disconnect        ＝ tcp＿disconnect，
   ．a(chǎn)ccept            ＝ inet＿csk＿accept，
   ．ioctl            ＝ tcp＿ioctl，
   ．init            ＝ tcp＿v4＿init＿sock，
   ．destroy        ＝ tcp＿v4＿destroy＿sock，
   ．shutdown        ＝ tcp＿shutdown，
   ．setsockopt        ＝ tcp＿setsockopt，
   ．getsockopt        ＝ tcp＿getsockopt，
   ．keepalive        ＝ tcp＿set＿keepalive，
   ．recvmsg        ＝ tcp＿recvmsg，
   ．sendmsg        ＝ tcp＿sendmsg，
   ．．．．．．

而tcp＿sendmsg實際上調(diào)用的是

int tcp＿sendmsg＿locked（struct sock ＊sk， struct msghdr ＊msg， size＿t size）

這個函數(shù)如下：

int tcp＿sendmsg＿locked（struct sock ＊sk， struct msghdr ＊msg， size＿t size）
｛
struct tcp＿sock ＊tp ＝ tcp＿sk（sk）；進行了強制類型轉(zhuǎn)換
struct sk＿buff ＊skb；
   flags ＝ msg－＞msg＿flags；
   ．．．．．．
if （copied）
           tcp＿push（sk， flags ＆ ～MSG＿MORE， mss＿now，
                TCP＿NAGLE＿PUSH， size＿goal）；
｝

在tcp＿sendmsg＿locked中，完成的是將所有的數(shù)據(jù)組織成發(fā)送隊列，這個發(fā)送隊列是struct sock結構中的一個域sk＿write＿queue，這個隊列的每一個元素是一個skb，里面存放的就是待發(fā)送的數(shù)據(jù)。然后調(diào)用了tcp＿push（）函數(shù)。結構體struct sock如下：

struct sock｛
   ．．．
struct sk＿buff＿head    sk＿write＿queue；指向skb隊列的第一個元素
   ．．．
struct sk＿buff    ＊sk＿send＿head；指向隊列第一個還沒有發(fā)送的元素
｝

在tcp協(xié)議的頭部有幾個標志字段：URG、ACK、RSH、RST、SYN、FIN，tcp＿push中會判斷這個skb的元素是否需要push，如果需要就將tcp頭部字段的push置一，置一的過程如下：

static void tcp＿push（struct sock ＊sk， int flags， int mss＿now，
int nonagle， int size＿goal）
｛
struct tcp＿sock ＊tp ＝ tcp＿sk（sk）；
struct sk＿buff ＊skb；
   skb ＝ tcp＿write＿queue＿tail（sk）；
if （！skb）
return；
if （�。╢lags ＆ MSG＿MORE） ｜｜ forced＿push（tp））
       tcp＿mark＿push（tp， skb）；
   tcp＿mark＿urg（tp， flags）；
if （tcp＿should＿autocork（sk， skb， size＿goal）） ｛
avoid atomic op if TSQ＿THROTTLED bit is already set
if （！test＿bit（TSQ＿THROTTLED， ＆sk－＞sk＿tsq＿flags）） ｛
           NET＿INC＿STATS（sock＿net（sk）， LINUX＿MIB＿TCPAUTOCORKING）；
           set＿bit（TSQ＿THROTTLED， ＆sk－＞sk＿tsq＿flags）；
       ｝
It is possible TX completion already happened
        ＊ before we set TSQ＿THROTTLED．
       
if （refcount＿read（＆sk－＞sk＿wmem＿alloc） ＞ skb－＞truesize）
return；
   ｝
if （flags ＆ MSG＿MORE）
       nonagle ＝ TCP＿NAGLE＿CORK；
   ＿＿tcp＿push＿pending＿frames（sk， mss＿now， nonagle）；
｝

首先struct tcp＿skb＿cb結構體存放的就是tcp的頭部，頭部的控制位為tcp＿flags，通過tcp＿mark＿push會將skb中的cb，也就是48個字節(jié)的數(shù)組，類型轉(zhuǎn)換為struct tcp＿skb＿cb，這樣位于skb的cb就成了tcp的頭部。tcp＿mark＿push如下：

static inline void tcp＿mark＿push（struct tcp＿sock ＊tp， struct sk＿buff ＊skb）
｛
   TCP＿SKB＿CB（skb）－＞tcp＿flags ｜＝ TCPHDR＿PSH；
   tp－＞pushed＿seq ＝ tp－＞write＿seq；
｝
．．．
＃define TCP＿SKB＿CB（＿＿skb）    （（struct tcp＿skb＿cb ＊）＆（（＿＿skb）－＞cb［0］））
．．．
struct sk＿buff ｛
   ．．．    
char            cb［48］ ＿＿aligned（8）；
   ．．．struct tcp＿skb＿cb ｛
   ＿＿u32        seq；         Starting sequence number    
   ＿＿u32        end＿seq；     SEQ ＋ FIN ＋ SYN ＋ datalen    
   ＿＿u8        tcp＿flags；     tcp頭部標志，位于第13個字節(jié)tcp［13］）    
   ．．．．．．
｝；

然后，tcp＿push調(diào)用了＿＿tcp＿push＿pending＿frames（sk， mss＿now， nonagle）；函數(shù)發(fā)送數(shù)據(jù)：

void ＿＿tcp＿push＿pending＿frames（struct sock ＊sk， unsigned int cur＿mss，
int nonagle）
｛
if （tcp＿write＿xmit（sk， cur＿mss， nonagle， 0，
              sk＿gfp＿mask（sk， GFP＿ATOMIC）））
       tcp＿check＿probe＿timer（sk）；
｝

發(fā)現(xiàn)它調(diào)用了tcp＿write＿xmit函數(shù)來發(fā)送數(shù)據(jù)：

static bool tcp＿write＿xmit（struct sock ＊sk， unsigned int mss＿now， int nonagle，
int push＿one， gfp＿t gfp）
｛
struct tcp＿sock ＊tp ＝ tcp＿sk（sk）；
struct sk＿buff ＊skb；
unsigned int tso＿segs， sent＿pkts；
int cwnd＿quota；
int result；
bool is＿cwnd＿limited ＝ false， is＿rwnd＿limited ＝ false；
   u32 max＿segs；
統(tǒng)計已發(fā)送的報文總數(shù)
   sent＿pkts ＝ 0；
   ．．．．．．
若發(fā)送隊列未滿，則準備發(fā)送報文
while （（skb ＝ tcp＿send＿head（sk））） ｛
unsigned int limit；
if （unlikely（tp－＞repair） ＆＆ tp－＞repair＿queue ＝＝ TCP＿SEND＿QUEUE） ｛
＂skb＿mstamp＿ns＂ is used as a start point for the retransmit timer
           skb－＞skb＿mstamp＿ns ＝ tp－＞tcp＿wstamp＿ns ＝ tp－＞tcp＿clock＿cache；
           list＿move＿tail（＆skb－＞tcp＿tsorted＿anchor， ＆tp－＞tsorted＿sent＿queue）；
           tcp＿init＿tso＿segs（skb， mss＿now）；
goto repair；  Skip network transmission
       ｝
if （tcp＿pacing＿check（sk））
break；
       tso＿segs ＝ tcp＿init＿tso＿segs（skb， mss＿now）；
       BUG＿ON（！tso＿segs）；
檢查發(fā)送窗口的大小
       cwnd＿quota ＝ tcp＿cwnd＿test（tp， skb）；
if （！cwnd＿quota） ｛
if （push＿one ＝＝ 2）
Force out a loss probe pkt．
               cwnd＿quota ＝ 1；
else
break；
       ｝
if （unlikely（！tcp＿snd＿wnd＿test（tp， skb， mss＿now））） ｛
           is＿rwnd＿limited ＝ true；
break；
       ．．．．．．
       limit ＝ mss＿now；
if （tso＿segs ＞ 1 ＆＆ ！tcp＿urg＿mode（tp））
           limit ＝ tcp＿mss＿split＿point（sk， skb， mss＿now，
min＿t（unsigned int，
                             cwnd＿quota，
                             max＿segs），
                           nonagle）；
if （skb－＞len ＞ limit ＆＆
           unlikely（tso＿fragment（sk， TCP＿FRAG＿IN＿WRITE＿QUEUE，
                     skb， limit， mss＿now， gfp）））
break；
if （tcp＿small＿queue＿check（sk， skb， 0））
break；
if （unlikely（tcp＿transmit＿skb（sk， skb， 1， gfp）））
break；
   ．．．．．．

tcp＿write＿xmit位于tcpoutput．c中，它實現(xiàn)了tcp的擁塞控制，然后調(diào)用了tcp＿transmit＿skb（sk， skb， 1， gfp）傳輸數(shù)據(jù)，實際上調(diào)用的是＿＿tcp＿transmit＿skb：

static int ＿＿tcp＿transmit＿skb（struct sock ＊sk， struct sk＿buff ＊skb，
                 int clone＿it， gfp＿t gfp＿mask， u32 rcv＿nxt）
｛
   skb＿push（skb， tcp＿header＿size）；
   skb＿reset＿transport＿header（skb）；
   ．．．．．．
構建TCP頭部和校驗和
   th ＝ （struct tcphdr ＊）skb－＞data；
   th－＞source        ＝ inet－＞inet＿sport；
   th－＞dest        ＝ inet－＞inet＿dport；
   th－＞seq            ＝ htonl（tcb－＞seq）；
   th－＞ack＿seq        ＝ htonl（rcv＿nxt）；
   tcp＿options＿write（（＿＿be32 ＊）（th ＋ 1）， tp， ＆opts）；
   skb＿shinfo（skb）－＞gso＿type ＝ sk－＞sk＿gso＿type；
if （likely（！（tcb－＞tcp＿flags ＆ TCPHDR＿SYN））） ｛
       th－＞window      ＝ htons（tcp＿select＿window（sk））；
       tcp＿ecn＿send（sk， skb， th， tcp＿header＿size）；
   ｝ else ｛
RFC1323： The window in SYN ＆ SYN／ACK segments
        ＊ is never scaled．
       
       th－＞window    ＝ htons（min（tp－＞rcv＿wnd， 65535U））；
   ｝
   ．．．．．．
   icsk－＞icsk＿af＿ops－＞send＿check（sk， skb）；
if （likely（tcb－＞tcp＿flags ＆ TCPHDR＿ACK））
       tcp＿event＿ack＿sent（sk， tcp＿skb＿pcount（skb）， rcv＿nxt）；
if （skb－＞len ！＝ tcp＿header＿size） ｛
       tcp＿event＿data＿sent（tp， sk）；
       tp－＞data＿segs＿out ＋＝ tcp＿skb＿pcount（skb）；
       tp－＞bytes＿sent ＋＝ skb－＞len － tcp＿header＿size；
   ｝
if （after（tcb－＞end＿seq， tp－＞snd＿nxt） ｜｜ tcb－＞seq ＝＝ tcb－＞end＿seq）
       TCP＿ADD＿STATS（sock＿net（sk）， TCP＿MIB＿OUTSEGS，
                 tcp＿skb＿pcount（skb））；
   tp－＞segs＿out ＋＝ tcp＿skb＿pcount（skb）；
OK， its time to fill skb＿shinfo（skb）－＞gso＿｛segs｜size｝
   skb＿shinfo（skb）－＞gso＿segs ＝ tcp＿skb＿pcount（skb）；
   skb＿shinfo（skb）－＞gso＿size ＝ tcp＿skb＿mss（skb）；
Leave earliest departure time in skb－＞tstamp （skb－＞skb＿mstamp＿ns）
Cleanup our debris for IP stacks
   memset（skb－＞cb， 0， max（sizeof（struct inet＿skb＿parm），
                  sizeof（struct inet6＿skb＿parm）））；
   err ＝ icsk－＞icsk＿af＿ops－＞queue＿xmit（sk， skb， ＆inet－＞cork．fl）；
   ．．．．．．
｝

tcp＿transmit＿skb是tcp發(fā)送數(shù)據(jù)位于傳輸層的最后一步，這里首先對TCP數(shù)據(jù)段的頭部進行了處理，然后調(diào)用了網(wǎng)絡層提供的發(fā)送接口icsk－＞icsk＿af＿ops－＞queue＿xmit（sk， skb， ＆inet－＞cork．fl）；實現(xiàn)了數(shù)據(jù)的發(fā)送，自此，數(shù)據(jù)離開了傳輸層，傳輸層的任務也就結束了。

gdb調(diào)試驗證如下：

4．2 接收端

傳輸層 TCP 處理入口在 tcp＿v4＿rcv 函數(shù)（位于 linux／net／ipv4／tcp ipv4．c 文件中），它會做 TCP header 檢查等處理。

調(diào)用 ＿tcp＿v4＿lookup，查找該 package 的 open socket。如果找不到，該 package 會被丟棄。接下來檢查 socket 和 connection 的狀態(tài)。

如果socket 和 connection 一切正常，調(diào)用 tcp＿prequeue 使 package 從內(nèi)核進入 user space，放進 socket 的 receive queue。然后 socket 會被喚醒，調(diào)用 system call，并最終調(diào)用 tcp＿recvmsg 函數(shù)去從 socket recieve queue 中獲取 segment。

對于傳輸層的代碼階段，我們需要分析recv函數(shù)，這個與send類似，調(diào)用的是＿＿sys＿recvfrom，整個函數(shù)的調(diào)用路徑與send非常類似：

int ＿＿sys＿recvfrom（int fd， void ＿＿user ＊ubuf， size＿t size， unsigned int flags，
struct sockaddr ＿＿user ＊addr， int ＿＿user ＊addr＿len）
｛
   ．．．．．．
   err ＝ import＿single＿range（READ， ubuf， size， ＆iov， ＆msg．msg＿iter）；
if （unlikely（err））
return err；
   sock ＝ sockfd＿lookup＿light（fd， ＆err， ＆fput＿needed）；
   ．．．．．
   msg．msg＿control ＝ NULL；
   msg．msg＿controllen ＝ 0；
Save some cycles and don＇t copy the address if not needed
   msg．msg＿name ＝ addr ？ （struct sockaddr ＊）＆address ： NULL；
We assume all kernel code knows the size of sockaddr＿storage
   msg．msg＿namelen ＝ 0；
   msg．msg＿iocb ＝ NULL；
   msg．msg＿flags ＝ 0；
if （sock－＞file－＞f＿flags ＆ O＿NONBLOCK）
       flags ｜＝ MSG＿DONTWAIT；
   err ＝ sock＿recvmsg（sock， ＆msg， flags）；
if （err ＞＝ 0 ＆＆ addr �。� NULL） ｛
       err2 ＝ move＿addr＿to＿user（＆address，
                    msg．msg＿namelen， addr， addr＿len）；
   ．．．．．
｝

＿＿sys＿recvfrom調(diào)用了sock＿recvmsg來接收數(shù)據(jù)，整個函數(shù)實際調(diào)用的是sock－＞ops－＞recvmsg（sock， msg， msg＿data＿left（msg）， flags）；，同樣，根據(jù)tcp＿prot結構的初始化，調(diào)用的其實是tcp＿rcvmsg

接受函數(shù)比發(fā)送函數(shù)要復雜得多，因為數(shù)據(jù)接收不僅僅只是接收，tcp的三次握手也是在接收函數(shù)實現(xiàn)的，所以收到數(shù)據(jù)后要判斷當前的狀態(tài)，是否正在建立連接等，根據(jù)發(fā)來的信息考慮狀態(tài)是否要改變，在這里，我們僅僅考慮在連接建立后數(shù)據(jù)的接收。

tcp＿rcvmsg函數(shù)如下：

int tcp＿recvmsg（struct sock ＊sk， struct msghdr ＊msg， size＿t len， int nonblock，
int flags， int ＊addr＿len）
｛
．．．．．．
if （sk＿can＿busy＿loop（sk） ＆＆ skb＿queue＿empty（＆sk－＞sk＿receive＿queue） ＆＆
（sk－＞sk＿state ＝＝ TCP＿ESTABLISHED））
sk＿busy＿loop（sk， nonblock）；
lock＿sock（sk）；
．．．．．
if （unlikely（tp－＞repair）） ｛
err ＝ －EPERM；
if （�。╢lags ＆ MSG＿PEEK））
goto out；
if （tp－＞repair＿queue ＝＝ TCP＿SEND＿QUEUE）
goto recv＿sndq；
err ＝ －EINVAL；
if （tp－＞repair＿queue ＝＝ TCP＿NO＿QUEUE）
goto out；
．．．．．．
last ＝ skb＿peek＿tail（＆sk－＞sk＿receive＿queue）；
skb＿queue＿walk（＆sk－＞sk＿receive＿queue， skb） ｛
last ＝ skb；
．．．．．．
if （！（flags ＆ MSG＿TRUNC）） ｛
err ＝ skb＿copy＿datagram＿msg（skb， offset， msg， used）；
if （err） ｛
Exception． Bailout！
if （！copied）
copied ＝ －EFAULT；
break；
｝
｝
＊seq ＋＝ used；
copied ＋＝ used；
len －＝ used；
tcp＿rcv＿space＿adjust（sk）；