linux伺服器開發相關視訊解析：

90分鐘了解4種紅黑樹的Linux核心應用場景

支撐億級io的底層基石 epoll實戰揭秘

c/c++ linux伺服器開發免費學習位址：c/c++ linux背景伺服器進階架構師

從 linux 源碼看 socket 的阻塞和非阻塞

、一直覺得如果能知道從應用到架構再到作業系統的每一處代碼，是一件 Exciting 的事情。

大部分高性能網絡架構采用的是非阻塞模式。筆者這次就從 linux 源碼的角度來闡述 socket 阻塞(block)和非阻塞(non_block)的差別。 本文源碼均來自采用 Linux-2.6.24 核心版本。

一個 TCP 非阻塞 client 端簡單的例子

如果我們要産生一個非阻塞的 socket,在 C 語言中如下代碼所示:

// 建立socket
int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
...
// 更改socket為nonblock
fcntl(sock_fd, F_SETFL, fdflags | O_NONBLOCK);
// connect
....
while(1)  {  
    int recvlen = recv(sock_fd, recvbuf, RECV_BUF_SIZE) ; 
    ......
} 
...
           

由于網絡協定非常複雜，核心裡面用到了大量的面向對象的技巧，是以我們從建立連接配接開始，一步一步追述到最後代碼的調用點。

socket 的建立

很明顯，核心的第一步應該是通過 AF_INET、SOCK_STREAM 以及最後一個參數 0 定位到需要建立一個 TCP 的 socket,如下圖綠線所示:

我們跟蹤源碼調用

socket(AF_INET, SOCK_STREAM, 0)
    |->sys_socket 進入系統調用
        |->sock_create
            |->__sock_create
           

進一步分析__sock_create 的代碼判斷:

const struct net_proto_family *pf;
// RCU(Read-Copy Update)是linux的一種核心同步方法，在此不闡述
// family=INET
pf = rcu_dereference(net_families[family]);
err = pf->create(net, sock, protocol);
           

由于 family 是 AF_INET 協定，注意在作業系統裡面定義了 PF_INET 等于 AF_INET,

核心通過函數指針實作了對 pf(net_proto_family)的重載。如下圖所示:

則通過源碼可知，由于是 AF_INET(PF_INET),是以 net_families[PF_INET].create=inet_create(以後我們都用 PF_INET 表示)，即

pf->create = inet_create;

進一步追溯調用:

inet_create(struct net *net, struct socket *sock, int protocol){
    Sock* sock;
    ......
    // 此處是尋找對應協定處理器的過程
lookup_protocol:
    // 疊代尋找protocol==answer->protocol的情況
    list_for_each_rcu(p, &inetsw[sock->type]) answer = list_entry(p, struct inet_protosw, list);

        /* Check the non-wild match. */
        if (protocol == answer->protocol) {
            if (protocol != IPPROTO_IP)
                break;
        }
    ......
    // 這邊answer指的是SOCK_STREAM
    sock->ops = answer->ops;
    answer_no_check = answer->no_check;
    // 這邊sk->prot就是answer_prot=>tcp_prot
    sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);
    sock_init_data(sock, sk);
    ......
}
           

上面的代碼就是在 INET 中尋找 SOCK_STREAM 的過程了

【文章福利】需要C/C++ Linux伺服器架構師學習資料加群812855908（資料包括C/C++，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg等）

我們再看一下 inetsw[SOCK_STREAM]的具體配置:

static struct inet_protosw inetsw_array[] =
{
    {
        .type =       SOCK_STREAM,
        .protocol =   IPPROTO_TCP,
        .prot =       &tcp_prot,
        .ops =        &inet_stream_ops,
        .capability = -1,
        .no_check =   0,
        .flags =      INET_PROTOSW_PERMANENT |
                  INET_PROTOSW_ICSK,
    },
    ......
}
           

這邊也用了重載，AF_INET 有 TCP、UDP 以及 Raw 三種:

從上述代碼，我們可以清楚的發現 sock->ops=&inet_stream_ops;

const struct proto_ops inet_stream_ops = {
    .family           = PF_INET,
    .owner           = THIS_MODULE,
    ......
    .sendmsg       = tcp_sendmsg,
    .recvmsg       = sock_common_recvmsg,
    ......
}
           

即 sock->ops->recvmsg = sock_common_recvmsg;

同時 sock->sk->sk_prot = tcp_prot;

我們再看下 tcp_prot 中的各個函數重載的定義:

struct proto tcp_prot = {
    .name            = "TCP",
    .close            = tcp_close,
    .connect        = tcp_v4_connect,
    .disconnect        = tcp_disconnect,
    .accept            = inet_csk_accept,
    ......
    // 我們重點考察tcp的讀
    .recvmsg        = tcp_recvmsg,
    ......
}
           

fcntl 控制 socket 的阻塞\非阻塞狀态

我們用 fcntl 修改 socket 的阻塞\非阻塞狀态。

事實上:

fcntl 的作用就是将 O_NONBLOCK 标志位存儲在 sock_fd 對應的 filp 結構的 f_lags 裡,如下圖所示。

fcntl(sock_fd, F_SETFL, fdflags | O_NONBLOCK);
    |->setfl
           

追蹤 setfl 代碼:

static int setfl(int fd, struct file * filp, unsigned long arg) {
    ......
    filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
    ......
}
           

上圖中，由 sock_fd 在 task_struct(程序結構體)->files_struct->fd_array 中找到對應的 socket 的 file 描述符，再修改 file->flags

在調用 socket.recv 的時候

我們跟蹤源碼調用:

socket.recv
    |->sys_recv
        |->sys_recvfrom
            |->sock_recvmsg
                |->__sock_recvmsg
                    |->sock->ops->recvmsg
           

由上文可知:

sock->ops->recvmsg = sock_common_recvmsg;

sock

值得注意的是,在 sock_recmsg 中,有對辨別 O_NONBLOCK 的處理

if (sock->file->f_flags & O_NONBLOCK)
    flags |= MSG_DONTWAIT;
           

上述代碼中 sock 關聯的 file 中擷取其 f_flags,如果 flags 有 O_NONBLOCK 辨別，那麼就設定 msg_flags 為 MSG_DONTWAIT(不等待)。

fcntl 與 socket 就是通過其共同操作 File 結構關聯起來的。

繼續跟蹤調用

sock_common_recvmsg

int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
            struct msghdr *msg, size_t size, int flags) {
    ......
    // 如果flags的MSG_DONTWAIT辨別置位，則傳給recvmsg的第5個參數為正,否則為0
    err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
                   flags & ~MSG_DONTWAIT, &addr_len);
    .....                   
}
           

由上文可知:

sk->sk_prot->recvmsg 其中 sk_prot=tcp_prot,即最終調用的是 tcp_prot->tcp_recvmsg,

上面的代碼可以看出，如果 fcntl(O_NONBLOCK)=>MSG_DONTWAIT 置位=>(flags & MSG_DONTWAIT)>0, 再結合 tcp_recvmsg 的函數簽名,即如果設定了 O_NONBLOCK 的話，設定給 tcp_recvmsg 的 nonblock 參數>0,關系如下圖所示:

最終的調用邏輯 tcp_recvmsg

首先我們看下 tcp_recvmsg 的函數簽名:

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

顯然我們關注焦點在(int nonblock 這個參數上):

int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
        size_t len, int nonblock, int flags, int *addr_len){
    ......    
    // copied是指向使用者空間拷貝了多少位元組，即讀了多少
    int copied;
    // target指的是期望多少位元組
    int target;
    // 等效為timo = nonblock ? 0 : sk->sk_rcvtimeo;
    timeo = sock_rcvtimeo(sk, nonblock);
    ......    
    // 如果設定了MSG_WAITALL辨別target=需要讀的長度
    // 如果未設定，則為最低低水位值
    target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
    ......

    do{
        // 表明讀到資料
        if (copied) {
            // 注意，這邊隻要!timeo，即nonblock設定了就會跳出循環
            if (sk->sk_err ||
                sk->sk_state == TCP_CLOSE ||
                (sk->sk_shutdown & RCV_SHUTDOWN) ||
                !timeo ||
                signal_pending(current) ||
                (flags & MSG_PEEK))
            break;
        }else{
            // 到這裡，表明沒有讀到任何資料
            // 且nonblock設定了導緻timeo=0，則傳回-EAGAIN,符合我們的預期
            if (!timeo) {
                copied = -EAGAIN;
                break;
        }
        // 這邊如果堵到了期望的資料，繼續，否則目前程序阻塞在sk_wait_data上
        if (copied >= target) {
            /* Do not sleep, just process backlog. */
            release_sock(sk);
            lock_sock(sk);
        } else
            sk_wait_data(sk, &timeo);
    } while (len > 0);        
    ......
    return copied
}
           

上面的邏輯歸結起來就是：

(1)在設定了 nonblock 的時候，如果copied>0,則傳回讀了多少位元組,如果 copied=0，則傳回-EAGAIN,提示應用重複調用。

(2)如果沒有設定 nonblock，如果讀取的資料>=期望，則傳回讀取了多少位元組。如果沒有則用 sk_wait_data 将目前程序等待。

如下流程圖所示:

阻塞函數 sk_wait_data

sk_wait_data 代碼-函數為:

// 将程序狀态設定為可打斷INTERRUPTIBLE
prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
// 通過調用schedule_timeout讓出CPU，然後進行睡眠
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);
           

該函數調用 schedule_timeout 進入睡眠，其進一步調用了 schedule 函數，首先從運作隊列删除，其次加入到等待隊列，最後調用和體系結構相關的 switch_to 宏來完成程序間的切換。

如下圖所示:

阻塞後什麼時候恢複運作呢

情況 1:有對應的網絡資料到來

首先我們看下網絡分組到來的核心路徑，網卡發起中斷後調用 netif_rx 将事件挂入 CPU 的等待隊列，并喚起軟中斷(soft_irq)，再通過 linux 的軟中斷機制調用 net_rx_action，如下圖所示:

注:上圖來自 PLKA(<<深入 Linux 核心架構>>)

緊接着跟蹤 next_rx_action

next_rx_action
    |-process_backlog
        ......
            |->packet_type->func 在這裡我們考慮ip_rcv
                    |->ipprot->handler 在這裡ipprot重載為tcp_protocol
                        (handler 即為tcp_v4_rcv)
           

緊接着 tcp_v4_rcv:

tcp_input.c
tcp_v4_rcv
    |-tcp_v4_do_rcv
        |-tcp_rcv_state_process
            |-tcp_data_queue
                |-sk->sk_data_ready=sock_def_readable
                    |-wake_up_interruptible
                        |-__wake_up
                            |-__wake_up_common
           

在這裡__wake_up_common 将停在目前 wait_queue_head_t 中的程序喚醒，即狀态改為 task_running，等待 CFS 排程以進行下一步的動作,如下圖所示。

情況 2:設定的逾時時間到來

在前面調用 sk_wait_event 中調用了 schedule_timeout

fastcall signed long __sched schedule_timeout(signed long timeout) {
    ......
    // 設定逾時的回掉函數為process_timeout
    setup_timer(&timer, process_timeout, (unsigned long)current);
    __mod_timer(&timer, expire);
    // 這邊讓出CPU
    schedule();
    del_singleshot_timer_sync(&timer);
    timeout = expire - jiffies;
 out:
     // 傳回經過了多長事件
    return timeout < 0 ? 0 : timeout;    
}
           

process_timeout 函數即是将此程序重新喚醒

static void process_timeout(unsigned long __data)
{
    wake_up_process((struct task_struct *)__data);
}
           

總結

linux 核心源代碼博大精深，閱讀其代碼很費周折。希望筆者這篇文章能幫助到閱讀 linux 網絡協定棧代碼的人。