探討read的返回值的三種狀況

時間  2020-07-27
標籤 探討 read 返回 三種 狀況 简体版
原文   原文鏈接
本文的copyleft歸gfree.wind@gmail.com全部，使用GPL發佈，能夠自由拷貝，轉載。但轉載請保持文檔的完整性，註明原做者及原連接，嚴禁用於任何商業用途。
======================================================================================================
 
今天探討一個很看似簡單的API 「read」的返回值問題。read的返回值有哪幾個值？每一個值又是在什麼狀況下發生的？
 
先問一下男人吧：man 2 read
RETURN VALUE
       On success, the number of bytes read is returned (zero indicates end of file), and the file position is advanced by this number.  It is not an error if this number is smaller than the number of bytes requested; this may happen for example because fewer  bytes  are  actually available  right  now (maybe because we were close to end-of-file, or because we are reading from a pipe, or from a terminal), or because read() was interrupted by a signal.  On error, -1 is returned, and errno is set appropriately.  In this case it is left unspecified whether the file position (if any) changes.
 
從上面的描述中，read的返回值一共有三種狀況：
1. 大於0：成功讀取的字節數；
2. 等於0：到達文件尾；
3. -1：發生錯誤，經過errno肯定具體錯誤值。
Note：本次討論只限於阻塞的fd，不討論非阻塞的狀況。
 
經過這個man的介紹，看似read的應用很簡單，但真的是這樣嗎？莫忘了Linux中文件是一個很common的概念。它能夠是一個真實的文件，也能夠是一個socket，一個設備，等等。對於真實的文件，文件尾EOF是一個肯定的狀況。
 
那麼若是是一個socket，它的返回值什麼時候爲0呢？還有，在read的過程當中，若是被信號中斷，到底是返回-1，仍是返回一個正值或者0呢？當對端關閉後，是否socket還能夠讀取對端關閉socket前發送的數據呢？
 
爲了搞清楚socket的行爲，必需要研究一下對應的kernel的代碼。本次以unix域的TCP鏈接的socket爲例，來探討一下socket的行爲。
 
unix_stream_recvmsg爲unix域的TCP鏈接的socket的讀取函數：
  1. static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
  2.              struct msghdr *msg, size_t size,
  3.              int flags)
  4. {
  5.     struct sock_iocb *siocb = kiocb_to_siocb(iocb);
  6.     struct scm_cookie tmp_scm;
  7.     struct sock *sk = sock->sk;
  8.     struct unix_sock *u = unix_sk(sk);
  9.     struct sockaddr_un *sunaddr = msg->msg_name;
  10.     int copied = 0;
  11.     int check_creds = 0;
  12.     int target;
  13.     int err = 0;
  14.     long timeo;
  16.     err = -EINVAL;
  17.     if (sk->sk_state != TCP_ESTABLISHED)
  18.         goto out;
  20.     err = -EOPNOTSUPP;
  21.     if (flags&MSG_OOB)
  22.         goto out;
  24.     target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
  25.     timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
  27.     msg->msg_namelen = 0;
  29.     /* Lock the socket to prevent queue disordering
  30.      * while sleeps in memcpy_tomsg
  31.      */
  33.     if (!siocb->scm) {
  34.         siocb->scm = &tmp_scm;
  35.         memset(&tmp_scm, 0, sizeof(tmp_scm));
  36.     }
  38.     mutex_lock(&u->readlock);
  40.     do {
  41.         int chunk;
  42.         struct sk_buff *skb;
  44.         unix_state_lock(sk);
  45.         skb = skb_dequeue(&sk->sk_receive_queue);
  46.         if (skb == NULL) {
  47.             if (copied >= target)
  48.                 goto unlock;
  50.             /*
  51.              *    POSIX 1003.1g mandates this order.
  52.              */
  54.             err = sock_error(sk);
  55.             if (err)
  56.                 goto unlock;
  57.             if (sk->sk_shutdown & RCV_SHUTDOWN)
  58.                 goto unlock;
  60.             unix_state_unlock(sk);
  61.             err = -EAGAIN;
  62.             if (!timeo)
  63.                 break;
  64.             mutex_unlock(&u->readlock);
  66.             timeo = unix_stream_data_wait(sk, timeo);
  68.             if (signal_pending(current)) {
  69.                 err = sock_intr_errno(timeo);
  70.                 goto out;
  71.             }
  72.             mutex_lock(&u->readlock);
  73.             continue;
  74.  unlock:
  75.             unix_state_unlock(sk);
  76.             break;
  77.         }
  78.         unix_state_unlock(sk);
  80.         if (check_creds) {
  81.             /* Never glue messages from different writers */
  82.             if ((UNIXCB(skb).pid != siocb->scm->pid) ||
  83.              (UNIXCB(skb).cred != siocb->scm->cred)) {
  84.                 skb_queue_head(&sk->sk_receive_queue, skb);
  85.                 break;
  86.             }
  87.         } else {
  88.             /* Copy credentials */
  89.             scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).cred);
  90.             check_creds = 1;
  91.         }
  93.         /* Copy address just once */
  94.         if (sunaddr) {
  95.             unix_copy_addr(msg, skb->sk);
  96.             sunaddr = NULL;
  97.         }
  99.         chunk = min_t(unsigned int, skb->len, size);
  100.         if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
  101.             skb_queue_head(&sk->sk_receive_queue, skb);
  102.             if (copied == 0)
  103.                 copied = -EFAULT;
  104.             break;
  105.         }
  106.         copied += chunk;
  107.         size -= chunk;
  109.         /* Mark read part of skb as used */
  110.         if (!(flags & MSG_PEEK)) {
  111.             skb_pull(skb, chunk);
  113.             if (UNIXCB(skb).fp)
  114.                 unix_detach_fds(siocb->scm, skb);
  116.             /* put the skb back if we didn't use it up.. */
  117.             if (skb->len) {
  118.                 skb_queue_head(&sk->sk_receive_queue, skb);
  119.                 break;
  120.             }
  122.             consume_skb(skb);
  124.             if (siocb->scm->fp)
  125.                 break;
  126.         } else {
  127.             /* It is questionable, see note in unix_dgram_recvmsg.
  128.              */
  129.             if (UNIXCB(skb).fp)
  130.                 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
  132.             /* put message back and return */
  133.             skb_queue_head(&sk->sk_receive_queue, skb);
  134.             break;
  135.         }
  136.     } while (size);
  138.     mutex_unlock(&u->readlock);
  139.     scm_recv(sock, msg, siocb->scm, flags);
  140. out:
  141.     return copied ? : err;
  142. }
在這個函數中只有一個出口：
  1. return copied ? : err;
copied在unix_stream_recvmsg爲已讀取的字節數。那麼這行代碼的意義就比較明顯了，當已讀取了必定數據，那麼read的返回值即爲讀取的字節數。當沒有讀取任何數據時，就返回err。
 
下面看前面提出的兩個問題：
1. 什麼時候返回值爲0；
2. 被信號中斷時，read的返回值是什麼？
3. 對端關閉後，是否能夠繼續讀取對端關閉前發送的數據呢？
 
先看第一個問題：什麼時候返回值爲0。這須要copied爲0，且err爲0。
  1.             err = sock_error(sk);
  2.             if (err)
  3.                 goto unlock;
  4.             if (sk->sk_shutdown & RCV_SHUTDOWN)
  5.                 goto unlock;
這幾行代碼告訴了咱們答案。首先這幾行代碼是在socket的receive queue沒有數據時，纔會運行到達的。當socket沒有錯誤時，會繼續堅持socket的RCV_SHUTDOWN標誌位，若是設置了該標誌位，則goto 到unlock，直至最後的return返回語句。此時，copied爲0時，err也會爲0.
而sk->sk_shutdown的標誌位會在兩種狀況下被設置，參見unix_shutdown函數。在unix_shutdown函數，由API close或者shutdown觸發，它不只設置了本端的sk_shutdown標誌位，還會設置對端相對應的sk_shutdown標誌位。因此不管是本端仍是對端調用shutdown或者close時，都有可能致使本端的read返回爲0。這裏之因此說可能致使，是由於shutdown時能夠指定shutdown的行爲，是關閉發送仍是接收。
 
第二個問題，被信號中斷時，返回值是什麼？
  1.             timeo = unix_stream_data_wait(sk, timeo);
  3.             if (signal_pending(current)) {
  4.                 err = sock_intr_errno(timeo);
  5.                 goto out;
  6.             }
這幾行代碼是這個問題的答案。這幾行代碼一樣是處於receive queue爲空的判斷中。那麼，這說明若是receive queue中已有數據，且大於要讀取的字節數，那麼在這個函數中，根本就不會去判斷是否有pending的信號，返回值爲讀取的字節數。若是receive queue中沒有足夠的數據，那麼就會運行到此處，檢查是否有pending的信號。當有信號pending時，這時的返回值就決定於copied的值。若是已讀取了一些字節，那麼就返回copied即已讀取了的字節數——小於咱們要去讀取的字節數。若是沒有讀取任何字節，那麼就返回-1，且errno爲EINTR。
 
第三個問題，對端關閉後，是否能夠讀取對端在關閉以前發送的數據。
從前面兩個問題以及第一個問題的答案。這個問題的答案也很明顯了。在unix_stream_recvmsg中，只要receive queue中有數據，那麼就不會去檢查是否sk_shutdown的標誌。因此答案是，即便對端關閉socket，本端仍能夠讀取對端在關閉以前發送的數據。
 
本文只探討了unix域的TCP鏈接的socket的讀取狀況。至於其它種類的socket的read行爲，我猜想Linux仍然會採起一致的行爲——有心人能夠去看代碼驗證一下。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程