在分析之前先來看下SO_RCVTIMEO和SO_SNDTIMEO套接口吧,前面分析代碼時沒太注意這兩個.這里算是個補充.

SO_RCVTIMEO和SO_SNDTIMEO套接口選項可以給套接口的讀和寫,來設置超時時間,在unix網絡編程中,說是他們只能用于讀和

寫,而像accept和connect都不能用他們來設置.可是我在閱讀內核源碼的過程中看到,在linux中,accept和connect可以分別用

SO_RCVTIMEO和SO_SNDTIMEO套接口來設置超時,這里他們的超時時間也就是sock的sk_rcvtimeo和sk_sndtimeo

域.accept和connect的相關代碼我前面都介紹過了,這里再提一下.其中accept的相關部分在inet_csk_accept中,會調用

sock_rcvtimeo來取得超時時間(如果是非阻塞則忽略超時間).而connect的相關代碼在inet_stream_connect中通過調

用sock_sndtimeo來取得超時時間(如果非阻塞則忽略超時時間).

---------------------------------------------------------------------------------

tcp發送數據最終都會調用到tcp_sendmsg,舉個例子吧,比如send系統調用.

send系統調用會z直接調用sys_sendto,然后填充msghdr數據結構,并調用sock_sendmsg,而在他中,則最終會調用__sock_sendmsg.在這個函數里面會初始化sock_iocb結構,然后調用tcp_sendmsg.

在sys_sendto中還會做和前面幾個系統調用差不多的操作,就是通過fd得到socket,在sock_sendmsg中則會設置aio所需的操作.

我們簡要的看下__sock_sendmsg的實現.可以看到在內核中數據都是用msghdr來表示的(也就是會將char *轉為msghdr),而這個結構這里就不介紹了,unix網絡編程里面有詳細的介紹.而struct kiocb則是aio會用到的.

static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,

struct msghdr *msg, size_t size)

{

struct sock_iocb *si = kiocb_to_siocb(iocb);

int err;

si->sock = sock;

si->scm = NULL;

si->msg = msg;

si->size = size;

err = security_socket_sendmsg(sock, msg, size);

if (err)

return err;

///這里就會調用tcp_sendmsg.

return sock->ops->sendmsg(iocb, sock, msg, size);

}

我們在前面知道tcp將數據傳遞給ip層的時候調用ip_queue_xmit,而在這個函數沒有做任何切片的工作,切片的工作都在tcp層完成了.而udp則是需要在ip層進行切片(通過ip_append_data). 而tcp的數據是字節流的,因此在

tcp_sendmsg中主要做的工作就是講字節流分段(根據mss),然后傳遞給ip層. 可以看到它的任務和ip_append_data很類似,流程其實也差不多. 所以有興趣的可以看下我前面的blog

而在tcp_sendmsg中也是要看網卡是否支持Scatter/Gather I/O,從而進行相關操作.

下面我們來看它的實現,我們分段來看:

///首先取出句柄的flag,主要是看是非阻塞還是阻塞模式.

flags = msg->msg_flags;

///這里取得發送超時時間.

timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);

///如果connect還沒有完成則等待連接完成(如是非阻塞則直接返回).

if ((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))

if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)

goto out_err;

/* This should be in poll */

clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

///取出當前的mss,在tcp_current_mss還會設置xmit_size_goal,這個值一般都是等于mss,除非有gso的情況下,有所不同.這里我們就認為他是和mms相等的.

mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));

size_goal = tp->xmit_size_goal;

在取得了相關的值之后我們進入循環處理msg,我們知道msghdr有可能是包含很多buffer的,因此這里我們分為兩層循環,一層是遍歷msg的buffer,一層是對buffer進行處理(切包或者組包)并發送給ip層.

首先來看當buf空間不夠時的情況,它這里判斷buf空間是否足夠是通過

!tcp_send_head(sk) ||

(copy = size_goal - skb->len) <= 0

來判斷的,這里稍微解釋下這個:

這里tcp_send_head返回值為sk->sk_send_head,也就是指向當前的將要發送的buf的位置.如果為空,則說明buf沒有空間,我們就需要alloc一個段來保存將要發送的msg.

而skb->len指的是當前的skb的所包含的數據的大小(包含頭的大小).而這個值如果大于size_goal,則說明buf已滿,我

們需要重新alloc一個端.如果小于size_goal,則說明buf還有空間來容納一些數據來組成一個等于mss的數據包再發送給ip層.

/* Ok commence sending. */

iovlen = msg->msg_iovlen;

iov = msg->msg_iov;

///copy的大小

copied = 0;

err = -EPIPE;

///如果發送端已經完全關閉則返回,并設置errno.

if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))

goto do_error;

while (--iovlen >= 0) {

///取得當前buf長度

int seglen = iov->iov_len;

///buf的基地址.

unsigned char __user *from = iov->iov_base;

iov++;

while (seglen > 0) {

int copy;

///我們知道sock的發送隊列sk_write_queue是一個雙向鏈表,而用tcp_write_queue_tail則是取得鏈表的最后一個元素.(如果鏈表為空則返回NULL).

skb = tcp_write_queue_tail(sk);

///上面介紹過了.主要是判斷buf是否有空閑空間.

if (!tcp_send_head(sk) ||

(copy = size_goal - skb->len) <= 0) {

new_segment:

///開始alloc一個新的段.

if (!sk_stream_memory_free(sk))

goto wait_for_sndbuf;

///alloc的大小一般都是等于mss的大小,這里是通過select_size得到的.

skb = sk_stream_alloc_skb(sk, select_size(sk),

sk->sk_allocation);

if (!skb)

goto wait_for_memory;

/*

* Check whether we can use HW checksum.

*/

if (sk->sk_route_caps & NETIF_F_ALL_CSUM)

skb->ip_summed = CHECKSUM_PARTIAL;

///將這個skb加入到sk_write_queue隊列中,并更新sk_send_head域.

skb_entail(sk, skb);

///將copy值更新.

copy = size_goal;

}

接下來如果走到這里,則說明 要么已經alloc一個新的buf,要么當前的buf中還有空閑空間.

這里先來分析alloc一個新的buf的情況.

這里先看下skb中的幾個域的含義:

head and end 指的是alloc了的buf的起始和終止位置,而data and tail 指的是數據段的起始和終止位置,因此經過每一層tail和data都會變化的,而初始值這兩個是相等的.

我們來看skb_tailroom,它主要是用來判斷得到當前的skb的tailroom的大小.tailroom也就是當前buf的剩余數據段的大小,這里也就是用來判斷當前buf是否能夠再添加數據.

static inline int skb_is_nonlinear(const struct sk_buff *skb)

{

return skb->data_len;

}

static inline int skb_tailroom(const struct sk_buff *skb)

{

///如果是新alloc的skb則會返回tailroom否則返回0

return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;

}

接下來來看代碼:

while (--iovlen >= 0) {

...........................

while (seglen > 0) {

///如果copy大于buf的大小,則縮小copy.

if (copy > seglen)

copy = seglen;

///這里查看skb的空間.如果大于0,則說明是新建的skb.

if (skb_tailroom(skb) > 0) {

///如果需要復制的數據大于所剩的空間,則先復制當前skb所能容納的大小.

if (copy > skb_tailroom(skb))

copy = skb_tailroom(skb);

///復制數據到sk_buff.大小為copy.如果成功進入do_fault,(我們下面會分析)

if ((err = skb_add_data(skb, from, copy)) != 0)

goto do_fault;

}

如果走到這一步,當前的sk buff中有空閑空間 也分兩種情況,一種是 設備支持Scatter/Gather I/O(原理和udp的ip_append_data一樣,可以看我以前的blog).

另外一種情況是設備不支持S/G IO,可是mss變大了.這種情況下我們需要返回new_segment,新建一個段,然后再處理.

\我建議在看這段代碼前,可以看下我前面blog分析ip_append_data的那篇.因為那里對S/G

IO的設備處理切片的分析比較詳細,而這里和那邊處理基本類似.這里我對frags的操作什么的都是很簡單的描述,詳細的在ip_append_data

那里已經描述過.

然后再來了解下PSH標記,這個標記主要是用來使接收方將sk->receive_queue上緩存的skb提交給用戶進程.詳細的介紹可

以看tcp協議的相關部分(推功能).在這里設置這個位會有兩種情況,第一種是我們寫了超過一半窗口大小的數據,此時我們需要標記最后一個段的PSH位.

或者我們有一個完整的tcp段發送出去,此時我們也需要標記pSH位.

while (--iovlen >= 0) {

...........................

while (seglen > 0) {

...............................

else {

int merge = 0;

///取得nr_frags也就是保存物理頁的數組.

int i = skb_shinfo(skb)->nr_frags;

///從socket取得當前的發送物理頁.

struct page *page = TCP_PAGE(sk);

///取得當前頁的位移.

int off = TCP_OFF(sk);

///這里主要是判斷skb的發送頁是否已經存在于nr_frags中,如果存在并且也沒有滿,則我們只需要將數據合并到這個頁就可以了,而不需要在frag再添加一個頁.

if (skb_can_coalesce(skb, i, page, off) &&

off != PAGE_SIZE) {

merge = 1;

} else if (i == MAX_SKB_FRAGS ||

(!i &&

!(sk->sk_route_caps & NETIF_F_SG))) {

///到這里說明要么設備不支持SG IO,要么頁已經滿了.因為我們知道nr_frags的大小是有限制的.此時調用tcp_mark_push來加一個PSH標記.

tcp_mark_push(tp, skb);

goto new_segment;

} else if (page) {

if (off == PAGE_SIZE) {

///這里說明當前的發送頁已滿.

put_page(page);

TCP_PAGE(sk) = page = NULL;

off = 0;

}

} else

off = 0;

if (copy > PAGE_SIZE - off)

copy = PAGE_SIZE - off;

.................................

///如果page為NULL則需要新alloc一個物理頁.

if (!page) {

/* Allocate new cache page. */

if (!(page = sk_stream_alloc_page(sk)))

goto wait_for_memory;

}

///開始復制數據到這個物理頁.

err = skb_copy_to_page(sk, from, skb, page,

off, copy);

if (err) {

///出錯的情況.

if (!TCP_PAGE(sk)) {

TCP_PAGE(sk) = page;

TCP_OFF(sk) = 0;

}

goto do_error;

}

///判斷是否為新建的物理頁.

if (merge) {

///如果只是在存在的物理頁添加數據,則只需要更新size

skb_shinfo(skb)->frags[i - 1].size +=

copy;

} else {

///負責添加此物理頁到skb的frags.

skb_fill_page_desc(skb, i, page, off, copy);

if (TCP_PAGE(sk)) {

///設置物理頁的引用計數.

get_page(page);

} else if (off + copy < PAGE_SIZE) {

get_page(page);

TCP_PAGE(sk) = page;

}

}

///設置位移.

TCP_OFF(sk) = off + copy;

}

數據復制完畢,接下來就該發送數據了.

這里我們要知道幾個tcp_push,tcp_one_push最終都會調用__tcp_push_pending_frames,而在它中間最

終會調用tcp_write_xmit,而tcp_write_xmit則會調用tcp_transmit_skb,這個函數最終會調用

ip_queue_xmit來講數據發送給ip層.這里要注意,我們這里的分析忽略掉了,tcp的一些管理以及信息交互的過程.

接下來看數據傳輸之前先來分析下TCP_PUSH幾個函數的實現,tcp_push這幾個類似函數的最后一個參數都是一個控制nagle算法的參數,來看下這幾個函數的原型:

static inline void tcp_push(struct sock *sk, int flags, int mss_now,

int nonagle)

void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,

int nonagle)

static int tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle)

我們還要知道tcp sock有一個nonagle域,這個域是會被tcp_cork套接口選項時被設置為TCP_NAGLE_CORK .先來看tcp_push的實現:

static inline void tcp_push(struct sock *sk, int flags, int mss_now,

int nonagle)

{

struct tcp_sock *tp = tcp_sk(sk);

if (tcp_send_head(sk)) {

struct sk_buff *skb = tcp_write_queue_tail(sk);

///MSG_MORE這個參數我們在ip_append_data那里已經介紹過了,就是告訴ip層,我這里主要是一些小的數據包,然后ip層就會提前劃分一個mtu大小的buf,然后等待數據的到來.因此如果沒有設置這個或者forced_push返回真(我們寫了超過最大窗口一般的數據),就標記一個PSH.

if (!(flags & MSG_MORE) || forced_push(tp))

tcp_mark_push(tp, skb);

tcp_mark_urg(tp, flags, skb);

///這里還是根據是否有設置MSG_MORE來判斷使用哪個flags.因此可以看到如果我們設置了tcp_cork套接字選項和設置msg的MSG_MORE比較類似.最終調用tcp_push都會傳遞給__tcp_push_pending_frames的參數為TCP_NAGLE_CORK .

__tcp_push_pending_frames(sk, mss_now,

(flags & MSG_MORE) ? TCP_NAGLE_CORK : nonagle);

}

}

在看tcp_write_xmit之前,我們先來看下tcp_nagle_test,這個函數主要用來檢測nagle算法.如果當前允許數據段立即被發送,則返回1,否則為0.

///這個函數就不介紹了,內核的注釋很詳細.

/* Return 0, if packet can be sent now without violation Nagle's rules:

* 1. It is full sized.

* 2. Or it contains FIN. (already checked by caller)

* 3. Or TCP_NODELAY was set.

* 4. Or TCP_CORK is not set, and all sent packets are ACKed.

* With Minshall's modification: all sent small packets are ACKed.

*/

static inline int tcp_nagle_check(const struct tcp_sock *tp,

const struct sk_buff *skb,

unsigned mss_now, int nonagle)

{

return (skb->len < mss_now &&

((nonagle & TCP_NAGLE_CORK) ||

(!nonagle && tp->packets_out && tcp_minshall_check(tp))));

}

static inline int tcp_nagle_test(struct tcp_sock *tp, struct sk_buff *skb,

unsigned int cur_mss, int nonagle)

{

///如果設置了TCP_NAGLE_PUSH則返回1,也就是數據可以立即發送

if (nonagle & TCP_NAGLE_PUSH)

return 1;

/* Don't use the nagle rule for urgent data (or for the final FIN).

* Nagle can be ignored during F-RTO too (see RFC4138).

*/

if (tcp_urg_mode(tp) || (tp->frto_counter == 2) ||

(TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN))

return 1;

///再次檢測 nonagle域,相關的檢測,上面已經說明了.

if (!tcp_nagle_check(tp, skb, cur_mss, nonagle))

return 1;

return 0;

}

然后看下tcp_write_xmit的實現,

static int tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle)

{

struct tcp_sock *tp = tcp_sk(sk);

struct sk_buff *skb;

unsigned int tso_segs, sent_pkts;

int cwnd_quota;

int result;

///檢測狀態.

if (unlikely(sk->sk_state == TCP_CLOSE))

return 0;

sent_pkts = 0;

///探測mtu.

if ((result = tcp_mtu_probe(sk)) == 0) {

return 0;

} else if (result > 0) {

sent_pkts = 1;

}

///開始處理數據包.

while ((skb = tcp_send_head(sk))) {

unsigned int limit;

tso_segs = tcp_init_tso_segs(sk, skb, mss_now);

BUG_ON(!tso_segs);

///主要用來測試congestion window..

cwnd_quota = tcp_cwnd_test(tp, skb);

if (!cwnd_quota)

break;

if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now)))

break;

if (tso_segs == 1) {

///主要看這里,如果這個skb是寫隊列的最后一個buf,則傳輸TCP_NAGLE_PUSH給tcp_nagle_test,這個時侯直接返回1,于是接著往下面走,否則則說明數據包不要求理解發送,我們就跳出循環(這時數據段就不會被發送).比如設置了TCP_CORK.

if (unlikely(!tcp_nagle_test(tp, skb, mss_now,

(tcp_skb_is_last(sk, skb) ?

nonagle : TCP_NAGLE_PUSH))))

break;

} else {

if (tcp_tso_should_defer(sk, skb))

break;

}

limit = mss_now;

if (tso_segs > 1 && !tcp_urg_mode(tp))

limit = tcp_mss_split_point(sk, skb, mss_now,

cwnd_quota);

if (skb->len > limit &&

unlikely(tso_fragment(sk, skb, limit, mss_now)))

break;

TCP_SKB_CB(skb)->when = tcp_time_stamp;

///傳輸數據給3層.

if (unlikely(tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC)))

break;

/* Advance the send_head. This one is sent out.

* This call will increment packets_out.

*/

tcp_event_new_data_sent(sk, skb);

tcp_minshall_update(tp, mss_now, skb);

sent_pkts++;

}

if (likely(sent_pkts)) {

tcp_cwnd_validate(sk);

return 0;

}

return !tp->packets_out && tcp_send_head(sk);

}

然后返回來,來看剛才緊接著的實現:

while (--iovlen >= 0) {

...........................

while (seglen > 0) {

...............................

///如果第一次組完一個段,則設置PSH.

if (!copied)

TCP_SKB_CB(skb)->flags &= ~TCPCB_FLAG_PSH;

///然后設置寫隊列長度.

tp->write_seq += copy;

TCP_SKB_CB(skb)->end_seq += copy;

skb_shinfo(skb)->gso_segs = 0;

///更新buf基地址以及復制的buf大小.

from += copy;

copied += copy;

///buf已經復制完則退出循環.并發送這個段.

if ((seglen -= copy) == 0 && iovlen == 0)

goto out;

///如果skb的數據大小小于所需拷貝的數據大小或者存在帶外數據,我們繼續循環,而當存在帶外數據時,我們接近著的循環會退出循環,然后調用tcp_push將數據發出.

if (skb->len < size_goal || (flags & MSG_OOB))

continue;

///forced_push用來判斷我們是否已經寫了多于一半窗口大小的數據到對端.如果是,我們則要發送一個推數據(PSH).

if (forced_push(tp)) {

tcp_mark_push(tp, skb);

///調用__tcp_push_pending_frames將開啟NAGLE算法的緩存的段全部發送出去.

__tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);

} else if (skb == tcp_send_head(sk))

///如果當前將要發送的buf剛好為skb,則會傳發送當前的buf

tcp_push_one(sk, mss_now);

continue;

wait_for_sndbuf:

set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);

wait_for_memory:

if (copied)

///內存不夠,則盡量將本地的NAGLE算法所緩存的數據發送出去.

tcp_push(sk, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);

if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)

goto do_error;

///更新相關域.

mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));

size_goal = tp->xmit_size_goal;

}

}

最后來看下出錯或者成功tcp_sendmsg所做的:

out:

///這里是成功返回所做的.

if (copied)

///這里可以看到最終的flag是tp->nonagle,而這個就是看套接口選項是否有開nagle算法,如果沒開的話,立即把數據發出去,否則則會村訊nagle算法,將小數據緩存起來.

tcp_push(sk, flags, mss_now, tp->nonagle);

TCP_CHECK_TIMER(sk);

release_sock(sk);

return copied;

do_fault:

if (!skb->len) {

///從write隊列unlink掉當前的buf.

tcp_unlink_write_queue(skb, sk);

///更新send)head

tcp_check_send_head(sk, skb);

///釋放skb.

sk_wmem_free_skb(sk, skb);

}

do_error:

if (copied)

///如果copied不為0,則說明發送成功一部分數據,因此此時返回out.

goto out;

out_err:

///否則進入錯誤處理.

err = sk_stream_error(sk, flags, err);

TCP_CHECK_TIMER(sk);

release_sock(sk);

return err;

總結

以上是生活随笔為你收集整理的linux 内核 发送数据,linux 内核tcp数据发送的实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。