Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
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) | |
113aa838 | 13 | * Alan Cox <alan@lxorguk.ukuu.org.uk> (Borrowed comments 8-)) |
1da177e4 LT |
14 | */ |
15 | ||
16 | #include <linux/module.h> | |
3f07c014 | 17 | #include <linux/sched/signal.h> |
1da177e4 LT |
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. | |
4dc3b16b | 26 | * @sk: socket |
1da177e4 LT |
27 | * |
28 | * FIXME: write proper description | |
29 | */ | |
30 | void sk_stream_write_space(struct sock *sk) | |
31 | { | |
32 | struct socket *sock = sk->sk_socket; | |
43815482 | 33 | struct socket_wq *wq; |
1da177e4 | 34 | |
a74f0fa0 | 35 | if (__sk_stream_is_writeable(sk, 1) && sock) { |
1da177e4 LT |
36 | clear_bit(SOCK_NOSPACE, &sock->flags); |
37 | ||
43815482 ED |
38 | rcu_read_lock(); |
39 | wq = rcu_dereference(sk->sk_wq); | |
1ce0bf50 | 40 | if (skwq_has_sleeper(wq)) |
a9a08845 LT |
41 | wake_up_interruptible_poll(&wq->wait, EPOLLOUT | |
42 | EPOLLWRNORM | EPOLLWRBAND); | |
43815482 | 43 | if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN)) |
ceb5d58b | 44 | sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT); |
43815482 | 45 | rcu_read_unlock(); |
1da177e4 LT |
46 | } |
47 | } | |
1da177e4 LT |
48 | |
49 | /** | |
50 | * sk_stream_wait_connect - Wait for a socket to get into the connected state | |
4dc3b16b PP |
51 | * @sk: sock to wait on |
52 | * @timeo_p: for how long to wait | |
1da177e4 LT |
53 | * |
54 | * Must be called with the socket locked. | |
55 | */ | |
56 | int sk_stream_wait_connect(struct sock *sk, long *timeo_p) | |
57 | { | |
d9dc8b0f | 58 | DEFINE_WAIT_FUNC(wait, woken_wake_function); |
1da177e4 | 59 | struct task_struct *tsk = current; |
6151b31c | 60 | int done; |
1da177e4 | 61 | |
6151b31c | 62 | do { |
c1cbe4b7 BL |
63 | int err = sock_error(sk); |
64 | if (err) | |
65 | return err; | |
1da177e4 LT |
66 | if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV)) |
67 | return -EPIPE; | |
68 | if (!*timeo_p) | |
69 | return -EAGAIN; | |
70 | if (signal_pending(tsk)) | |
71 | return sock_intr_errno(*timeo_p); | |
72 | ||
d9dc8b0f | 73 | add_wait_queue(sk_sleep(sk), &wait); |
1da177e4 | 74 | sk->sk_write_pending++; |
6151b31c | 75 | done = sk_wait_event(sk, timeo_p, |
d0ac89f6 ED |
76 | !READ_ONCE(sk->sk_err) && |
77 | !((1 << READ_ONCE(sk->sk_state)) & | |
d9dc8b0f WC |
78 | ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)), &wait); |
79 | remove_wait_queue(sk_sleep(sk), &wait); | |
1da177e4 | 80 | sk->sk_write_pending--; |
6151b31c | 81 | } while (!done); |
1da177e4 LT |
82 | return 0; |
83 | } | |
1da177e4 LT |
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. | |
4dc3b16b | 88 | * @sk: socket to verify |
1da177e4 | 89 | */ |
d0ac89f6 | 90 | static int sk_stream_closing(const struct sock *sk) |
1da177e4 | 91 | { |
d0ac89f6 | 92 | return (1 << READ_ONCE(sk->sk_state)) & |
1da177e4 LT |
93 | (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK); |
94 | } | |
95 | ||
96 | void sk_stream_wait_close(struct sock *sk, long timeout) | |
97 | { | |
98 | if (timeout) { | |
d9dc8b0f WC |
99 | DEFINE_WAIT_FUNC(wait, woken_wake_function); |
100 | ||
101 | add_wait_queue(sk_sleep(sk), &wait); | |
1da177e4 LT |
102 | |
103 | do { | |
d9dc8b0f | 104 | if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk), &wait)) |
1da177e4 LT |
105 | break; |
106 | } while (!signal_pending(current) && timeout); | |
107 | ||
d9dc8b0f | 108 | remove_wait_queue(sk_sleep(sk), &wait); |
1da177e4 LT |
109 | } |
110 | } | |
1da177e4 LT |
111 | EXPORT_SYMBOL(sk_stream_wait_close); |
112 | ||
113 | /** | |
114 | * sk_stream_wait_memory - Wait for more memory for a socket | |
4dc3b16b PP |
115 | * @sk: socket to wait for memory |
116 | * @timeo_p: for how long | |
1da177e4 LT |
117 | */ |
118 | int sk_stream_wait_memory(struct sock *sk, long *timeo_p) | |
119 | { | |
120 | int err = 0; | |
121 | long vm_wait = 0; | |
122 | long current_timeo = *timeo_p; | |
d9dc8b0f | 123 | DEFINE_WAIT_FUNC(wait, woken_wake_function); |
1da177e4 LT |
124 | |
125 | if (sk_stream_memory_free(sk)) | |
8032bf12 | 126 | current_timeo = vm_wait = get_random_u32_below(HZ / 5) + 2; |
1da177e4 | 127 | |
d9dc8b0f WC |
128 | add_wait_queue(sk_sleep(sk), &wait); |
129 | ||
1da177e4 | 130 | while (1) { |
9cd3e072 | 131 | sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk); |
1da177e4 | 132 | |
1da177e4 LT |
133 | if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) |
134 | goto do_error; | |
ef8d8ccd ED |
135 | if (!*timeo_p) |
136 | goto do_eagain; | |
1da177e4 LT |
137 | if (signal_pending(current)) |
138 | goto do_interrupted; | |
9cd3e072 | 139 | sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); |
1da177e4 LT |
140 | if (sk_stream_memory_free(sk) && !vm_wait) |
141 | break; | |
142 | ||
143 | set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); | |
144 | sk->sk_write_pending++; | |
d0ac89f6 ED |
145 | sk_wait_event(sk, ¤t_timeo, READ_ONCE(sk->sk_err) || |
146 | (READ_ONCE(sk->sk_shutdown) & SEND_SHUTDOWN) || | |
482964e5 | 147 | (sk_stream_memory_free(sk) && |
d9dc8b0f | 148 | !vm_wait), &wait); |
1da177e4 LT |
149 | sk->sk_write_pending--; |
150 | ||
151 | if (vm_wait) { | |
152 | vm_wait -= current_timeo; | |
153 | current_timeo = *timeo_p; | |
154 | if (current_timeo != MAX_SCHEDULE_TIMEOUT && | |
155 | (current_timeo -= vm_wait) < 0) | |
156 | current_timeo = 0; | |
157 | vm_wait = 0; | |
158 | } | |
159 | *timeo_p = current_timeo; | |
160 | } | |
161 | out: | |
3f8ef65a LJ |
162 | if (!sock_flag(sk, SOCK_DEAD)) |
163 | remove_wait_queue(sk_sleep(sk), &wait); | |
1da177e4 LT |
164 | return err; |
165 | ||
166 | do_error: | |
167 | err = -EPIPE; | |
168 | goto out; | |
ef8d8ccd ED |
169 | do_eagain: |
170 | /* Make sure that whenever EAGAIN is returned, EPOLLOUT event can | |
171 | * be generated later. | |
172 | * When TCP receives ACK packets that make room, tcp_check_space() | |
173 | * only calls tcp_new_space() if SOCK_NOSPACE is set. | |
174 | */ | |
175 | set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); | |
1da177e4 LT |
176 | err = -EAGAIN; |
177 | goto out; | |
178 | do_interrupted: | |
179 | err = sock_intr_errno(*timeo_p); | |
180 | goto out; | |
181 | } | |
1da177e4 LT |
182 | EXPORT_SYMBOL(sk_stream_wait_memory); |
183 | ||
1da177e4 LT |
184 | int sk_stream_error(struct sock *sk, int flags, int err) |
185 | { | |
186 | if (err == -EPIPE) | |
187 | err = sock_error(sk) ? : -EPIPE; | |
188 | if (err == -EPIPE && !(flags & MSG_NOSIGNAL)) | |
189 | send_sig(SIGPIPE, current, 0); | |
190 | return err; | |
191 | } | |
1da177e4 LT |
192 | EXPORT_SYMBOL(sk_stream_error); |
193 | ||
1da177e4 LT |
194 | void sk_stream_kill_queues(struct sock *sk) |
195 | { | |
196 | /* First the read buffer. */ | |
197 | __skb_queue_purge(&sk->sk_receive_queue); | |
198 | ||
e0c8bccd ED |
199 | /* Next, the error queue. |
200 | * We need to use queue lock, because other threads might | |
201 | * add packets to the queue without socket lock being held. | |
202 | */ | |
203 | skb_queue_purge(&sk->sk_error_queue); | |
204 | ||
1da177e4 | 205 | /* Next, the write queue. */ |
c59f02f8 | 206 | WARN_ON_ONCE(!skb_queue_empty(&sk->sk_write_queue)); |
1da177e4 LT |
207 | |
208 | /* Account for returned memory. */ | |
2bb2f5fb | 209 | sk_mem_reclaim_final(sk); |
1da177e4 | 210 | |
c59f02f8 | 211 | WARN_ON_ONCE(sk->sk_wmem_queued); |
1da177e4 LT |
212 | |
213 | /* It is _impossible_ for the backlog to contain anything | |
214 | * when we get here. All user references to this socket | |
215 | * have gone away, only the net layer knows can touch it. | |
216 | */ | |
217 | } | |
1da177e4 | 218 | EXPORT_SYMBOL(sk_stream_kill_queues); |