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 22void sk_stream_write_space(struct sock *sk) 23{ 24 struct socket *sock = sk->sk_socket; 25 struct socket_wq *wq; 26 27 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) { 28 clear_bit(SOCK_NOSPACE, &sock->flags); 29 30 rcu_read_lock(); 31 wq = rcu_dereference(sk->sk_wq); 32 if (wq_has_sleeper(wq)) 33 wake_up_interruptible_poll(&wq->wait, POLLOUT | 34 POLLWRNORM | POLLWRBAND); 35 if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN)) 36 sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT); 37 rcu_read_unlock(); 38 } 39} 40EXPORT_SYMBOL(sk_stream_write_space); 41 42/** 43 * sk_stream_wait_connect - Wait for a socket to get into the connected state 44 * @sk: sock to wait on 45 * @timeo_p: for how long to wait 46 * 47 * Must be called with the socket locked. 48 */ 49int sk_stream_wait_connect(struct sock *sk, long *timeo_p) 50{ 51 struct task_struct *tsk = current; 52 DEFINE_WAIT(wait); 53 int done; 54 55 do { 56 int err = sock_error(sk); 57 if (err) 58 return err; 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_sleep(sk), &wait, TASK_INTERRUPTIBLE); 67 sk->sk_write_pending++; 68 done = sk_wait_event(sk, timeo_p, 69 !sk->sk_err && 70 !((1 << sk->sk_state) & 71 ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))); 72 finish_wait(sk_sleep(sk), &wait); 73 sk->sk_write_pending--; 74 } while (!done); 75 return 0; 76} 77EXPORT_SYMBOL(sk_stream_wait_connect); 78 79/** 80 * sk_stream_closing - Return 1 if we still have things to send in our buffers. 81 * @sk: socket to verify 82 */ 83static inline int sk_stream_closing(struct sock *sk) 84{ 85 return (1 << sk->sk_state) & 86 (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK); 87} 88 89void sk_stream_wait_close(struct sock *sk, long timeout) 90{ 91 if (timeout) { 92 DEFINE_WAIT(wait); 93 94 do { 95 prepare_to_wait(sk_sleep(sk), &wait, 96 TASK_INTERRUPTIBLE); 97 if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk))) 98 break; 99 } while (!signal_pending(current) && timeout); 100 101 finish_wait(sk_sleep(sk), &wait); 102 } 103} 104EXPORT_SYMBOL(sk_stream_wait_close); 105 106/** 107 * sk_stream_wait_memory - Wait for more memory for a socket 108 * @sk: socket to wait for memory 109 * @timeo_p: for how long 110 */ 111int sk_stream_wait_memory(struct sock *sk, long *timeo_p) 112{ 113 int err = 0; 114 long vm_wait = 0; 115 long current_timeo = *timeo_p; 116 DEFINE_WAIT(wait); 117 118 if (sk_stream_memory_free(sk)) 119 current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2; 120 121 while (1) { 122 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 123 124 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 125 126 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) 127 goto do_error; 128 if (!*timeo_p) 129 goto do_nonblock; 130 if (signal_pending(current)) 131 goto do_interrupted; 132 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 133 if (sk_stream_memory_free(sk) && !vm_wait) 134 break; 135 136 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 137 sk->sk_write_pending++; 138 sk_wait_event(sk, ¤t_timeo, sk->sk_err || 139 (sk->sk_shutdown & SEND_SHUTDOWN) || 140 (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 } 154out: 155 finish_wait(sk_sleep(sk), &wait); 156 return err; 157 158do_error: 159 err = -EPIPE; 160 goto out; 161do_nonblock: 162 err = -EAGAIN; 163 goto out; 164do_interrupted: 165 err = sock_intr_errno(*timeo_p); 166 goto out; 167} 168EXPORT_SYMBOL(sk_stream_wait_memory); 169 170int sk_stream_error(struct sock *sk, int flags, int err) 171{ 172 if (err == -EPIPE) 173 err = sock_error(sk) ? : -EPIPE; 174 if (err == -EPIPE && !(flags & MSG_NOSIGNAL)) 175 send_sig(SIGPIPE, current, 0); 176 return err; 177} 178EXPORT_SYMBOL(sk_stream_error); 179 180void sk_stream_kill_queues(struct sock *sk) 181{ 182 /* First the read buffer. */ 183 __skb_queue_purge(&sk->sk_receive_queue); 184 185 /* Next, the error queue. */ 186 __skb_queue_purge(&sk->sk_error_queue); 187 188 /* Next, the write queue. */ 189 WARN_ON(!skb_queue_empty(&sk->sk_write_queue)); 190 191 /* Account for returned memory. */ 192 sk_mem_reclaim(sk); 193 194 WARN_ON(sk->sk_wmem_queued); 195 WARN_ON(sk->sk_forward_alloc); 196 197 /* It is _impossible_ for the backlog to contain anything 198 * when we get here. All user references to this socket 199 * have gone away, only the net layer knows can touch it. 200 */ 201} 202EXPORT_SYMBOL(sk_stream_kill_queues); 203