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@redhat.com> (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
32 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
33 clear_bit(SOCK_NOSPACE, &sock->flags);
34
35 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
36 wake_up_interruptible(sk->sk_sleep);
37 if (sock->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
38 sock_wake_async(sock, 2, POLL_OUT);
39 }
40 }
41
42 EXPORT_SYMBOL(sk_stream_write_space);
43
44 /**
45 * sk_stream_wait_connect - Wait for a socket to get into the connected state
46 * @sk - sock to wait on
47 * @timeo_p - for how long to wait
48 *
49 * Must be called with the socket locked.
50 */
51 int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
52 {
53 struct task_struct *tsk = current;
54 DEFINE_WAIT(wait);
55
56 while (1) {
57 if (sk->sk_err)
58 return sock_error(sk);
59 if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))
60 return -EPIPE;
61 if (!*timeo_p)
62 return -EAGAIN;
63 if (signal_pending(tsk))
64 return sock_intr_errno(*timeo_p);
65
66 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
67 sk->sk_write_pending++;
68 if (sk_wait_event(sk, timeo_p,
69 !((1 << sk->sk_state) &
70 ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))))
71 break;
72 finish_wait(sk->sk_sleep, &wait);
73 sk->sk_write_pending--;
74 }
75 return 0;
76 }
77
78 EXPORT_SYMBOL(sk_stream_wait_connect);
79
80 /**
81 * sk_stream_closing - Return 1 if we still have things to send in our buffers.
82 * @sk - socket to verify
83 */
84 static inline int sk_stream_closing(struct sock *sk)
85 {
86 return (1 << sk->sk_state) &
87 (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK);
88 }
89
90 void sk_stream_wait_close(struct sock *sk, long timeout)
91 {
92 if (timeout) {
93 DEFINE_WAIT(wait);
94
95 do {
96 prepare_to_wait(sk->sk_sleep, &wait,
97 TASK_INTERRUPTIBLE);
98 if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))
99 break;
100 } while (!signal_pending(current) && timeout);
101
102 finish_wait(sk->sk_sleep, &wait);
103 }
104 }
105
106 EXPORT_SYMBOL(sk_stream_wait_close);
107
108 /**
109 * sk_stream_wait_memory - Wait for more memory for a socket
110 * @sk - socket to wait for memory
111 * @timeo_p - for how long
112 */
113 int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
114 {
115 int err = 0;
116 long vm_wait = 0;
117 long current_timeo = *timeo_p;
118 DEFINE_WAIT(wait);
119
120 if (sk_stream_memory_free(sk))
121 current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;
122
123 while (1) {
124 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
125
126 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
127
128 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
129 goto do_error;
130 if (!*timeo_p)
131 goto do_nonblock;
132 if (signal_pending(current))
133 goto do_interrupted;
134 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
135 if (sk_stream_memory_free(sk) && !vm_wait)
136 break;
137
138 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
139 sk->sk_write_pending++;
140 sk_wait_event(sk, ¤t_timeo, sk_stream_memory_free(sk) &&
141 vm_wait);
142 sk->sk_write_pending--;
143
144 if (vm_wait) {
145 vm_wait -= current_timeo;
146 current_timeo = *timeo_p;
147 if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
148 (current_timeo -= vm_wait) < 0)
149 current_timeo = 0;
150 vm_wait = 0;
151 }
152 *timeo_p = current_timeo;
153 }
154 out:
155 finish_wait(sk->sk_sleep, &wait);
156 return err;
157
158 do_error:
159 err = -EPIPE;
160 goto out;
161 do_nonblock:
162 err = -EAGAIN;
163 goto out;
164 do_interrupted:
165 err = sock_intr_errno(*timeo_p);
166 goto out;
167 }
168
169 EXPORT_SYMBOL(sk_stream_wait_memory);
170
171 void sk_stream_rfree(struct sk_buff *skb)
172 {
173 struct sock *sk = skb->sk;
174
175 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
176 sk->sk_forward_alloc += skb->truesize;
177 }
178
179 EXPORT_SYMBOL(sk_stream_rfree);
180
181 int sk_stream_error(struct sock *sk, int flags, int err)
182 {
183 if (err == -EPIPE)
184 err = sock_error(sk) ? : -EPIPE;
185 if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
186 send_sig(SIGPIPE, current, 0);
187 return err;
188 }
189
190 EXPORT_SYMBOL(sk_stream_error);
191
192 void __sk_stream_mem_reclaim(struct sock *sk)
193 {
194 if (sk->sk_forward_alloc >= SK_STREAM_MEM_QUANTUM) {
195 atomic_sub(sk->sk_forward_alloc / SK_STREAM_MEM_QUANTUM,
196 sk->sk_prot->memory_allocated);
197 sk->sk_forward_alloc &= SK_STREAM_MEM_QUANTUM - 1;
198 if (*sk->sk_prot->memory_pressure &&
199 (atomic_read(sk->sk_prot->memory_allocated) <
200 sk->sk_prot->sysctl_mem[0]))
201 *sk->sk_prot->memory_pressure = 0;
202 }
203 }
204
205 EXPORT_SYMBOL(__sk_stream_mem_reclaim);
206
207 int sk_stream_mem_schedule(struct sock *sk, int size, int kind)
208 {
209 int amt = sk_stream_pages(size);
210
211 sk->sk_forward_alloc += amt * SK_STREAM_MEM_QUANTUM;
212 atomic_add(amt, sk->sk_prot->memory_allocated);
213
214 /* Under limit. */
215 if (atomic_read(sk->sk_prot->memory_allocated) < sk->sk_prot->sysctl_mem[0]) {
216 if (*sk->sk_prot->memory_pressure)
217 *sk->sk_prot->memory_pressure = 0;
218 return 1;
219 }
220
221 /* Over hard limit. */
222 if (atomic_read(sk->sk_prot->memory_allocated) > sk->sk_prot->sysctl_mem[2]) {
223 sk->sk_prot->enter_memory_pressure();
224 goto suppress_allocation;
225 }
226
227 /* Under pressure. */
228 if (atomic_read(sk->sk_prot->memory_allocated) > sk->sk_prot->sysctl_mem[1])
229 sk->sk_prot->enter_memory_pressure();
230
231 if (kind) {
232 if (atomic_read(&sk->sk_rmem_alloc) < sk->sk_prot->sysctl_rmem[0])
233 return 1;
234 } else if (sk->sk_wmem_queued < sk->sk_prot->sysctl_wmem[0])
235 return 1;
236
237 if (!*sk->sk_prot->memory_pressure ||
238 sk->sk_prot->sysctl_mem[2] > atomic_read(sk->sk_prot->sockets_allocated) *
239 sk_stream_pages(sk->sk_wmem_queued +
240 atomic_read(&sk->sk_rmem_alloc) +
241 sk->sk_forward_alloc))
242 return 1;
243
244 suppress_allocation:
245
246 if (!kind) {
247 sk_stream_moderate_sndbuf(sk);
248
249 /* Fail only if socket is _under_ its sndbuf.
250 * In this case we cannot block, so that we have to fail.
251 */
252 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
253 return 1;
254 }
255
256 /* Alas. Undo changes. */
257 sk->sk_forward_alloc -= amt * SK_STREAM_MEM_QUANTUM;
258 atomic_sub(amt, sk->sk_prot->memory_allocated);
259 return 0;
260 }
261
262 EXPORT_SYMBOL(sk_stream_mem_schedule);
263
264 void sk_stream_kill_queues(struct sock *sk)
265 {
266 /* First the read buffer. */
267 __skb_queue_purge(&sk->sk_receive_queue);
268
269 /* Next, the error queue. */
270 __skb_queue_purge(&sk->sk_error_queue);
271
272 /* Next, the write queue. */
273 BUG_TRAP(skb_queue_empty(&sk->sk_write_queue));
274
275 /* Account for returned memory. */
276 sk_stream_mem_reclaim(sk);
277
278 BUG_TRAP(!sk->sk_wmem_queued);
279 BUG_TRAP(!sk->sk_forward_alloc);
280
281 /* It is _impossible_ for the backlog to contain anything
282 * when we get here. All user references to this socket
283 * have gone away, only the net layer knows can touch it.
284 */
285 }
286
287 EXPORT_SYMBOL(sk_stream_kill_queues);
288
|
This page was automatically generated by the
LXR engine.
|