[deliverable/linux.git] / net / dccp / timer.c

/*
 *  net/dccp/timer.c
 * 
 *  An implementation of the DCCP protocol
 *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

#include <linux/config.h>
#include <linux/dccp.h>
#include <linux/skbuff.h>

#include "dccp.h"

static void dccp_write_timer(unsigned long data);
static void dccp_keepalive_timer(unsigned long data);
static void dccp_delack_timer(unsigned long data);

void dccp_init_xmit_timers(struct sock *sk)
{
	inet_csk_init_xmit_timers(sk, &dccp_write_timer, &dccp_delack_timer,
				  &dccp_keepalive_timer);
}

static void dccp_write_err(struct sock *sk)
{
	sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
	sk->sk_error_report(sk);

	dccp_v4_send_reset(sk, DCCP_RESET_CODE_ABORTED);
	dccp_done(sk);
	DCCP_INC_STATS_BH(DCCP_MIB_ABORTONTIMEOUT);
}

/* A write timeout has occurred. Process the after effects. */
static int dccp_write_timeout(struct sock *sk)
{
	const struct inet_connection_sock *icsk = inet_csk(sk);
	int retry_until;

	if (sk->sk_state == DCCP_REQUESTING || sk->sk_state == DCCP_PARTOPEN) {
		if (icsk->icsk_retransmits != 0)
			dst_negative_advice(&sk->sk_dst_cache);
		retry_until = icsk->icsk_syn_retries ? :
			    /* FIXME! */ 3 /* FIXME! sysctl_tcp_syn_retries */;
	} else {
		if (icsk->icsk_retransmits >=
		     /* FIXME! sysctl_tcp_retries1 */ 5 /* FIXME! */) {
			/* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu
			   black hole detection. :-(

			   It is place to make it. It is not made. I do not want
			   to make it. It is disguisting. It does not work in any
			   case. Let me to cite the same draft, which requires for
			   us to implement this:

   "The one security concern raised by this memo is that ICMP black holes
   are often caused by over-zealous security administrators who block
   all ICMP messages.  It is vitally important that those who design and
   deploy security systems understand the impact of strict filtering on
   upper-layer protocols.  The safest web site in the world is worthless
   if most TCP implementations cannot transfer data from it.  It would
   be far nicer to have all of the black holes fixed rather than fixing
   all of the TCP implementations."

                           Golden words :-).
		   */

			dst_negative_advice(&sk->sk_dst_cache);
		}

		retry_until = /* FIXME! */ 15 /* FIXME! sysctl_tcp_retries2 */;
		/*
		 * FIXME: see tcp_write_timout and tcp_out_of_resources
		 */
	}

	if (icsk->icsk_retransmits >= retry_until) {
		/* Has it gone just too far? */
		dccp_write_err(sk);
		return 1;
	}
	return 0;
}

/* This is the same as tcp_delack_timer, sans prequeue & mem_reclaim stuff */
static void dccp_delack_timer(unsigned long data)
{
	struct sock *sk = (struct sock *)data;
	struct inet_connection_sock *icsk = inet_csk(sk);

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk)) {
		/* Try again later. */
		icsk->icsk_ack.blocked = 1;
		NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
		sk_reset_timer(sk, &icsk->icsk_delack_timer,
			       jiffies + TCP_DELACK_MIN);
		goto out;
	}

	if (sk->sk_state == DCCP_CLOSED ||
	    !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
		goto out;
	if (time_after(icsk->icsk_ack.timeout, jiffies)) {
		sk_reset_timer(sk, &icsk->icsk_delack_timer,
			       icsk->icsk_ack.timeout);
		goto out;
	}

	icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;

	if (inet_csk_ack_scheduled(sk)) {
		if (!icsk->icsk_ack.pingpong) {
			/* Delayed ACK missed: inflate ATO. */
			icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1,
						 icsk->icsk_rto);
		} else {
			/* Delayed ACK missed: leave pingpong mode and
			 * deflate ATO.
			 */
			icsk->icsk_ack.pingpong = 0;
			icsk->icsk_ack.ato = TCP_ATO_MIN;
		}
		dccp_send_ack(sk);
		NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
	}
out:
	bh_unlock_sock(sk);
	sock_put(sk);
}

/*
 *	The DCCP retransmit timer.
 */
static void dccp_retransmit_timer(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);

	/*
	 * sk->sk_send_head has to have one skb with
	 * DCCP_SKB_CB(skb)->dccpd_type set to one of the retransmittable DCCP
	 * packet types (REQUEST, RESPONSE, the ACK in the 3way handshake
	 * (PARTOPEN timer), etc).
	 */
	BUG_TRAP(sk->sk_send_head != NULL);

	/* 
	 * More than than 4MSL (8 minutes) has passed, a RESET(aborted) was
	 * sent, no need to retransmit, this sock is dead.
	 */
	if (dccp_write_timeout(sk))
		goto out;

	/*
	 * We want to know the number of packets retransmitted, not the
	 * total number of retransmissions of clones of original packets.
	 */
	if (icsk->icsk_retransmits == 0)
		DCCP_INC_STATS_BH(DCCP_MIB_TIMEOUTS);

	if (dccp_retransmit_skb(sk, sk->sk_send_head) < 0) {
		/*
		 * Retransmission failed because of local congestion,
		 * do not backoff.
		 */
		if (icsk->icsk_retransmits == 0)
			icsk->icsk_retransmits = 1;
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
					  min(icsk->icsk_rto,
					      TCP_RESOURCE_PROBE_INTERVAL),
					  DCCP_RTO_MAX);
		goto out;
	}

	icsk->icsk_backoff++;
	icsk->icsk_retransmits++;

	icsk->icsk_rto = min(icsk->icsk_rto << 1, DCCP_RTO_MAX);
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto,
				  DCCP_RTO_MAX);
	if (icsk->icsk_retransmits > 3 /* FIXME: sysctl_dccp_retries1 */)
		__sk_dst_reset(sk);
out:;
}

static void dccp_write_timer(unsigned long data)
{
	struct sock *sk = (struct sock *)data;
	struct inet_connection_sock *icsk = inet_csk(sk);
	int event = 0;

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk)) {
		/* Try again later */
		sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
			       jiffies + (HZ / 20));
		goto out;
	}

	if (sk->sk_state == DCCP_CLOSED || !icsk->icsk_pending)
		goto out;

	if (time_after(icsk->icsk_timeout, jiffies)) {
		sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
			       icsk->icsk_timeout);
		goto out;
	}

	event = icsk->icsk_pending;
	icsk->icsk_pending = 0;

	switch (event) {
	case ICSK_TIME_RETRANS:
		dccp_retransmit_timer(sk);
		break;
	}
out:
	bh_unlock_sock(sk);
	sock_put(sk);
}

/*
 *	Timer for listening sockets
 */
static void dccp_response_timer(struct sock *sk)
{
	inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL, DCCP_TIMEOUT_INIT,
				   DCCP_RTO_MAX);
}

static void dccp_keepalive_timer(unsigned long data)
{
	struct sock *sk = (struct sock *)data;

	/* Only process if socket is not in use. */
	bh_lock_sock(sk);
	if (sock_owned_by_user(sk)) {
		/* Try again later. */ 
		inet_csk_reset_keepalive_timer(sk, HZ / 20);
		goto out;
	}

	if (sk->sk_state == DCCP_LISTEN) {
		dccp_response_timer(sk);
		goto out;
	}
out:
	bh_unlock_sock(sk);
	sock_put(sk);
}
Commit	Line	Data
7c657876 ACM	1	/*
	2	* net/dccp/timer.c
	3	*
	4	* An implementation of the DCCP protocol
	5	* Arnaldo Carvalho de Melo <acme@conectiva.com.br>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*/
	12
	13	#include <linux/config.h>
	14	#include <linux/dccp.h>
	15	#include <linux/skbuff.h>
	16
	17	#include "dccp.h"
	18
	19	static void dccp_write_timer(unsigned long data);
	20	static void dccp_keepalive_timer(unsigned long data);
	21	static void dccp_delack_timer(unsigned long data);
	22
	23	void dccp_init_xmit_timers(struct sock *sk)
	24	{
	25	inet_csk_init_xmit_timers(sk, &dccp_write_timer, &dccp_delack_timer,
	26	&dccp_keepalive_timer);
	27	}
	28
	29	static void dccp_write_err(struct sock *sk)
	30	{
	31	sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
	32	sk->sk_error_report(sk);
	33
	34	dccp_v4_send_reset(sk, DCCP_RESET_CODE_ABORTED);
	35	dccp_done(sk);
	36	DCCP_INC_STATS_BH(DCCP_MIB_ABORTONTIMEOUT);
	37	}
	38
	39	/* A write timeout has occurred. Process the after effects. */
	40	static int dccp_write_timeout(struct sock *sk)
	41	{
	42	const struct inet_connection_sock *icsk = inet_csk(sk);
	43	int retry_until;
	44
	45	if (sk->sk_state == DCCP_REQUESTING \|\| sk->sk_state == DCCP_PARTOPEN) {
	46	if (icsk->icsk_retransmits != 0)
	47	dst_negative_advice(&sk->sk_dst_cache);
7690af3f ACM	48	retry_until = icsk->icsk_syn_retries ? :
7690af3f ACM	49	/* FIXME! / 3 / FIXME! sysctl_tcp_syn_retries */;
7c657876	50	} else {
7690af3f ACM	51	if (icsk->icsk_retransmits >=
	52	/* FIXME! sysctl_tcp_retries1 / 5 / FIXME! */) {
	53	/* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu
	54	black hole detection. :-(
7c657876 ACM	55
	56	It is place to make it. It is not made. I do not want
	57	to make it. It is disguisting. It does not work in any
	58	case. Let me to cite the same draft, which requires for
	59	us to implement this:
	60
	61	"The one security concern raised by this memo is that ICMP black holes
	62	are often caused by over-zealous security administrators who block
	63	all ICMP messages. It is vitally important that those who design and
	64	deploy security systems understand the impact of strict filtering on
	65	upper-layer protocols. The safest web site in the world is worthless
	66	if most TCP implementations cannot transfer data from it. It would
	67	be far nicer to have all of the black holes fixed rather than fixing
	68	all of the TCP implementations."
	69
	70	Golden words :-).
	71	*/
	72
	73	dst_negative_advice(&sk->sk_dst_cache);
	74	}
	75
	76	retry_until = /* FIXME! / 15 / FIXME! sysctl_tcp_retries2 */;
	77	/*
	78	* FIXME: see tcp_write_timout and tcp_out_of_resources
	79	*/
	80	}
	81
	82	if (icsk->icsk_retransmits >= retry_until) {
	83	/* Has it gone just too far? */
	84	dccp_write_err(sk);
	85	return 1;
	86	}
	87	return 0;
	88	}
	89
	90	/* This is the same as tcp_delack_timer, sans prequeue & mem_reclaim stuff */
	91	static void dccp_delack_timer(unsigned long data)
	92	{
	93	struct sock sk = (struct sock )data;
	94	struct inet_connection_sock *icsk = inet_csk(sk);
	95
	96	bh_lock_sock(sk);
	97	if (sock_owned_by_user(sk)) {
	98	/* Try again later. */
	99	icsk->icsk_ack.blocked = 1;
	100	NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
7690af3f ACM	101	sk_reset_timer(sk, &icsk->icsk_delack_timer,
7690af3f ACM	102	jiffies + TCP_DELACK_MIN);
7c657876 ACM	103	goto out;
	104	}
	105
7690af3f ACM	106	if (sk->sk_state == DCCP_CLOSED \|\|
7690af3f ACM	107	!(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
7c657876 ACM	108	goto out;
7c657876 ACM	109	if (time_after(icsk->icsk_ack.timeout, jiffies)) {
7690af3f ACM	110	sk_reset_timer(sk, &icsk->icsk_delack_timer,
7690af3f ACM	111	icsk->icsk_ack.timeout);
7c657876 ACM	112	goto out;
	113	}
	114
	115	icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
	116
	117	if (inet_csk_ack_scheduled(sk)) {
	118	if (!icsk->icsk_ack.pingpong) {
	119	/* Delayed ACK missed: inflate ATO. */
7690af3f ACM	120	icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1,
7690af3f ACM	121	icsk->icsk_rto);
7c657876 ACM	122	} else {
	123	/* Delayed ACK missed: leave pingpong mode and
	124	* deflate ATO.
	125	*/
	126	icsk->icsk_ack.pingpong = 0;
	127	icsk->icsk_ack.ato = TCP_ATO_MIN;
	128	}
	129	dccp_send_ack(sk);
	130	NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
	131	}
	132	out:
	133	bh_unlock_sock(sk);
	134	sock_put(sk);
	135	}
	136
	137	/*
	138	* The DCCP retransmit timer.
	139	*/
	140	static void dccp_retransmit_timer(struct sock *sk)
	141	{
	142	struct inet_connection_sock *icsk = inet_csk(sk);
	143
	144	/*
	145	* sk->sk_send_head has to have one skb with
	146	* DCCP_SKB_CB(skb)->dccpd_type set to one of the retransmittable DCCP
03ace394	147	* packet types (REQUEST, RESPONSE, the ACK in the 3way handshake
7c657876 ACM	148	* (PARTOPEN timer), etc).
	149	*/
	150	BUG_TRAP(sk->sk_send_head != NULL);
	151
	152	/*
	153	* More than than 4MSL (8 minutes) has passed, a RESET(aborted) was
	154	* sent, no need to retransmit, this sock is dead.
	155	*/
	156	if (dccp_write_timeout(sk))
	157	goto out;
	158
	159	/*
	160	* We want to know the number of packets retransmitted, not the
	161	* total number of retransmissions of clones of original packets.
	162	*/
	163	if (icsk->icsk_retransmits == 0)
	164	DCCP_INC_STATS_BH(DCCP_MIB_TIMEOUTS);
	165
	166	if (dccp_retransmit_skb(sk, sk->sk_send_head) < 0) {
	167	/*
	168	* Retransmission failed because of local congestion,
	169	* do not backoff.
	170	*/
	171	if (icsk->icsk_retransmits == 0)
	172	icsk->icsk_retransmits = 1;
	173	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
	174	min(icsk->icsk_rto,
	175	TCP_RESOURCE_PROBE_INTERVAL),
7690af3f	176	DCCP_RTO_MAX);
7c657876 ACM	177	goto out;
	178	}
	179
	180	icsk->icsk_backoff++;
	181	icsk->icsk_retransmits++;
	182
	183	icsk->icsk_rto = min(icsk->icsk_rto << 1, DCCP_RTO_MAX);
7690af3f ACM	184	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto,
7690af3f ACM	185	DCCP_RTO_MAX);
7c657876 ACM	186	if (icsk->icsk_retransmits > 3 /* FIXME: sysctl_dccp_retries1 */)
	187	__sk_dst_reset(sk);
	188	out:;
	189	}
	190
	191	static void dccp_write_timer(unsigned long data)
	192	{
	193	struct sock sk = (struct sock )data;
	194	struct inet_connection_sock *icsk = inet_csk(sk);
	195	int event = 0;
	196
	197	bh_lock_sock(sk);
	198	if (sock_owned_by_user(sk)) {
	199	/* Try again later */
7690af3f ACM	200	sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
7690af3f ACM	201	jiffies + (HZ / 20));
7c657876 ACM	202	goto out;
	203	}
	204
	205	if (sk->sk_state == DCCP_CLOSED \|\| !icsk->icsk_pending)
	206	goto out;
	207
	208	if (time_after(icsk->icsk_timeout, jiffies)) {
7690af3f ACM	209	sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
7690af3f ACM	210	icsk->icsk_timeout);
7c657876 ACM	211	goto out;
	212	}
	213
	214	event = icsk->icsk_pending;
	215	icsk->icsk_pending = 0;
	216
	217	switch (event) {
	218	case ICSK_TIME_RETRANS:
	219	dccp_retransmit_timer(sk);
	220	break;
	221	}
	222	out:
	223	bh_unlock_sock(sk);
	224	sock_put(sk);
	225	}
	226
	227	/*
	228	* Timer for listening sockets
	229	*/
	230	static void dccp_response_timer(struct sock *sk)
	231	{
7690af3f ACM	232	inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL, DCCP_TIMEOUT_INIT,
7690af3f ACM	233	DCCP_RTO_MAX);
7c657876 ACM	234	}
	235
	236	static void dccp_keepalive_timer(unsigned long data)
	237	{
	238	struct sock sk = (struct sock )data;
	239
	240	/* Only process if socket is not in use. */
	241	bh_lock_sock(sk);
	242	if (sock_owned_by_user(sk)) {
	243	/* Try again later. */
	244	inet_csk_reset_keepalive_timer(sk, HZ / 20);
	245	goto out;
	246	}
	247
	248	if (sk->sk_state == DCCP_LISTEN) {
	249	dccp_response_timer(sk);
	250	goto out;
	251	}
	252	out:
	253	bh_unlock_sock(sk);
	254	sock_put(sk);
	255	}