Branch data Line data Source code
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 : 0 : void sk_stream_write_space(struct sock *sk)
29 : : {
30 : 2 : struct socket *sock = sk->sk_socket;
31 : : struct socket_wq *wq;
32 : :
33 [ + - ][ + - ]: 2 : if (sk_stream_is_writeable(sk) && sock) {
34 : 2 : clear_bit(SOCK_NOSPACE, &sock->flags);
35 : :
36 : : rcu_read_lock();
37 : 2 : wq = rcu_dereference(sk->sk_wq);
38 [ + - ]: 2 : if (wq_has_sleeper(wq))
39 : 2 : wake_up_interruptible_poll(&wq->wait, POLLOUT |
40 : : POLLWRNORM | POLLWRBAND);
41 [ + - ][ - + ]: 2 : if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
[ # # ]
42 : 0 : sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
43 : : rcu_read_unlock();
44 : : }
45 : 0 : }
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 : 0 : int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
56 : : {
57 : 6 : struct task_struct *tsk = current;
58 : 6 : DEFINE_WAIT(wait);
59 : : int done;
60 : :
61 : : do {
62 : : int err = sock_error(sk);
63 [ + - ]: 6 : if (err)
64 : : return err;
65 [ - + ]: 6 : if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))
66 : : return -EPIPE;
67 [ # # ]: 0 : if (!*timeo_p)
68 : : return -EAGAIN;
69 [ # # ]: 0 : if (signal_pending(tsk))
70 : 0 : return sock_intr_errno(*timeo_p);
71 : :
72 : 0 : prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
73 : 0 : sk->sk_write_pending++;
74 [ # # ][ # # ]: 0 : done = sk_wait_event(sk, timeo_p,
[ # # ][ # # ]
[ # # ]
75 : : !sk->sk_err &&
76 : : !((1 << sk->sk_state) &
77 : : ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));
78 : 0 : finish_wait(sk_sleep(sk), &wait);
79 : 0 : sk->sk_write_pending--;
80 [ # # ]: 0 : } 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 : 0 : return (1 << sk->sk_state) &
92 : : (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK);
93 : : }
94 : :
95 : 0 : void sk_stream_wait_close(struct sock *sk, long timeout)
96 : : {
97 [ - + ]: 43 : if (timeout) {
98 : 0 : DEFINE_WAIT(wait);
99 : :
100 : : do {
101 : 0 : prepare_to_wait(sk_sleep(sk), &wait,
102 : : TASK_INTERRUPTIBLE);
103 [ # # ][ # # ]: 0 : if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))
104 : : break;
105 [ # # ][ # # ]: 0 : } while (!signal_pending(current) && timeout);
106 : :
107 : 0 : finish_wait(sk_sleep(sk), &wait);
108 : : }
109 : 43 : }
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 : 0 : int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
118 : : {
119 : : int err = 0;
120 : : long vm_wait = 0;
121 : 0 : long current_timeo = *timeo_p;
122 : 0 : DEFINE_WAIT(wait);
123 : :
124 [ # # ]: 0 : if (sk_stream_memory_free(sk))
125 : 0 : current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;
126 : :
127 : : while (1) {
128 : 0 : set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
129 : :
130 : 0 : prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
131 : :
132 [ # # ][ # # ]: 0 : if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
133 : : goto do_error;
134 [ # # ]: 0 : if (!*timeo_p)
135 : : goto do_nonblock;
136 [ # # ]: 0 : if (signal_pending(current))
137 : : goto do_interrupted;
138 : 0 : clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
139 [ # # ][ # # ]: 0 : if (sk_stream_memory_free(sk) && !vm_wait)
140 : : break;
141 : :
142 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
143 : 0 : sk->sk_write_pending++;
144 [ # # ][ # # ]: 0 : sk_wait_event(sk, ¤t_timeo, sk->sk_err ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
145 : : (sk->sk_shutdown & SEND_SHUTDOWN) ||
146 : : (sk_stream_memory_free(sk) &&
147 : : !vm_wait));
148 : 0 : sk->sk_write_pending--;
149 : :
150 [ # # ]: 0 : if (vm_wait) {
151 : 0 : vm_wait -= current_timeo;
152 : 0 : current_timeo = *timeo_p;
153 [ # # ][ # # ]: 0 : if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
154 : 0 : (current_timeo -= vm_wait) < 0)
155 : : current_timeo = 0;
156 : : vm_wait = 0;
157 : : }
158 : 0 : *timeo_p = current_timeo;
159 : 0 : }
160 : : out:
161 : 0 : finish_wait(sk_sleep(sk), &wait);
162 : 0 : return err;
163 : :
164 : : do_error:
165 : : err = -EPIPE;
166 : : goto out;
167 : : do_nonblock:
168 : : err = -EAGAIN;
169 : : goto out;
170 : : do_interrupted:
171 : : err = sock_intr_errno(*timeo_p);
172 : : goto out;
173 : : }
174 : : EXPORT_SYMBOL(sk_stream_wait_memory);
175 : :
176 : 0 : int sk_stream_error(struct sock *sk, int flags, int err)
177 : : {
178 [ + + ]: 7 : if (err == -EPIPE)
179 [ - + ]: 6 : err = sock_error(sk) ? : -EPIPE;
180 [ # # ][ + - ]: 7 : if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
181 : 6 : send_sig(SIGPIPE, current, 0);
182 : 0 : return err;
183 : : }
184 : : EXPORT_SYMBOL(sk_stream_error);
185 : :
186 : 0 : void sk_stream_kill_queues(struct sock *sk)
187 : : {
188 : : /* First the read buffer. */
189 : 109 : __skb_queue_purge(&sk->sk_receive_queue);
190 : :
191 : : /* Next, the error queue. */
192 : 109 : __skb_queue_purge(&sk->sk_error_queue);
193 : :
194 : : /* Next, the write queue. */
195 [ - + ]: 109 : WARN_ON(!skb_queue_empty(&sk->sk_write_queue));
196 : :
197 : : /* Account for returned memory. */
198 : : sk_mem_reclaim(sk);
199 : :
200 [ - + ]: 109 : WARN_ON(sk->sk_wmem_queued);
201 [ - + ]: 109 : WARN_ON(sk->sk_forward_alloc);
202 : :
203 : : /* It is _impossible_ for the backlog to contain anything
204 : : * when we get here. All user references to this socket
205 : : * have gone away, only the net layer knows can touch it.
206 : : */
207 : 109 : }
208 : : EXPORT_SYMBOL(sk_stream_kill_queues);
|
