]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - net/core/stream.c
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.
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-))
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>
23 * sk_stream_write_space - stream socket write_space callback.
26 * FIXME: write proper description
28 void sk_stream_write_space(struct sock
*sk
)
30 struct socket
*sock
= sk
->sk_socket
;
33 if (sk_stream_is_writeable(sk
) && sock
) {
34 clear_bit(SOCK_NOSPACE
, &sock
->flags
);
37 wq
= rcu_dereference(sk
->sk_wq
);
38 if (wq_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(sock
, SOCK_WAKE_SPACE
, POLL_OUT
);
46 EXPORT_SYMBOL(sk_stream_write_space
);
49 * sk_stream_wait_connect - Wait for a socket to get into the connected state
50 * @sk: sock to wait on
51 * @timeo_p: for how long to wait
53 * Must be called with the socket locked.
55 int sk_stream_wait_connect(struct sock
*sk
, long *timeo_p
)
57 struct task_struct
*tsk
= current
;
62 int err
= sock_error(sk
);
65 if ((1 << sk
->sk_state
) & ~(TCPF_SYN_SENT
| TCPF_SYN_RECV
))
69 if (signal_pending(tsk
))
70 return sock_intr_errno(*timeo_p
);
72 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
73 sk
->sk_write_pending
++;
74 done
= sk_wait_event(sk
, timeo_p
,
76 !((1 << sk
->sk_state
) &
77 ~(TCPF_ESTABLISHED
| TCPF_CLOSE_WAIT
)));
78 finish_wait(sk_sleep(sk
), &wait
);
79 sk
->sk_write_pending
--;
83 EXPORT_SYMBOL(sk_stream_wait_connect
);
86 * sk_stream_closing - Return 1 if we still have things to send in our buffers.
87 * @sk: socket to verify
89 static inline int sk_stream_closing(struct sock
*sk
)
91 return (1 << sk
->sk_state
) &
92 (TCPF_FIN_WAIT1
| TCPF_CLOSING
| TCPF_LAST_ACK
);
95 void sk_stream_wait_close(struct sock
*sk
, long timeout
)
101 prepare_to_wait(sk_sleep(sk
), &wait
,
103 if (sk_wait_event(sk
, &timeout
, !sk_stream_closing(sk
)))
105 } while (!signal_pending(current
) && timeout
);
107 finish_wait(sk_sleep(sk
), &wait
);
110 EXPORT_SYMBOL(sk_stream_wait_close
);
113 * sk_stream_wait_memory - Wait for more memory for a socket
114 * @sk: socket to wait for memory
115 * @timeo_p: for how long
117 int sk_stream_wait_memory(struct sock
*sk
, long *timeo_p
)
121 long current_timeo
= *timeo_p
;
124 if (sk_stream_memory_free(sk
))
125 current_timeo
= vm_wait
= (net_random() % (HZ
/ 5)) + 2;
128 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
130 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
132 if (sk
->sk_err
|| (sk
->sk_shutdown
& SEND_SHUTDOWN
))
136 if (signal_pending(current
))
138 clear_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
139 if (sk_stream_memory_free(sk
) && !vm_wait
)
142 set_bit(SOCK_NOSPACE
, &sk
->sk_socket
->flags
);
143 sk
->sk_write_pending
++;
144 sk_wait_event(sk
, ¤t_timeo
, sk
->sk_err
||
145 (sk
->sk_shutdown
& SEND_SHUTDOWN
) ||
146 (sk_stream_memory_free(sk
) &&
148 sk
->sk_write_pending
--;
151 vm_wait
-= current_timeo
;
152 current_timeo
= *timeo_p
;
153 if (current_timeo
!= MAX_SCHEDULE_TIMEOUT
&&
154 (current_timeo
-= vm_wait
) < 0)
158 *timeo_p
= current_timeo
;
161 finish_wait(sk_sleep(sk
), &wait
);
171 err
= sock_intr_errno(*timeo_p
);
174 EXPORT_SYMBOL(sk_stream_wait_memory
);
176 int sk_stream_error(struct sock
*sk
, int flags
, int err
)
179 err
= sock_error(sk
) ? : -EPIPE
;
180 if (err
== -EPIPE
&& !(flags
& MSG_NOSIGNAL
))
181 send_sig(SIGPIPE
, current
, 0);
184 EXPORT_SYMBOL(sk_stream_error
);
186 void sk_stream_kill_queues(struct sock
*sk
)
188 /* First the read buffer. */
189 __skb_queue_purge(&sk
->sk_receive_queue
);
191 /* Next, the error queue. */
192 __skb_queue_purge(&sk
->sk_error_queue
);
194 /* Next, the write queue. */
195 WARN_ON(!skb_queue_empty(&sk
->sk_write_queue
));
197 /* Account for returned memory. */
200 WARN_ON(sk
->sk_wmem_queued
);
201 WARN_ON(sk
->sk_forward_alloc
);
203 /* It is _impossible_ for the backlog to contain anything
204 * when we get here. All user references to this socket
205 * have gone away, only the net layer knows can touch it.
208 EXPORT_SYMBOL(sk_stream_kill_queues
);