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
;
32 if (sk_stream_wspace(sk
) >= sk_stream_min_wspace(sk
) && sock
) {
33 clear_bit(SOCK_NOSPACE
, &sock
->flags
);
35 if (sk
->sk_sleep
&& waitqueue_active(sk
->sk_sleep
))
36 wake_up_interruptible_poll(sk
->sk_sleep
, POLLOUT
|
37 POLLWRNORM
| POLLWRBAND
);
38 if (sock
->fasync_list
&& !(sk
->sk_shutdown
& SEND_SHUTDOWN
))
39 sock_wake_async(sock
, SOCK_WAKE_SPACE
, POLL_OUT
);
43 EXPORT_SYMBOL(sk_stream_write_space
);
46 * sk_stream_wait_connect - Wait for a socket to get into the connected state
47 * @sk: sock to wait on
48 * @timeo_p: for how long to wait
50 * Must be called with the socket locked.
52 int sk_stream_wait_connect(struct sock
*sk
, long *timeo_p
)
54 struct task_struct
*tsk
= current
;
59 int err
= sock_error(sk
);
62 if ((1 << sk
->sk_state
) & ~(TCPF_SYN_SENT
| TCPF_SYN_RECV
))
66 if (signal_pending(tsk
))
67 return sock_intr_errno(*timeo_p
);
69 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
70 sk
->sk_write_pending
++;
71 done
= sk_wait_event(sk
, timeo_p
,
73 !((1 << sk
->sk_state
) &
74 ~(TCPF_ESTABLISHED
| TCPF_CLOSE_WAIT
)));
75 finish_wait(sk
->sk_sleep
, &wait
);
76 sk
->sk_write_pending
--;
81 EXPORT_SYMBOL(sk_stream_wait_connect
);
84 * sk_stream_closing - Return 1 if we still have things to send in our buffers.
85 * @sk: socket to verify
87 static inline int sk_stream_closing(struct sock
*sk
)
89 return (1 << sk
->sk_state
) &
90 (TCPF_FIN_WAIT1
| TCPF_CLOSING
| TCPF_LAST_ACK
);
93 void sk_stream_wait_close(struct sock
*sk
, long timeout
)
99 prepare_to_wait(sk
->sk_sleep
, &wait
,
101 if (sk_wait_event(sk
, &timeout
, !sk_stream_closing(sk
)))
103 } while (!signal_pending(current
) && timeout
);
105 finish_wait(sk
->sk_sleep
, &wait
);
109 EXPORT_SYMBOL(sk_stream_wait_close
);
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
116 int sk_stream_wait_memory(struct sock
*sk
, long *timeo_p
)
120 long current_timeo
= *timeo_p
;
123 if (sk_stream_memory_free(sk
))
124 current_timeo
= vm_wait
= (net_random() % (HZ
/ 5)) + 2;
127 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
129 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
131 if (sk
->sk_err
|| (sk
->sk_shutdown
& SEND_SHUTDOWN
))
135 if (signal_pending(current
))
137 clear_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
138 if (sk_stream_memory_free(sk
) && !vm_wait
)
141 set_bit(SOCK_NOSPACE
, &sk
->sk_socket
->flags
);
142 sk
->sk_write_pending
++;
143 sk_wait_event(sk
, ¤t_timeo
, !sk
->sk_err
&&
144 !(sk
->sk_shutdown
& SEND_SHUTDOWN
) &&
145 sk_stream_memory_free(sk
) &&
147 sk
->sk_write_pending
--;
150 vm_wait
-= current_timeo
;
151 current_timeo
= *timeo_p
;
152 if (current_timeo
!= MAX_SCHEDULE_TIMEOUT
&&
153 (current_timeo
-= vm_wait
) < 0)
157 *timeo_p
= current_timeo
;
160 finish_wait(sk
->sk_sleep
, &wait
);
170 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);
185 EXPORT_SYMBOL(sk_stream_error
);
187 void sk_stream_kill_queues(struct sock
*sk
)
189 /* First the read buffer. */
190 __skb_queue_purge(&sk
->sk_receive_queue
);
192 /* Next, the error queue. */
193 __skb_queue_purge(&sk
->sk_error_queue
);
195 /* Next, the write queue. */
196 WARN_ON(!skb_queue_empty(&sk
->sk_write_queue
));
198 /* Account for returned memory. */
201 WARN_ON(sk
->sk_wmem_queued
);
202 WARN_ON(sk
->sk_forward_alloc
);
204 /* It is _impossible_ for the backlog to contain anything
205 * when we get here. All user references to this socket
206 * have gone away, only the net layer knows can touch it.
210 EXPORT_SYMBOL(sk_stream_kill_queues
);
This page took 0.034815 seconds and 5 git commands to generate.