[linux-2.6-block.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/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_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);

	/* retransmit timer is used for feature negotiation throughout
	 * connection.  In this case, no packet is re-transmitted, but rather an
	 * ack is generated and pending changes are splaced into its options.
	 */
	if (sk->sk_send_head == NULL) {
		dccp_pr_debug("feat negotiation retransmit timeout %p\n", sk);
		if (sk->sk_state == DCCP_OPEN)
			dccp_send_ack(sk);
		goto backoff;
	}

	/*
	 * 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;
	}

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