我们结合源码进行仔细分析：

接收端调用的是＿＿sys＿recvfrom函数：

＿＿sys＿recvfrom函数具体如下：

发现它调用了sock＿recvmsg函数：

发现它调用了sock＿recvmsg＿nosec函数：

发现它调用了inet＿recvmsg函数：

最后调用的是tcp＿recvmsg这个系统调用。至此接收端调用分析完毕。

下面用gdb打断点进行验证：

验证结果刚好符合我们的调研。

4 传输层流程

4．1 发送端

传输层的最终目的是向它的用户提供高效的、可靠的和成本有效的数据传输服务，主要功能包括 （1）构造 TCP segment （2）计算 checksum （3）发送回复（ACK）包 （4）滑动窗口（sliding windown）等保证可靠性的操作。TCP 协议栈的大致处理过程如下图所示：

TCP 栈简要过程：

tcp＿sendmsg 函数会首先检查已经建立的 TCP connection 的状态，然后获取该连接的 MSS，开始 segement 发送流程。

构造 TCP 段的 playload：它在内核空间中创建该 packet 的 sk＿buffer 数据结构的实例 skb，从 userspace buffer 中拷贝 packet 的数据到 skb 的 buffer。

构造 TCP header。

计算 TCP 校验和（checksum）和 顺序号 （sequence number）。

TCP 校验和是一个端到端的校验和，由发送端计算，然后由接收端验证。其目的是为了发现TCP首部和数据在发送端到接收端之间发生的任何改动。如果接收方检测到校验和有差错，则TCP段会被直接丢弃。TCP校验和覆盖 TCP 首部和 TCP 数据。

TCP的校验和是必需的

发到 IP 层处理：调用 IP handler 句柄 ip＿queue＿xmit，将 skb 传入 IP 处理流程。

UDP 栈简要过程：

UDP 将 message 封装成 UDP 数据报

调用 ip＿append＿data（） 方法将 packet 送到 IP 层进行处理。

下面我们结合代码依次分析：

根据我们对应用层的追查可以发现，传输层也是先调用send（）－＞sendto（）－＞sys＿sento－＞sock＿sendmsg－＞sock＿sendmsg＿nosec，我们看下sock＿sendmsg＿nosec这个函数：

在应用层调用的是inet＿sendmsg函数，在传输层根据后面的断点可以知道，调用的是sock－＞ops－sendmsg这个函数。而sendmsg为一个宏，调用的是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，
   ．accept            ＝ 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实际上调用的是

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

这个函数如下：

int tcp＿sendmsg＿locked（struct sock ＊sk， struct msghdr ＊msg， size＿t size）
｛
struct tcp＿sock ＊tp ＝ tcp＿sk（sk）；进行了强制类型转换
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中，完成的是将所有的数据组织成发送队列，这个发送队列是struct sock结构中的一个域sk＿write＿queue，这个队列的每一个元素是一个skb，里面存放的就是待发送的数据。然后调用了tcp＿push（）函数。结构体struct sock如下：

struct sock｛
   ．．．
struct sk＿buff＿head    sk＿write＿queue；指向skb队列的第一个元素
   ．．．
struct sk＿buff    ＊sk＿send＿head；指向队列第一个还没有发送的元素
｝

在tcp协议的头部有几个标志字段：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 （！（flags ＆ 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个字节的数组，类型转换为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个字节tcp［13］）    
   ．．．．．．
｝；

然后，tcp＿push调用了＿＿tcp＿push＿pending＿frames（sk， mss＿now， nonagle）；函数发送数据：

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）；
｝

发现它调用了tcp＿write＿xmit函数来发送数据：

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；
统计已发送的报文总数
   sent＿pkts ＝ 0；
   ．．．．．．
若发送队列未满，则准备发送报文
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）；
检查发送窗口的大小
       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中，它实现了tcp的拥塞控制，然后调用了tcp＿transmit＿skb（sk， skb， 1， gfp）传输数据，实际上调用的是＿＿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发送数据位于传输层的最后一步，这里首先对TCP数据段的头部进行了处理，然后调用了网络层提供的发送接口icsk－＞icsk＿af＿ops－＞queue＿xmit（sk， skb， ＆inet－＞cork．fl）；实现了数据的发送，自此，数据离开了传输层，传输层的任务也就结束了。

gdb调试验证如下：

4．2 接收端

传输层 TCP 处理入口在 tcp＿v4＿rcv 函数（位于 linux／net／ipv4／tcp ipv4．c 文件中），它会做 TCP header 检查等处理。

调用 ＿tcp＿v4＿lookup，查找该 package 的 open socket。如果找不到，该 package 会被丢弃。接下来检查 socket 和 connection 的状态。

如果socket 和 connection 一切正常，调用 tcp＿prequeue 使 package 从内核进入 user space，放进 socket 的 receive queue。然后 socket 会被唤醒，调用 system call，并最终调用 tcp＿recvmsg 函数去从 socket recieve queue 中获取 segment。

对于传输层的代码阶段，我们需要分析recv函数，这个与send类似，调用的是＿＿sys＿recvfrom，整个函数的调用路径与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调用了sock＿recvmsg来接收数据，整个函数实际调用的是sock－＞ops－＞recvmsg（sock， msg， msg＿data＿left（msg）， flags）；，同样，根据tcp＿prot结构的初始化，调用的其实是tcp＿rcvmsg

接受函数比发送函数要复杂得多，因为数据接收不仅仅只是接收，tcp的三次握手也是在接收函数实现的，所以收到数据后要判断当前的状态，是否正在建立连接等，根据发来的信息考虑状态是否要改变，在这里，我们仅仅考虑在连接建立后数据的接收。

tcp＿rcvmsg函数如下：

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 （！（flags ＆ 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）；