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