Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *     SUCS NET3:
       4                 :            :  *
       5                 :            :  *     Generic stream handling routines. These are generic for most
       6                 :            :  *     protocols. Even IP. Tonight 8-).
       7                 :            :  *     This is used because TCP, LLC (others too) layer all have mostly
       8                 :            :  *     identical sendmsg() and recvmsg() code.
       9                 :            :  *     So we (will) share it here.
      10                 :            :  *
      11                 :            :  *     Authors:        Arnaldo Carvalho de Melo <acme@conectiva.com.br>
      12                 :            :  *                     (from old tcp.c code)
      13                 :            :  *                     Alan Cox <alan@lxorguk.ukuu.org.uk> (Borrowed comments 8-))
      14                 :            :  */
      15                 :            : 
      16                 :            : #include <linux/module.h>
      17                 :            : #include <linux/sched/signal.h>
      18                 :            : #include <linux/net.h>
      19                 :            : #include <linux/signal.h>
      20                 :            : #include <linux/tcp.h>
      21                 :            : #include <linux/wait.h>
      22                 :            : #include <net/sock.h>
      23                 :            : 
      24                 :            : /**
      25                 :            :  * sk_stream_write_space - stream socket write_space callback.
      26                 :            :  * @sk: socket
      27                 :            :  *
      28                 :            :  * FIXME: write proper description
      29                 :            :  */
      30                 :          0 : void sk_stream_write_space(struct sock *sk)
      31                 :            : {
      32                 :          0 :         struct socket *sock = sk->sk_socket;
      33                 :            :         struct socket_wq *wq;
      34                 :            : 
      35                 :          0 :         if (__sk_stream_is_writeable(sk, 1) && sock) {
      36                 :          0 :                 clear_bit(SOCK_NOSPACE, &sock->flags);
      37                 :            : 
      38                 :            :                 rcu_read_lock();
      39                 :          0 :                 wq = rcu_dereference(sk->sk_wq);
      40                 :          0 :                 if (skwq_has_sleeper(wq))
      41                 :          0 :                         wake_up_interruptible_poll(&wq->wait, EPOLLOUT |
      42                 :            :                                                 EPOLLWRNORM | EPOLLWRBAND);
      43                 :          0 :                 if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
      44                 :          0 :                         sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
      45                 :            :                 rcu_read_unlock();
      46                 :            :         }
      47                 :          0 : }
      48                 :            : 
      49                 :            : /**
      50                 :            :  * sk_stream_wait_connect - Wait for a socket to get into the connected state
      51                 :            :  * @sk: sock to wait on
      52                 :            :  * @timeo_p: for how long to wait
      53                 :            :  *
      54                 :            :  * Must be called with the socket locked.
      55                 :            :  */
      56                 :          0 : int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
      57                 :            : {
      58                 :          0 :         DEFINE_WAIT_FUNC(wait, woken_wake_function);
      59                 :          0 :         struct task_struct *tsk = current;
      60                 :            :         int done;
      61                 :            : 
      62                 :            :         do {
      63                 :          0 :                 int err = sock_error(sk);
      64                 :          0 :                 if (err)
      65                 :          0 :                         return err;
      66                 :          0 :                 if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))
      67                 :            :                         return -EPIPE;
      68                 :          0 :                 if (!*timeo_p)
      69                 :            :                         return -EAGAIN;
      70                 :          0 :                 if (signal_pending(tsk))
      71                 :          0 :                         return sock_intr_errno(*timeo_p);
      72                 :            : 
      73                 :          0 :                 add_wait_queue(sk_sleep(sk), &wait);
      74                 :          0 :                 sk->sk_write_pending++;
      75                 :          0 :                 done = sk_wait_event(sk, timeo_p,
      76                 :            :                                      !sk->sk_err &&
      77                 :            :                                      !((1 << sk->sk_state) &
      78                 :            :                                        ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)), &wait);
      79                 :          0 :                 remove_wait_queue(sk_sleep(sk), &wait);
      80                 :          0 :                 sk->sk_write_pending--;
      81                 :          0 :         } while (!done);
      82                 :            :         return 0;
      83                 :            : }
      84                 :            : EXPORT_SYMBOL(sk_stream_wait_connect);
      85                 :            : 
      86                 :            : /**
      87                 :            :  * sk_stream_closing - Return 1 if we still have things to send in our buffers.
      88                 :            :  * @sk: socket to verify
      89                 :            :  */
      90                 :            : static inline int sk_stream_closing(struct sock *sk)
      91                 :            : {
      92                 :          0 :         return (1 << sk->sk_state) &
      93                 :            :                (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK);
      94                 :            : }
      95                 :            : 
      96                 :          1 : void sk_stream_wait_close(struct sock *sk, long timeout)
      97                 :            : {
      98                 :          1 :         if (timeout) {
      99                 :          0 :                 DEFINE_WAIT_FUNC(wait, woken_wake_function);
     100                 :            : 
     101                 :          0 :                 add_wait_queue(sk_sleep(sk), &wait);
     102                 :            : 
     103                 :            :                 do {
     104                 :          0 :                         if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk), &wait))
     105                 :            :                                 break;
     106                 :          0 :                 } while (!signal_pending(current) && timeout);
     107                 :            : 
     108                 :          0 :                 remove_wait_queue(sk_sleep(sk), &wait);
     109                 :            :         }
     110                 :          1 : }
     111                 :            : EXPORT_SYMBOL(sk_stream_wait_close);
     112                 :            : 
     113                 :            : /**
     114                 :            :  * sk_stream_wait_memory - Wait for more memory for a socket
     115                 :            :  * @sk: socket to wait for memory
     116                 :            :  * @timeo_p: for how long
     117                 :            :  */
     118                 :          0 : int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
     119                 :            : {
     120                 :            :         int err = 0;
     121                 :            :         long vm_wait = 0;
     122                 :          0 :         long current_timeo = *timeo_p;
     123                 :          0 :         DEFINE_WAIT_FUNC(wait, woken_wake_function);
     124                 :            : 
     125                 :          0 :         if (sk_stream_memory_free(sk))
     126                 :          0 :                 current_timeo = vm_wait = (prandom_u32() % (HZ / 5)) + 2;
     127                 :            : 
     128                 :          0 :         add_wait_queue(sk_sleep(sk), &wait);
     129                 :            : 
     130                 :            :         while (1) {
     131                 :          0 :                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
     132                 :            : 
     133                 :          0 :                 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
     134                 :            :                         goto do_error;
     135                 :          0 :                 if (!*timeo_p)
     136                 :            :                         goto do_eagain;
     137                 :          0 :                 if (signal_pending(current))
     138                 :            :                         goto do_interrupted;
     139                 :          0 :                 sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
     140                 :          0 :                 if (sk_stream_memory_free(sk) && !vm_wait)
     141                 :            :                         break;
     142                 :            : 
     143                 :          0 :                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
     144                 :          0 :                 sk->sk_write_pending++;
     145                 :          0 :                 sk_wait_event(sk, &current_timeo, sk->sk_err ||
     146                 :            :                                                   (sk->sk_shutdown & SEND_SHUTDOWN) ||
     147                 :            :                                                   (sk_stream_memory_free(sk) &&
     148                 :            :                                                   !vm_wait), &wait);
     149                 :          0 :                 sk->sk_write_pending--;
     150                 :            : 
     151                 :          0 :                 if (vm_wait) {
     152                 :          0 :                         vm_wait -= current_timeo;
     153                 :          0 :                         current_timeo = *timeo_p;
     154                 :          0 :                         if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
     155                 :          0 :                             (current_timeo -= vm_wait) < 0)
     156                 :            :                                 current_timeo = 0;
     157                 :            :                         vm_wait = 0;
     158                 :            :                 }
     159                 :          0 :                 *timeo_p = current_timeo;
     160                 :          0 :         }
     161                 :            : out:
     162                 :          0 :         remove_wait_queue(sk_sleep(sk), &wait);
     163                 :          0 :         return err;
     164                 :            : 
     165                 :            : do_error:
     166                 :            :         err = -EPIPE;
     167                 :            :         goto out;
     168                 :            : do_eagain:
     169                 :            :         /* Make sure that whenever EAGAIN is returned, EPOLLOUT event can
     170                 :            :          * be generated later.
     171                 :            :          * When TCP receives ACK packets that make room, tcp_check_space()
     172                 :            :          * only calls tcp_new_space() if SOCK_NOSPACE is set.
     173                 :            :          */
     174                 :          0 :         set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
     175                 :            :         err = -EAGAIN;
     176                 :          0 :         goto out;
     177                 :            : do_interrupted:
     178                 :          0 :         err = sock_intr_errno(*timeo_p);
     179                 :            :         goto out;
     180                 :            : }
     181                 :            : EXPORT_SYMBOL(sk_stream_wait_memory);
     182                 :            : 
     183                 :          0 : int sk_stream_error(struct sock *sk, int flags, int err)
     184                 :            : {
     185                 :          0 :         if (err == -EPIPE)
     186                 :          0 :                 err = sock_error(sk) ? : -EPIPE;
     187                 :          0 :         if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
     188                 :          0 :                 send_sig(SIGPIPE, current, 0);
     189                 :          0 :         return err;
     190                 :            : }
     191                 :            : EXPORT_SYMBOL(sk_stream_error);
     192                 :            : 
     193                 :          1 : void sk_stream_kill_queues(struct sock *sk)
     194                 :            : {
     195                 :            :         /* First the read buffer. */
     196                 :          1 :         __skb_queue_purge(&sk->sk_receive_queue);
     197                 :            : 
     198                 :            :         /* Next, the error queue. */
     199                 :          1 :         __skb_queue_purge(&sk->sk_error_queue);
     200                 :            : 
     201                 :            :         /* Next, the write queue. */
     202                 :          1 :         WARN_ON(!skb_queue_empty(&sk->sk_write_queue));
     203                 :            : 
     204                 :            :         /* Account for returned memory. */
     205                 :          1 :         sk_mem_reclaim(sk);
     206                 :            : 
     207                 :          1 :         WARN_ON(sk->sk_wmem_queued);
     208                 :          1 :         WARN_ON(sk->sk_forward_alloc);
     209                 :            : 
     210                 :            :         /* It is _impossible_ for the backlog to contain anything
     211                 :            :          * when we get here.  All user references to this socket
     212                 :            :          * have gone away, only the net layer knows can touch it.
     213                 :            :          */
     214                 :          1 : }
     215                 :            : EXPORT_SYMBOL(sk_stream_kill_queues);