~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/core/stream.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp