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