tcp connection setup的實現(二)

首先來看下內核如何處理3次握手的半連接隊列和accept隊列(其實也就是server端的三次握手的狀態變換).而半連接隊列和accept隊列在內核如何表示,我們上次已經介紹過了,這裏就不介紹了. 


首先我們知道當3層的數據包到達之後會調用4層的協議handle,tcp的話就是tcp_v4_rcv.如何調用可以看我前面的blog: 

而在tcp_v4_rcv中,則最終會調用tcp_v4_do_rcv來處理輸入數據包.在看tcp_v4_do_rcv之前,我們先來看在tcp_v4_rcv中,內核如何通過4元組(目的,源端口和地址)來查找對應得sock對象. 

在分析之前,我們要知道,當一對tcp連接3次握手完畢後,內核將會重新new一個socket,這個socket中的大部分域都是與主socket相同的.而把這個新的socket的狀態設置爲established,而主socket的狀態依舊爲listen狀態. 

而通過前面的blog分析,我們也知道在inet_hashinfo中將處於listening狀態的socket和處於TCP_ESTABLISHED與TCP_CLOSE之間的狀態的socket是分開的,一個是ehash,一個是listening_hash.因此通過對應的4元組查找socket也是分開在這兩個hash鏈表中操作的. 

內核是通過調用__inet_lookup來查找socket的: 

///在tcp_v4_rcv中的代碼片段.
sk = __inet_lookup(net, &tcp_hashinfo, iph->saddr,
            th->source, iph->daddr, th->dest, inet_iif(skb));

static inline struct sock *__inet_lookup(struct net *net,
                     struct inet_hashinfo *hashinfo,
                     const __be32 saddr, const __be16 sport,
                     const __be32 daddr, const __be16 dport,
                     const int dif)
{
    u16 hnum = ntohs(dport);
    struct sock *sk = __inet_lookup_established(net, hashinfo,
                saddr, sport, daddr, hnum, dif);

    return sk ? : __inet_lookup_listener(net, hashinfo, daddr, hnum, dif);
}

tcp_hashinfo我們前面也已經分析過了,包含了所有tcp所用到的hash信息,比如socket,port等等.這裏的查找其實就是在tcp_hashinfo中(其實是它的域ehash或者listening_hash)查找相應的socket. 

我們可以看到內核在這裏進行了兩次查找,首先是在established狀態的socket中查找,處於established狀態,說明3次握手已經完成,因此這個socket可以通過簡單的4元組hash在hashinfo的ehash中查找. 

而當在__inet_lookup_established中沒有找到時,則將會__inet_lookup_listener中查找.也就是在處於listening狀態的socket中查找(這裏主要是通過daddr也就是目的地址來進行匹配). 


當找到對應的socket以後就會進入數據包的處理,也就是進入tcp_v4_do_rcv函數. 

int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct sock *rsk;
..................................................

///如果爲TCP_ESTABLISHED狀態,則進入相關處理
    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;
    }

///進行包頭的合法性校驗.
    if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
        goto csum_err;
///進入TCP_LISTEN狀態.
    if (sk->sk_state == TCP_LISTEN) {
        struct sock *nsk = tcp_v4_hnd_req(sk, skb);
        if (!nsk)
            goto discard;

        if (nsk != sk) {
            if (tcp_child_process(sk, nsk, skb)) {
                rsk = nsk;
                goto reset;
            }
            return 0;
        }
    }

    TCP_CHECK_TIMER(sk);
///進入其他狀態的處理.除了ESTABLISHED和TIME_WAIT狀態.
    if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
        rsk = sk;
        goto reset;
    }
    TCP_CHECK_TIMER(sk);
    return 0;
......................................................................
}

可以看到當進來之後,會通過判斷socket的不同狀態來進入不同的處理.這裏其實就分了3種狀態,TCP_ESTABLISHED,TCP_LISTEN和剩餘的的狀態. 

我們這裏先不分析TCP_ESTABLISHED. 

我們先來看當第一個syn分解到達後,內核會做怎麼樣處理.首先它會進入tcp_v4_hnd_req函數,這個函數我們後面會處理,這裏只需要知道當爲第一個syn分節時,它會返回當前socket.因此此時nsk == sk,所以我們進入tcp_rcv_state_process函數,這個函數處理除了ESTABLISHED和TIME_WAIT狀態之外的所有狀態. 

我們這裏只看他的listen狀態處理,後面的話也是遇到一個狀態,我們看一個狀態的處理: 

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
              struct tcphdr *th, unsigned len)
{
    struct tcp_sock *tp = tcp_sk(sk);
///取得對應的inet_connection_sock .
    struct inet_connection_sock *icsk = inet_csk(sk);
    int queued = 0;
    tp->rx_opt.saw_tstamp = 0;

    switch (sk->sk_state) {
    case TCP_LISTEN:
///當爲ack分節,則返回1,而對應內核會發送一個rst給對端.
        if (th->ack)
            return 1;
///如果是rst,則忽略這個分組.
        if (th->rst)
            goto discard;
///是syn分組,因此調用對應的虛函數conn_request,而這個函數在tcpv4中被初始化爲tcp_v4_conn_request.
        if (th->syn) {
            if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
                return 1;
            kfree_skb(skb);
            return 0;
        }
        goto discard;
............................................................
}

可以看到最終會調用tcp_v4_conn_request來處理syn分組,我們接下來就來看這個函數的實現. 

先來看幾個相關的函數,第一個是reqsk_queue_is_full,他來判斷半連接隊列是否已滿.其實實現很簡單,就是判斷qlen和max_qlen_log的大小: 

static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)
{
    return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
}

第二個是sk_acceptq_is_full,它用來判斷accept隊列是否已滿.這個也是很簡單,比較當前的隊列大小sk_ack_backlog與最大的隊列大小sk_max_ack_backlog. 

static inline int sk_acceptq_is_full(struct sock *sk)
{
    return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
}

最後一個是tcp_openreq_init,它用來新建一個inet_request_sock,我們知道每次一個syn到達後,我們都會新建一個inet_request_sock,並加入到半連接隊列. 

static inline void tcp_openreq_init(struct request_sock *req,
                    struct tcp_options_received *rx_opt,
                    struct sk_buff *skb)
{
    struct inet_request_sock *ireq = inet_rsk(req);

    req->rcv_wnd = 0;        /* So that tcp_send_synack() knows! */
    req->cookie_ts = 0;
    tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
    req->mss = rx_opt->mss_clamp;
    req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
    ireq->tstamp_ok = rx_opt->tstamp_ok;
    ireq->sack_ok = rx_opt->sack_ok;
    ireq->snd_wscale = rx_opt->snd_wscale;
    ireq->wscale_ok = rx_opt->wscale_ok;
    ireq->acked = 0;
    ireq->ecn_ok = 0;
    ireq->rmt_port = tcp_hdr(skb)->source;
}

接下來來看tcp_v4_conn_request的實現, 

int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
    struct inet_request_sock *ireq;
    struct tcp_options_received tmp_opt;
    struct request_sock *req;
    __be32 saddr = ip_hdr(skb)->saddr;
    __be32 daddr = ip_hdr(skb)->daddr;
///這個名字實在是無語,when具體表示什麼不太理解,只是知道它是用來計算rtt的.
    __u32 isn = TCP_SKB_CB(skb)->when;
    struct dst_entry *dst = NULL;
#ifdef CONFIG_SYN_COOKIES
    int want_cookie = 0;
#else
#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
#endif

///如果是廣播或者多播,則丟掉這個包.
    if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
        goto drop;

///判斷半連接隊列是否已經滿掉.如果滿掉並且處於非timewait狀態,則丟掉這個包(如果設置了SYN Cookie則會繼續進行,因爲SYN Cookie不需要新分配半連接隊列,詳細的SYN Cookie請google)
    if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
#ifdef CONFIG_SYN_COOKIES
        if (sysctl_tcp_syncookies) {
            want_cookie = 1;
        } else
#endif
        goto drop;
    }
///如果accept隊列已滿,並且qlen_young大於一就丟掉這個包,這裏qlen_young大於一表示在syn隊列中已經有足夠多的(這裏不包括重傳的syn)請求了.
    if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
        goto drop;
    req = inet_reqsk_alloc(&tcp_request_sock_ops);
    if (!req)
        goto drop;
...................................................

///對tmp_opt進行初始化,而tcp_options_received中包含了tcp的一些選項信息(比如mss,窗口擴大因子等等)
    tcp_clear_options(&tmp_opt);
    tmp_opt.mss_clamp = 536;
    tmp_opt.user_mss  = tcp_sk(sk)->rx_opt.user_mss;

///對對端的tcp_options_received進行解析,並對本端得tcp_options_received進行初始化.
    tcp_parse_options(skb, &tmp_opt, 0);

.......................................................
///這裏對新的req進行初始化.

    tcp_openreq_init(req, &tmp_opt, skb);
...............................................

///這裏將tcp_options_received保存到req中.
    ireq->opt = tcp_v4_save_options(sk, skb);
    if (!want_cookie)
        TCP_ECN_create_request(req, tcp_hdr(skb));

    if (want_cookie) {
#ifdef CONFIG_SYN_COOKIES
        syn_flood_warning(skb);
        req->cookie_ts = tmp_opt.tstamp_ok;
#endif
        isn = cookie_v4_init_sequence(sk, skb, &req->mss);
    }else if (!isn) {
.............................................
///計算當前一個合適的isn,並返回.
        isn = tcp_v4_init_sequence(skb);
    }

///賦值發送給對端的isn
    tcp_rsk(req)->snt_isn = isn;

///發送syn和ack(如果設置了want_cookie則不會將這個req鏈接到半連接隊列中.
    if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)
        goto drop_and_free;

///將這個req鏈接到半連接隊列中.
    inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
    return 0;

drop_and_release:
    dst_release(dst);
drop_and_free:
    reqsk_free(req);
drop:
    return 0;
}

而tcp_v4_hnd_req的主要工作是在半連接隊列中看是否存在當前的socket,如果存在則說明這個有可能是最終的ack包,因此將會做一系列的合法性校驗(比如重傳,rst,syn等等),最終確定這個是ack後會調用對應的新建socket的虛函數syn_recv_sock. 

static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
    struct tcphdr *th = tcp_hdr(skb);
    const struct iphdr *iph = ip_hdr(skb);
    struct sock *nsk;
    struct request_sock **prev;
///通過socket,查找對應request_sock
    struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
                               iph->saddr, iph->daddr);
    if (req)
///如果存在則進入req的相關處理.
        return tcp_check_req(sk, skb, req, prev);

///不存在,則通過inet_lookup_established查找.這是因爲有可能當我們進入這個函數之前,socket的狀態被改變了,也就是這個socket的狀態已經不是listen了.

    nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
            th->source, iph->daddr, th->dest, inet_iif(skb));

    if (nsk) {
        if (nsk->sk_state != TCP_TIME_WAIT) {
///非tw狀態返回新的socket.
            bh_lock_sock(nsk);
            return nsk;
        }
///如果是timewait狀態則返回空.
        inet_twsk_put(inet_twsk(nsk));
        return NULL;
    }

#ifdef CONFIG_SYN_COOKIES
    if (!th->rst && !th->syn && th->ack)
        sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
#endif
    return sk;
}

tcp_check_req最主要工作就是調用虛函數,新建一個socket,並返回. 

先來看幾個相關的函數,第一個是inet_csk_reqsk_queue_unlink,它主要用來從半連接隊列unlink掉一個元素.: 

static inline void inet_csk_reqsk_queue_unlink(struct sock *sk,
                           struct request_sock *req,
                           struct request_sock **prev)
{
    reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);
}

static inline void reqsk_queue_unlink(struct request_sock_queue *queue,
                      struct request_sock *req,
                      struct request_sock **prev_req)
{
    write_lock(&queue->syn_wait_lock);
///處理鏈表.
    *prev_req = req->dl_next;
    write_unlock(&queue->syn_wait_lock);
}

第二個是inet_csk_reqsk_queue_removed,它主要用來修改對應的qlen和qlen_young的值. 

static inline void inet_csk_reqsk_queue_removed(struct sock *sk,
                        struct request_sock *req)
{
    if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)
        inet_csk_delete_keepalive_timer(sk);
}

static inline int reqsk_queue_removed(struct request_sock_queue *queue,
                      struct request_sock *req)
{
    struct listen_sock *lopt = queue->listen_opt;
///如果重傳數爲0則說明沒有重傳過,因此qlen_young跟着也減一.
    if (req->retrans == 0)
        --lopt->qlen_young;

    return --lopt->qlen;
}

最後是inet_csk_reqsk_queue_add,它用來把新的req加入到accept隊列中. 

static inline void inet_csk_reqsk_queue_add(struct sock *sk,
                        struct request_sock *req,
                        struct sock *child)
{
    reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);
}


static inline void reqsk_queue_add(struct request_sock_queue *queue,
                   struct request_sock *req,
                   struct sock *parent,
                   struct sock *child)
{
    req->sk = child;
    sk_acceptq_added(parent);
///可以看到剛好就是request_sock_queue的rskq_accept_head與rskq_accept_tail保存accept隊列.
    if (queue->rskq_accept_head == NULL)
        queue->rskq_accept_head = req;
    else
        queue->rskq_accept_tail->dl_next = req;

    queue->rskq_accept_tail = req;
    req->dl_next = NULL;
}

然後再來看tcp_check_req的實現. 

struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
               struct request_sock *req,
               struct request_sock **prev)
{
    const struct tcphdr *th = tcp_hdr(skb);
    __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);
    int paws_reject = 0;
    struct tcp_options_received tmp_opt;
    struct sock *child;

    tmp_opt.saw_tstamp = 0;
......................................
///如果只有rst和syn域則發送一個rst給對端.
if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) {
        TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
        goto embryonic_reset;
    }

///如果是重傳的syn,則重新發送syn和ack分組.
    if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn &&
        flg == TCP_FLAG_SYN &&
        !paws_reject) {
        req->rsk_ops->rtx_syn_ack(sk, req);
        return NULL;
    }

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

///確定有設置ack分節.
    if (!(flg & TCP_FLAG_ACK))
        return NULL;

///這裏主要處理TCP_DEFER_ACCEPT被設置的情況,如果它被設置,則丟掉這個包.(這是因爲TCP_DEFER_ACCEPT會等待數據真正發過來才處理的,而不是最後一個ack發過來就處理)
    if (inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
        TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
        inet_rsk(req)->acked = 1;
        return NULL;
    }

///可以創建一個新的socket了.返回一個包含新創建的socket的request結構.
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
    if (child == NULL)
        goto listen_overflow;
..................................
#endif
///創建成功,則在request_sock_queue的listen_opt中unlink掉這個req.也就是從半連接隊列中刪除這個req.
    inet_csk_reqsk_queue_unlink(sk, req, prev);
///修改對應的 qlen和qlen_young的值.
    inet_csk_reqsk_queue_removed(sk, req);
///最後加入到accept隊列中.這裏注意最終是將新的socket賦值給對應的req.
    inet_csk_reqsk_queue_add(sk, req, child);
    return child;

listen_overflow:
    if (!sysctl_tcp_abort_on_overflow) {
        inet_rsk(req)->acked = 1;
        return NULL;
    }

embryonic_reset:
    NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
    if (!(flg & TCP_FLAG_RST))
        req->rsk_ops->send_reset(sk, skb);

    inet_csk_reqsk_queue_drop(sk, req, prev);
    return NULL;
}

最後我們來看內核如何創建一個新的socket,tcp 協議使用tcp_v4_syn_recv_sock來實現,它做的其實很簡單就是新建一個socket,並且設置狀態爲TCP_SYN_RECV(在inet_csk_clone中),父socket繼續處於listen狀態,然後對新的socket進行一些賦值,然後對一些定時器進行初始化.這裏定時器我們全部都略過了,以後會專門來分析tcp中的定時器. 


最後從tcp_v4_hnd_req中返回,判斷是否與父socket相等,然後調用tcp_child_process函數: 

這個函數主要是完成最終的三次握手,將子socket設置爲TCP_ESTABLISHED然後根據條件喚醒被accept阻塞的主socket: 

int tcp_child_process(struct sock *parent, struct sock *child,
              struct sk_buff *skb)
{
    int ret = 0;
    int state = child->sk_state;

    if (!sock_owned_by_user(child)) {
///完成最終的三次握手.
        ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
                        skb->len);
        /* Wakeup parent, send SIGIO */
        if (state == TCP_SYN_RECV && child->sk_state != state)
///喚醒阻塞的主socket.
            parent->sk_data_ready(parent, 0);
    } else {
        /* Alas, it is possible again, because we do lookup
         * in main socket hash table and lock on listening
         * socket does not protect us more.
         */
        sk_add_backlog(child, skb);
    }

    bh_unlock_sock(child);
    sock_put(child);
    return ret;
}

最後來分析下在tcp_rcv_state_process中的處理當前的TCP_SYN_RECV狀態,它主要是爲將要到來的數據傳輸做一些準備,設置一些相關域.: 

case TCP_SYN_RECV:
            if (acceptable) {
                tp->copied_seq = tp->rcv_nxt;
                smp_mb();
///設置狀態爲TCP_ESTABLISHED.
                tcp_set_state(sk, TCP_ESTABLISHED);
                sk->sk_state_change(sk);

///這裏的wake應該是針對epoll這類的
                if (sk->sk_socket)
                    sk_wake_async(sk,
                              SOCK_WAKE_IO, POLL_OUT);

///設置期望接收的isn號,也就是第一個字節的序列和窗口大小.
                tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
                tp->snd_wnd = ntohs(th->window) <<
                          tp->rx_opt.snd_wscale;
                tcp_init_wl(tp, TCP_SKB_CB(skb)->ack_seq,
                        TCP_SKB_CB(skb)->seq);

.........................................................................
            break;