[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / core / stream.c

/*
 *     SUCS NET3:
 *
 *     Generic stream handling routines. These are generic for most
 *     protocols. Even IP. Tonight 8-).
 *     This is used because TCP, LLC (others too) layer all have mostly
 *     identical sendmsg() and recvmsg() code.
 *     So we (will) share it here.
 *
 *     Authors:        Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *                     (from old tcp.c code)
 *                     Alan Cox <alan@lxorguk.ukuu.org.uk> (Borrowed comments 8-))
 */

#include <linux/module.h>
#include <linux/net.h>
#include <linux/signal.h>
#include <linux/tcp.h>
#include <linux/wait.h>
#include <net/sock.h>

/**
 * sk_stream_write_space - stream socket write_space callback.
 * @sk: socket
 *
 * FIXME: write proper description
 */
void sk_stream_write_space(struct sock *sk)
{
	struct socket *sock = sk->sk_socket;
	struct socket_wq *wq;

	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
		clear_bit(SOCK_NOSPACE, &sock->flags);

		rcu_read_lock();
		wq = rcu_dereference(sk->sk_wq);
		if (wq_has_sleeper(wq))
			wake_up_interruptible_poll(&wq->wait, POLLOUT |
						POLLWRNORM | POLLWRBAND);
		if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
			sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
		rcu_read_unlock();
	}
}
EXPORT_SYMBOL(sk_stream_write_space);

/**
 * sk_stream_wait_connect - Wait for a socket to get into the connected state
 * @sk: sock to wait on
 * @timeo_p: for how long to wait
 *
 * Must be called with the socket locked.
 */
int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
{
	struct task_struct *tsk = current;
	DEFINE_WAIT(wait);
	int done;

	do {
		int err = sock_error(sk);
		if (err)
			return err;
		if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))
			return -EPIPE;
		if (!*timeo_p)
			return -EAGAIN;
		if (signal_pending(tsk))
			return sock_intr_errno(*timeo_p);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		sk->sk_write_pending++;
		done = sk_wait_event(sk, timeo_p,
				     !sk->sk_err &&
				     !((1 << sk->sk_state) &
				       ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));
		finish_wait(sk_sleep(sk), &wait);
		sk->sk_write_pending--;
	} while (!done);
	return 0;
}
EXPORT_SYMBOL(sk_stream_wait_connect);

/**
 * sk_stream_closing - Return 1 if we still have things to send in our buffers.
 * @sk: socket to verify
 */
static inline int sk_stream_closing(struct sock *sk)
{
	return (1 << sk->sk_state) &
	       (TCPF_FIN_WAIT1 | TCPF_CLOSING | TCPF_LAST_ACK);
}

void sk_stream_wait_close(struct sock *sk, long timeout)
{
	if (timeout) {
		DEFINE_WAIT(wait);

		do {
			prepare_to_wait(sk_sleep(sk), &wait,
					TASK_INTERRUPTIBLE);
			if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))
				break;
		} while (!signal_pending(current) && timeout);

		finish_wait(sk_sleep(sk), &wait);
	}
}
EXPORT_SYMBOL(sk_stream_wait_close);

/**
 * sk_stream_wait_memory - Wait for more memory for a socket
 * @sk: socket to wait for memory
 * @timeo_p: for how long
 */
int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
{
	int err = 0;
	long vm_wait = 0;
	long current_timeo = *timeo_p;
	DEFINE_WAIT(wait);

	if (sk_stream_memory_free(sk))
		current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;

	while (1) {
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
			goto do_error;
		if (!*timeo_p)
			goto do_nonblock;
		if (signal_pending(current))
			goto do_interrupted;
		clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
		if (sk_stream_memory_free(sk) && !vm_wait)
			break;

		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
		sk->sk_write_pending++;
		sk_wait_event(sk, &current_timeo, sk->sk_err ||
						  (sk->sk_shutdown & SEND_SHUTDOWN) ||
						  (sk_stream_memory_free(sk) &&
						  !vm_wait));
		sk->sk_write_pending--;

		if (vm_wait) {
			vm_wait -= current_timeo;
			current_timeo = *timeo_p;
			if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
			    (current_timeo -= vm_wait) < 0)
				current_timeo = 0;
			vm_wait = 0;
		}
		*timeo_p = current_timeo;
	}
out:
	finish_wait(sk_sleep(sk), &wait);
	return err;

do_error:
	err = -EPIPE;
	goto out;
do_nonblock:
	err = -EAGAIN;
	goto out;
do_interrupted:
	err = sock_intr_errno(*timeo_p);
	goto out;
}
EXPORT_SYMBOL(sk_stream_wait_memory);

int sk_stream_error(struct sock *sk, int flags, int err)
{
	if (err == -EPIPE)
		err = sock_error(sk) ? : -EPIPE;
	if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
		send_sig(SIGPIPE, current, 0);
	return err;
}
EXPORT_SYMBOL(sk_stream_error);

void sk_stream_kill_queues(struct sock *sk)
{
	/* First the read buffer. */
	__skb_queue_purge(&sk->sk_receive_queue);

	/* Next, the error queue. */
	__skb_queue_purge(&sk->sk_error_queue);

	/* Next, the write queue. */
	WARN_ON(!skb_queue_empty(&sk->sk_write_queue));

	/* Account for returned memory. */
	sk_mem_reclaim(sk);

	WARN_ON(sk->sk_wmem_queued);
	WARN_ON(sk->sk_forward_alloc);

	/* It is _impossible_ for the backlog to contain anything
	 * when we get here.  All user references to this socket
	 * have gone away, only the net layer knows can touch it.
	 */
}
EXPORT_SYMBOL(sk_stream_kill_queues);
Commit	Line	Data
1da177e4 LT	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)
113aa838	12	* Alan Cox <alan@lxorguk.ukuu.org.uk> (Borrowed comments 8-))
1da177e4 LT	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.
4dc3b16b	24	* @sk: socket
1da177e4 LT	25	*
	26	* FIXME: write proper description
	27	*/
	28	void sk_stream_write_space(struct sock *sk)
	29	{
	30	struct socket *sock = sk->sk_socket;
43815482	31	struct socket_wq *wq;
1da177e4 LT	32
	33	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
	34	clear_bit(SOCK_NOSPACE, &sock->flags);
	35
43815482 ED	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 \|
9dc20c5f	40	POLLWRNORM \| POLLWRBAND);
43815482	41	if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
8d8ad9d7	42	sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
43815482	43	rcu_read_unlock();
1da177e4 LT	44	}
1da177e4 LT	45	}
1da177e4 LT	46	EXPORT_SYMBOL(sk_stream_write_space);
	47
	48	/**
	49	* sk_stream_wait_connect - Wait for a socket to get into the connected state
4dc3b16b PP	50	* @sk: sock to wait on
4dc3b16b PP	51	* @timeo_p: for how long to wait
1da177e4 LT	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);
6151b31c	59	int done;
1da177e4	60
6151b31c	61	do {
c1cbe4b7 BL	62	int err = sock_error(sk);
	63	if (err)
	64	return err;
1da177e4 LT	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
aa395145	72	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4	73	sk->sk_write_pending++;
6151b31c	74	done = sk_wait_event(sk, timeo_p,
c1cbe4b7	75	!sk->sk_err &&
4ec93edb	76	!((1 << sk->sk_state) &
6151b31c	77	~(TCPF_ESTABLISHED \| TCPF_CLOSE_WAIT)));
aa395145	78	finish_wait(sk_sleep(sk), &wait);
1da177e4	79	sk->sk_write_pending--;
6151b31c	80	} while (!done);
1da177e4 LT	81	return 0;
1da177e4 LT	82	}
1da177e4 LT	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.
4dc3b16b	87	* @sk: socket to verify
1da177e4 LT	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 {
aa395145	101	prepare_to_wait(sk_sleep(sk), &wait,
1da177e4 LT	102	TASK_INTERRUPTIBLE);
	103	if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))
	104	break;
	105	} while (!signal_pending(current) && timeout);
	106
aa395145	107	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	108	}
1da177e4 LT	109	}
1da177e4 LT	110	EXPORT_SYMBOL(sk_stream_wait_close);
	111
	112	/**
	113	* sk_stream_wait_memory - Wait for more memory for a socket
4dc3b16b PP	114	* @sk: socket to wait for memory
4dc3b16b PP	115	* @timeo_p: for how long
1da177e4 LT	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	DEFINE_WAIT(wait);
	123
	124	if (sk_stream_memory_free(sk))
	125	current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;
	126
	127	while (1) {
	128	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	129
aa395145	130	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4 LT	131
	132	if (sk->sk_err \|\| (sk->sk_shutdown & SEND_SHUTDOWN))
	133	goto do_error;
	134	if (!*timeo_p)
	135	goto do_nonblock;
	136	if (signal_pending(current))
	137	goto do_interrupted;
	138	clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	139	if (sk_stream_memory_free(sk) && !vm_wait)
	140	break;
	141
	142	set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
	143	sk->sk_write_pending++;
482964e5 NT	144	sk_wait_event(sk, &current_timeo, sk->sk_err \|\|
	145	(sk->sk_shutdown & SEND_SHUTDOWN) \|\|
	146	(sk_stream_memory_free(sk) &&
	147	!vm_wait));
1da177e4 LT	148	sk->sk_write_pending--;
	149
	150	if (vm_wait) {
	151	vm_wait -= current_timeo;
	152	current_timeo = *timeo_p;
	153	if (current_timeo != MAX_SCHEDULE_TIMEOUT &&
	154	(current_timeo -= vm_wait) < 0)
	155	current_timeo = 0;
	156	vm_wait = 0;
	157	}
	158	*timeo_p = current_timeo;
	159	}
	160	out:
aa395145	161	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	162	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	}
1da177e4 LT	174	EXPORT_SYMBOL(sk_stream_wait_memory);
1da177e4 LT	175
1da177e4 LT	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	}
1da177e4 LT	184	EXPORT_SYMBOL(sk_stream_error);
1da177e4 LT	185
1da177e4 LT	186	void sk_stream_kill_queues(struct sock *sk)
	187	{
	188	/* First the read buffer. */
	189	__skb_queue_purge(&sk->sk_receive_queue);
	190
	191	/* Next, the error queue. */
	192	__skb_queue_purge(&sk->sk_error_queue);
	193
	194	/* Next, the write queue. */
547b792c	195	WARN_ON(!skb_queue_empty(&sk->sk_write_queue));
1da177e4 LT	196
1da177e4 LT	197	/* Account for returned memory. */
3ab224be	198	sk_mem_reclaim(sk);
1da177e4	199
547b792c IJ	200	WARN_ON(sk->sk_wmem_queued);
547b792c IJ	201	WARN_ON(sk->sk_forward_alloc);
1da177e4 LT	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	}
1da177e4	208	EXPORT_SYMBOL(sk_stream_kill_queues);