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 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_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); 40 } 41 } 42 43 EXPORT_SYMBOL(sk_stream_write_space); 44 45 /** 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 49 * 50 * Must be called with the socket locked. 51 */ 52 int sk_stream_wait_connect(struct sock *sk, long *timeo_p) 53 { 54 struct task_struct *tsk = current; 55 DEFINE_WAIT(wait); 56 int done; 57 58 do { 59 int err = sock_error(sk); 60 if (err) 61 return err; 62 if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV)) 63 return -EPIPE; 64 if (!*timeo_p) 65 return -EAGAIN; 66 if (signal_pending(tsk)) 67 return sock_intr_errno(*timeo_p); 68 69 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 70 sk->sk_write_pending++; 71 done = sk_wait_event(sk, timeo_p, 72 !sk->sk_err && 73 !((1 << sk->sk_state) & 74 ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))); 75 finish_wait(sk->sk_sleep, &wait); 76 sk->sk_write_pending--; 77 } while (!done); 78 return 0; 79 } 80 81 EXPORT_SYMBOL(sk_stream_wait_connect); 82 83 /** 84 * sk_stream_closing - Return 1 if we still have things to send in our buffers. 85 * @sk: socket to verify 86 */ 87 static inline int sk_stream_closing(struct sock *sk) 88 { 89 return (1 << sk->sk_state) & 90 (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK); 91 } 92 93 void sk_stream_wait_close(struct sock *sk, long timeout) 94 { 95 if (timeout) { 96 DEFINE_WAIT(wait); 97 98 do { 99 prepare_to_wait(sk->sk_sleep, &wait, 100 TASK_INTERRUPTIBLE); 101 if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk))) 102 break; 103 } while (!signal_pending(current) && timeout); 104 105 finish_wait(sk->sk_sleep, &wait); 106 } 107 } 108 109 EXPORT_SYMBOL(sk_stream_wait_close); 110 111 /** 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 115 */ 116 int sk_stream_wait_memory(struct sock *sk, long *timeo_p) 117 { 118 int err = 0; 119 long vm_wait = 0; 120 long current_timeo = *timeo_p; 121 DEFINE_WAIT(wait); 122 123 if (sk_stream_memory_free(sk)) 124 current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2; 125 126 while (1) { 127 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 128 129 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 130 131 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) 132 goto do_error; 133 if (!*timeo_p) 134 goto do_nonblock; 135 if (signal_pending(current)) 136 goto do_interrupted; 137 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 138 if (sk_stream_memory_free(sk) && !vm_wait) 139 break; 140 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) && 146 vm_wait); 147 sk->sk_write_pending--; 148 149 if (vm_wait) { 150 vm_wait -= current_timeo; 151 current_timeo = *timeo_p; 152 if (current_timeo != MAX_SCHEDULE_TIMEOUT && 153 (current_timeo -= vm_wait) < 0) 154 current_timeo = 0; 155 vm_wait = 0; 156 } 157 *timeo_p = current_timeo; 158 } 159 out: 160 finish_wait(sk->sk_sleep, &wait); 161 return err; 162 163 do_error: 164 err = -EPIPE; 165 goto out; 166 do_nonblock: 167 err = -EAGAIN; 168 goto out; 169 do_interrupted: 170 err = sock_intr_errno(*timeo_p); 171 goto out; 172 } 173 174 EXPORT_SYMBOL(sk_stream_wait_memory); 175 176 int sk_stream_error(struct sock *sk, int flags, int err) 177 { 178 if (err == -EPIPE) 179 err = sock_error(sk) ? : -EPIPE; 180 if (err == -EPIPE && !(flags & MSG_NOSIGNAL)) 181 send_sig(SIGPIPE, current, 0); 182 return err; 183 } 184 185 EXPORT_SYMBOL(sk_stream_error); 186 187 void sk_stream_kill_queues(struct sock *sk) 188 { 189 /* First the read buffer. */ 190 __skb_queue_purge(&sk->sk_receive_queue); 191 192 /* Next, the error queue. */ 193 __skb_queue_purge(&sk->sk_error_queue); 194 195 /* Next, the write queue. */ 196 WARN_ON(!skb_queue_empty(&sk->sk_write_queue)); 197 198 /* Account for returned memory. */ 199 sk_mem_reclaim(sk); 200 201 WARN_ON(sk->sk_wmem_queued); 202 WARN_ON(sk->sk_forward_alloc); 203 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. 207 */ 208 } 209 210 EXPORT_SYMBOL(sk_stream_kill_queues); 211