linux 內核tcp接收數據的實現

相比於發送數據，接收數據更復雜一些。接收數據這裏和3層的接口是tcp_v4_rcv(我前面的blog有介紹3層和4層的接口的實現).而4層和用戶空間，也就是系統調用是socket_recvmsg(其他的讀取函數也都會調用這個函數).而這個系統調用會調用__sock_recvmsg.下面我們就先來看下這個函數。 

它的主要功能是初始化sock_iocb,以便與將來數據從內核空間拷貝到用戶空間。然後調用 
recvmsg這個虛函數(tcp協議的話也就是tcp_recvmsg). 

static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
                 struct msghdr *msg, size_t size, int flags)
{
    int err;
    struct sock_iocb *si = kiocb_to_siocb(iocb);
///初始化si。
    si->sock = sock;
    si->scm = NULL;
    si->msg = msg;
    si->size = size;
    si->flags = flags;

    err = security_socket_recvmsg(sock, msg, size, flags);
    if (err)
        return err;
//調用tcp_recvmsg
    return sock->ops->recvmsg(iocb, sock, msg, size, flags);
}

內核對待數據的接收分爲2部分，一部分是當用戶是阻塞的讀取數據時，這時如果有數據則是直接拷貝到用戶空間。而另一方面，如果是非阻塞，則會先把數據拷貝到接收隊列。 

而在內核中這個隊列分爲3種形式。分別是： 

1 sock域結構的 sk_backlog隊列。 

2 tcp_sock的ucopy.prequeue隊列。 

3 sock結構的 receive_queue隊列。 

我們先來看兩個主要的結構體，然後再來解釋這3各隊列的區別，首先是ucopy結構. 

這個結構表示將要直接複製到用戶空間的數據。 

/* Data for direct copy to user */
    struct {
///prequeue隊列。
        struct sk_buff_head prequeue;
///表示當前所處的進程，其實也就是skb的接受者。
        struct task_struct  *task;
///數據區
        struct iovec        *iov;
///prequeue隊列總的所佔用的內存大小
        int         memory;
///這個域表示用戶所請求的長度(要注意這個值是可變的，隨着拷貝給用戶的數據而減少)
        int         len;
........................
    } ucopy;

接下來是sock的sock_lock結構. 

內核的註釋很詳細，這個鎖主要是用來對軟中斷和進程上下文之間提供一個同步。 

/* This is the per-socket lock.  The spinlock provides a synchronization
 * between user contexts and software interrupt processing, whereas the
 * mini-semaphore synchronizes multiple users amongst themselves.
 */
typedef struct {
///自選鎖
    spinlock_t      slock;
///如果有用戶進程在使用這個sock 則owned爲1,否則爲0
    int         owned;
///等待隊列，也就是當sock被鎖住後，等待使用這個sock對象。
    wait_queue_head_t   wq;
    /*
     * We express the mutex-alike socket_lock semantics
     * to the lock validator by explicitly managing
     * the slock as a lock variant (in addition to
     * the slock itself):
     */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    struct lockdep_map dep_map;
#endif
} socket_lock_t;

然後來看3個隊列的區別。 

首先sk_backlog隊列是噹噹前的sock在進程上下文中被使用時，如果這個時候有數據到來，則將數據拷貝到sk_backlog. 

prequeue則是數據buffer第一站一般都是這裏，如果prequeue已滿，則會拷貝數據到receive_queue隊列種。 

最後一個receive_queue也就是進程上下文第一個取buffer的隊列。(後面介紹tcp_recvmsg時會再介紹這3個隊列). 

這裏爲什麼要有prequeue呢,直接放到receive_queue不就好了.這裏我是認receive_queue的處理比較繁瑣(看tcp_rcv_established的實現就知道了,分爲slow path和fast path),而軟中斷每次只能處理一個數據包(在一個cpu上),因此爲了軟中斷能儘快完成,我們就可以先將數據放到prequeue中(tcp_prequeue),然後軟中斷就直接返回.而處理prequeue就放到進程上下文去處理了. 

最後在分析tcp_v4_rcv和tcp_recvmsg之前，我們要知道tcp_v4_rcv還是處於軟中斷上下文，而tcp_recvmsg是處於進程上下文，因此比如socket_lock_t纔會提供一個owned來鎖住對應的sock。而我們也就是需要這3個隊列來進行軟中斷上下文和進程上下文之間的通信。最終當數據拷貝到對應隊列，則軟中斷調用返回。這裏要注意的是相同的函數在軟中斷上下文和進程上下文種調用是不同的，我們下面就會看到(比如tcp_rcv_established函數) 

ok，現在來看tcp_v4_rcv的源碼。這個函數是在軟中斷上下文中被調用的,我們這裏來看下她的代碼片斷： 

    int tcp_v4_rcv(struct sk_buff *skb)
{
///一些用到的變量
    const struct iphdr *iph;
    struct tcphdr *th;
    struct sock *sk;
    int ret;
    struct net *net = dev_net(skb->dev);
............................

//通過四元組得到對應的sock。
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
    if (!sk)
        goto no_tcp_socket;

process:

///如果是time_wait狀態，則進入相關處理(這次不會分析time_wait狀態，以後分析tcp的斷開狀態變遷時，會詳細分析這個).
    if (sk->sk_state == TCP_TIME_WAIT)
        goto do_time_wait;
.................................
///加下半部的鎖
    bh_lock_sock_nested(sk);
    ret = 0;
///這個宏很簡單就是判斷(sk)->sk_lock.owned.也就是當進程上下文在使用這個sock時爲1.
    if (!sock_owned_by_user(sk)) {
。........................
        {
///先將buffer放到prequeue隊列中。如果成功則返回1.
            if (!tcp_prequeue(sk, skb))
///假設失敗，則直接調用tcp_v4_do_rcv處理這個skb(其實也就是直接放到receive_queue中).
                ret = tcp_v4_do_rcv(sk, skb);
        }
    } else
///當有進程在使用這個sock則放buf到sk_backlog中。
        sk_add_backlog(sk, skb);
//解鎖。
    bh_unlock_sock(sk);

    sock_put(sk);

    return ret;
...................................................

上面的流程很簡單，我們接下來來看幾個跳過的函數，第一個是tcp_prequeue。 

這裏我們可以看到sysctl_tcp_low_latency可以決定我們是否使用prequeue隊列. 

static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

///如果啓用tcp_low_latency或者ucopy.task爲空則返回0.ucopy.task爲空一般是表示進程空間有進程在等待sock的數據的到來，因此我們需要直接複製數據到receive隊列。並喚醒它。
    if (sysctl_tcp_low_latency || !tp->ucopy.task)
        return 0;
///加數據包到prequeue隊列。
    __skb_queue_tail(&tp->ucopy.prequeue, skb);
///update內存大小。
    tp->ucopy.memory += skb->truesize;
///如果prequeue已滿，則將處理prequeue隊列。
    if (tp->ucopy.memory > sk->sk_rcvbuf) {
        struct sk_buff *skb1;

        BUG_ON(sock_owned_by_user(sk));
///遍歷prequeue隊列。
        while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
///這個函數最終也會調用tcp_v4_do_rcv(也就是加入到receive隊列中).
            sk_backlog_rcv(sk, skb1);
            NET_INC_STATS_BH(sock_net(sk),
                     LINUX_MIB_TCPPREQUEUEDROPPED);
        }
///清空內存。
        tp->ucopy.memory = 0;
    } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
///這裏表示這個數據包是prequeue的第一個包。然後喚醒等待隊列。
        wake_up_interruptible_poll(sk->sk_sleep,
                       POLLIN | POLLRDNORM | POLLRDBAND);

///這裏的定時器以後會詳細介紹。
        if (!inet_csk_ack_scheduled(sk))
            inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
                          (3 * tcp_rto_min(sk)) / 4,
                          TCP_RTO_MAX);
    }
    return 1;
}

我們這裏只關注TCP_ESTABLISHED狀態，來看tcp_v4_do_rcv:它主要是通過判斷相應的tcp狀態來進入相關的處理函數。 

int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct sock *rsk;
...................................
    if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
        TCP_CHECK_TIMER(sk);
///處理數據包。
        if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
            rsk = sk;
            goto reset;
        }
        TCP_CHECK_TIMER(sk);
        return 0;
    }

    ........................................
}

因此我們這裏重點要看的函數就是tcp_rcv_established,當它在軟中斷上下文中被調用時，主要的目的是將skb加入到receive_queue隊列中。因此這裏我們只看這一部分，等下面分析tcp_recvmsg時，我們再來看進程上下文才會處理的一部分。 

///程序如何到達這裏，我們在分析tcp_recvmsg時會再次分析tcp_rcv_established,那個時候會介紹這個。
if (!eaten) {
///進行checksum
    if (tcp_checksum_complete_user(sk, skb))

                goto csum_error;
..................................................

                __skb_pull(skb, tcp_header_len);

///最重要的在這裏，我們可以看到直接將skb加入到sk_receive隊列中。
            __skb_queue_tail(&sk->sk_receive_queue, skb);
                skb_set_owner_r(skb, sk);
///更新rcv_nxt,也就是表示下一個接收序列起始號。
                tp->rcv_nxt =             TCP_SKB_CB(skb)->end_seq;
            }
............................................

接下來來看tcp_rcvmsg函數。 

通過上面我們知道有找個隊列可供我們取得skbuf，那麼具體的次序是什麼呢，我這裏摘抄內核的註釋，它講的非常清楚： 

引用

Look: we have the following (pseudo)queues: 
1. packets in flight 
2. backlog 
3. prequeue 
4. receive_queue 
Each queue can be processed only if the next ones are empty. At this point we have empty receive_queue.But prequeue _can_ be not empty after 2nd iteration, when we jumped to start of loop because backlog 
processing added something to receive_queue. We cannot release_sock(), because backlog containd packets arrived _after_ prequeued ones. 

Shortly, algorithm is clear --- to process all the queues in order. We could make it more directly,requeueing packets from backlog to prequeue, if is not empty. It is more elegant, but eats cycles,

由於這個函數比較複雜，因此我們分段來分析這個函數。 
首先是處理包之前的一些合法性判斷，以及取得一些有用的值。 

int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
        size_t len, int nonblock, int flags, int *addr_len)
{
...................................

///鎖住當前的socket。
    lock_sock(sk);

    TCP_CHECK_TIMER(sk);

    err = -ENOTCONN;
    if (sk->sk_state == TCP_LISTEN)
        goto out;


///得到超時時間(前面已經介紹過了).如果非阻塞則爲0.
    timeo = sock_rcvtimeo(sk, nonblock);

    /* Urgent data needs to be handled specially. */
    if (flags & MSG_OOB)
        goto recv_urg;

///取得當前tcp字節流中的未讀數據的起始序列號。
    seq = &tp->copied_seq;
    if (flags & MSG_PEEK) {
        peek_seq = tp->copied_seq;
        seq = &peek_seq;
    }

///主要是用來處理MSG_WAITALL套接字選項。這個選項是用來標記是否等待所有的數據到達才返回的。
    target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
}

在上面我們看到了lock_sock，這個函數是用來鎖住當前的sock， 我們來看它的詳細實現,它最終會調用lock_sock_nested： 

void lock_sock_nested(struct sock *sk, int subclass)
{
    might_sleep();
///首先加鎖。
    spin_lock_bh(&sk->sk_lock.slock);
///如果owned爲1,也就是有其他進程在使用這個sock。此時調用__lock_sock(這個函數用來休眠進程，進入等待隊列)。
    if (sk->sk_lock.owned)
        __lock_sock(sk);
///當sock可以使用了，則設置owned爲1,標記被當前進程所使用。
    sk->sk_lock.owned = 1;
///解鎖。
    spin_unlock(&sk->sk_lock.slock);
    /*
     * The sk_lock has mutex_lock() semantics here:
     */
    mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
    local_bh_enable();
}

我們再來看__lock_sock如何來處理的。 

static void __lock_sock(struct sock *sk)
{
    DEFINE_WAIT(wait);

    for (;;) {
///加入等待隊列，可以看到加入的等待隊列是sl_lock.wq，也就是我們上面介紹過得。而這個等待隊列的喚醒我們下面會介紹。
        prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
                    TASK_UNINTERRUPTIBLE);
///解鎖。
        spin_unlock_bh(&sk->sk_lock.slock);
///讓出cpu，進入休眠。
        schedule();
        spin_lock_bh(&sk->sk_lock.slock);
///如果輪到我們處理這個sock，則跳出循環。
        if (!sock_owned_by_user(sk))
            break;
    }
    finish_wait(&sk->sk_lock.wq, &wait);
}

ok，再回到tcp_recvmsg.接下來我們來看如何處理數據包。 

下面這一段主要是用來從receive隊列中讀取數據。 

do {
        u32 offset;

///是否有urgent數據，如果已經讀取了一些數據或者有個未決的sigurg信號，則直接退出循環。
        if (tp->urg_data && tp->urg_seq == *seq) {
            if (copied)
                break;
            if (signal_pending(current)) {
                copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
                break;
            }
        }


///開始處理buf，首先是從receive隊列中讀取buf。
        skb_queue_walk(&sk->sk_receive_queue, skb) {
///開始遍歷receive_queue.
            if (before(*seq, TCP_SKB_CB(skb)->seq)) {
                printk(KERN_INFO "recvmsg bug: copied %X "
                       "seq %X\n", *seq, TCP_SKB_CB(skb)->seq);
                break;
            }
///由於tcp是字節流，因此我們拷貝給用戶空間，需要正序的拷貝給用戶，這裏的第一個seq前面已經描述了，表示當前的總的sock連接中的未讀數據的起始序列號，而後一個seq表示當前skb的起始序列號。因此這個差值如果小於skb->len,就表示，當前的skb就是我們需要讀取的那個skb(因爲它的序列號最小).
            offset = *seq - TCP_SKB_CB(skb)->seq;
///跳過syn。
            if (tcp_hdr(skb)->syn)
                offset--;
///找到skb。
            if (offset < skb->len)
                goto found_ok_skb;
            if (tcp_hdr(skb)->fin)
                goto found_fin_ok;
            WARN_ON(!(flags & MSG_PEEK));
        }
....................................
}while(len > 0)

接下來是對tcp狀態做一些校驗。這裏要注意，copied表示的是已經複製到用戶空間的skb的大小。而len表示還需要拷貝多少數據。 

///如果複製的值大於等於所需要複製的，並且sk_backlog爲空,則跳出循環。這是因爲我們每次複製完畢之後，都需要將sk_backlog中的數據複製到receive隊列中。
if (copied >= target && !sk->sk_backlog.tail)
            break;

        if (copied) {
            if (sk->sk_err ||
                sk->sk_state == TCP_CLOSE ||
                (sk->sk_shutdown & RCV_SHUTDOWN) ||
                !timeo ||
                signal_pending(current))
                break;
        } else {

///如沒有複製到數據(也就是receive爲空),則判斷是否有錯誤發生。這裏主要是狀態的判斷和超時的判斷。
            if (sock_flag(sk, SOCK_DONE))
                break;

            if (sk->sk_err) {
                copied = sock_error(sk);
                break;
            }

            if (sk->sk_shutdown & RCV_SHUTDOWN)
                break;

            if (sk->sk_state == TCP_CLOSE) {
                if (!sock_flag(sk, SOCK_DONE)) {
                    copied = -ENOTCONN;
                    break;
                }
                break;
            }

            if (!timeo) {
                copied = -EAGAIN;
                break;
            }

            if (signal_pending(current)) {
                copied = sock_intr_errno(timeo);
                break;
            }
        }

然後就是根據已經複製的數據大小來清理receive隊列中的數據，並且發送ACK給對端。然後就是給tcp_socket的ucopy域賦值，主要是iov域和task域。一個是數據區，一個是當前從屬的進程。 

tcp_cleanup_rbuf(sk, copied);

        if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {

///循環的第一次的話user_recv爲空，因此給ucopy得想關域賦值。
            if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
//進程爲當前進程。
                user_recv = current;
                tp->ucopy.task = user_recv;
                tp->ucopy.iov = msg->msg_iov;
            }
///長度爲還需拷貝的數據的長度。
            tp->ucopy.len = len;

            WARN_ON(tp->copied_seq != tp->rcv_nxt &&
                !(flags & (MSG_PEEK | MSG_TRUNC)));
///如果prequeue不爲空則跳到 do_prequeue，處理backlog隊列。
            if (!skb_queue_empty(&tp->ucopy.prequeue))
                goto do_prequeue;

            /* __ Set realtime policy in scheduler __ */
        }
///已經複製完畢，則開始拷貝back_log隊列到receive隊列。
        if (copied >= target) {
            /* Do not sleep, just process backlog. */
            release_sock(sk);
            lock_sock(sk);
        } else
///否則進入休眠，等待數據的到來。
            sk_wait_data(sk, &timeo);

上面的分析中有release_sock函數，這個函數用來release這個sock，也就是對這個sock解除鎖定。然後喚醒等待隊列。 

這裏要注意，sock一共有兩個等待隊列，一個是sock的sk_sleep等待隊列，這個等待隊列用來等待數據的到來。一個是ucopy域的等待隊列wq，這個表示等待使用這個sock。 

void release_sock(struct sock *sk)
{

    mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);

    spin_lock_bh(&sk->sk_lock.slock);
///如果backlog隊列不爲空，則調用__release_sock處理
    if (sk->sk_backlog.tail)
        __release_sock(sk);
///處理完畢則給owened賦值爲0.釋放對這個sock的控制。
    sk->sk_lock.owned = 0;
///喚醒wq上的所有元素。
    if (waitqueue_active(&sk->sk_lock.wq))
        wake_up(&sk->sk_lock.wq);
    spin_unlock_bh(&sk->sk_lock.slock);
}

然後來看主要的處理函數__release_sock,它主要是遍歷backlog隊列，然後處理skb。這裏它有兩個循環，外部循環是遍歷backlog，而內部循環是遍歷skb(也就是數據)。 

static void __release_sock(struct sock *sk)
{
    struct sk_buff *skb = sk->sk_backlog.head;

///遍歷backlog隊列。
    do {
        sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
        bh_unlock_sock(sk);

        do {
            struct sk_buff *next = skb->next;

            skb->next = NULL;

///這個函數我們知道最終會調tcp_v4_do_rcv.而在tcp_v4_do_rcv中，會把數據複製到receive_queue隊列中。
            sk_backlog_rcv(sk, skb);
            cond_resched_softirq();

            skb = next;
        } while (skb != NULL);

        bh_lock_sock(sk);
    } while ((skb = sk->sk_backlog.head) != NULL);
}

而當數據tp->ucopy.prequeue爲空，並且所複製的數據不能達到所期望的值，此時我們進入sk_wait_data等待數據的到來。 

#define sk_wait_event(__sk, __timeo, condition)         \
    ({int  __rc;                        \
///這個我們通過上面知道，會將數據複製到receive-queue隊列。
    release_sock(__sk);                 \
    __rc = condition;
///當sk_wait_data調用時，rc是用來判斷receive_queue是否爲空的，          \
    if (!__rc) {
///如果爲空則會休眠等待，sk_sleep等待隊列的喚醒。                  \
        *(__timeo) = schedule_timeout(*(__timeo));  \
        }                           \
        lock_sock(__sk);                    \
__rc = condition;               \
        __rc;                           \
    })



int sk_wait_data(struct sock *sk, long *timeo)
{
    int rc;
    DEFINE_WAIT(wait);
///加入sk_sleep的等待隊列
    prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
    set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
///處理事件
    rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
    clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
    finish_wait(sk->sk_sleep, &wait);
    return rc;
}

接下來就是一些域的更新，以及處理prequeue隊列： 

if (user_recv) {
            int chunk;

            /* __ Restore normal policy in scheduler __ */
///這個判斷主要是由於在release_sock中，有可能會將數據直接複製到用戶空間了。此時我們需要更新len以及copied域。
            if ((chunk = len - tp->ucopy.len) != 0) {
                NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);
                len -= chunk;
                copied += chunk;
            }
///tp->rcv_nxt == tp->copied_seq主要用來判斷是否receive隊列中還需要數據要執行嗎(下面會說明爲什麼)。
            if (tp->rcv_nxt == tp->copied_seq &&
                !skb_queue_empty(&tp->ucopy.prequeue)) {
do_prequeue:
///執行prequeue
                tcp_prequeue_process(sk);

///和上面一樣，更新len和cpoied域。
                if ((chunk = len - tp->ucopy.len) != 0) {
                    NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
                    len -= chunk;
                    copied += chunk;
                }
            }
        }
...................................
        continue;

在分析tcp_prequeue_process之前，我們先來看下什麼情況下release_sock會直接複製數據到用戶空間。我們知道它最終會調用tcp_rcv_established函數，因此來看tcp_rcv_established的代碼片斷 
內核接收到的數據包有可能不是正序的，可是內核傳遞給用戶空間的數據必須是正序的，只有這樣才能拷貝給用戶空間。 

else {
            int eaten = 0;
            int copied_early = 0;
///判斷從這裏開始。copied_seq表示未讀的skb的序列號。而rcv_nxt爲我們所期望接收的下一個數據的序列號。這裏我們是要保證字節流的正序。而第二個條件len - tcp_header_len <= tp->ucopy.len這個說明用戶請求的數據還沒有複製夠。如果已經複製夠了，則會複製數據到receive_queue隊列。
        if (tp->copied_seq == tp->rcv_nxt &&
               len - tcp_header_len <= tp->ucopy.len) {
.........................

///然後判斷從屬的進程必須等於當前調用進程。並且必須爲進程上下文。
    if (tp->ucopy.task == current &&
        sock_owned_by_user(sk) && !copied_early) {
                    __set_current_state(TASK_RUNNING);
///開始複製數據到用戶空間。
        if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))
                        eaten = 1;
                }

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

通過上面的判斷條件我們很容易看出前面調用release_sock,爲何有時將數據拷貝到用戶空間，有時拷貝到receive隊列。 


ok，最後我們來看下tcp_prequeue_process的實現。它的實現很簡單，就是遍歷prequeue,然後處理buf。這裏要注意，它會處理完所有的prequeue，也就是會清空prequeue. 

static void tcp_prequeue_process(struct sock *sk)
{
    struct sk_buff *skb;
    struct tcp_sock *tp = tcp_sk(sk);

    NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);

    /* RX process wants to run with disabled BHs, though it is not
     * necessary */
    local_bh_disable();
///遍歷並處理skb。
    while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
///最終會調用tcp_rcv_established.
        sk_backlog_rcv(sk, skb);
    local_bh_enable();
///內存清空爲0.
    tp->ucopy.memory = 0;
}

最後簡要的分析下數據如何複製到用戶空間。這裏的主要函數是skb_copy_datagram_iovec。最終都是通過這個函數複製到用戶空間的。 


我們知道內核存儲數據有兩種形式如果支持S/G IO的網卡，它會保存數據到skb_shinfo(skb)->frags(詳見前面的blog),否則則會保存在skb的data區中。 

因此這裏也是分爲兩部分處理。 

還有一個就是這裏遍歷frags也是遍歷兩次，第一次遍歷是查找剛好 

int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
                struct iovec *to, int len)
{
    int start = skb_headlen(skb);
    int i, copy = start - offset;
    struct sk_buff *frag_iter;
///支持S/G IO的網卡，第一個數據包也是保存在data域中的。
    if (copy > 0) {
        if (copy > len)
            copy = len;
///複製data域。
        if (memcpy_toiovec(to, skb->data + offset, copy))
            goto fault;
        if ((len -= copy) == 0)
            return 0;
        offset += copy;
    }

///遍歷frags，開始複製數據。
    for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
        int end;

        WARN_ON(start > offset + len);
///計算複製的字節數
        end = start + skb_shinfo(skb)->frags[i].size;
///判斷將要複製的字節數是否足夠
        if ((copy = end - offset) > 0) {
            int err;
            u8  *vaddr;
            skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
            struct page *page = frag->page;
///如果將要複製的數據太大，則縮小它爲請求的長度。
            if (copy > len)
                copy = len;
///轉換物理地址到虛擬地址。
            vaddr = kmap(page);
///複製數據。
            err = memcpy_toiovec(to, vaddr + frag->page_offset +
                         offset - start, copy);
            kunmap(page);
            if (err)
                goto fault;
///如果複製完畢則返回0
            if (!(len -= copy))
                return 0;
///更新offset域。
            offset += copy;
        }
//更新start域。
        start = end;
    }

///到達這裏說明數據還沒有寶貝完畢，也就是請求的數據還沒拷貝完成。此時我們就需要變化offset域。
    skb_walk_frags(skb, frag_iter) {
        int end;

        WARN_ON(start > offset + len);

        end = start + frag_iter->len;
        if ((copy = end - offset) > 0) {
            if (copy > len)
                copy = len;
///改變offset域爲offset-start遞歸重新開始。
            if (skb_copy_datagram_iovec(frag_iter,
                            offset - start,
                            to, copy))
                goto fault;
            if ((len -= copy) == 0)
                return 0;
            offset += copy;
        }
        start = end;
    }
    if (!len)
        return 0;

fault:
    return -EFAULT;
}