[linux.git] / net / x25 / x25_timer.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *	X.25 Packet Layer release 002
 *
 *	This is ALPHA test software. This code may break your machine,
 *	randomly fail to work with new releases, misbehave and/or generally
 *	screw up. It might even work.
 *
 *	This code REQUIRES 2.1.15 or higher
 *
 *	History
 *	X.25 001	Jonathan Naylor	Started coding.
 *	X.25 002	Jonathan Naylor	New timer architecture.
 *					Centralised disconnection processing.
 */

#include <linux/errno.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <net/sock.h>
#include <net/tcp_states.h>
#include <net/x25.h>

static void x25_heartbeat_expiry(struct timer_list *t);
static void x25_timer_expiry(struct timer_list *t);

void x25_init_timers(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	timer_setup(&x25->timer, x25_timer_expiry, 0);

	/* initialized by sock_init_data */
	sk->sk_timer.function = x25_heartbeat_expiry;
}

void x25_start_heartbeat(struct sock *sk)
{
	mod_timer(&sk->sk_timer, jiffies + 5 * HZ);
}

void x25_stop_heartbeat(struct sock *sk)
{
	del_timer(&sk->sk_timer);
}

void x25_start_t2timer(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	mod_timer(&x25->timer, jiffies + x25->t2);
}

void x25_start_t21timer(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	mod_timer(&x25->timer, jiffies + x25->t21);
}

void x25_start_t22timer(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	mod_timer(&x25->timer, jiffies + x25->t22);
}

void x25_start_t23timer(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	mod_timer(&x25->timer, jiffies + x25->t23);
}

void x25_stop_timer(struct sock *sk)
{
	del_timer(&x25_sk(sk)->timer);
}

unsigned long x25_display_timer(struct sock *sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	if (!timer_pending(&x25->timer))
		return 0;

	return x25->timer.expires - jiffies;
}

static void x25_heartbeat_expiry(struct timer_list *t)
{
	struct sock *sk = from_timer(sk, t, sk_timer);

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk)) /* can currently only occur in state 3 */
		goto restart_heartbeat;

	switch (x25_sk(sk)->state) {

		case X25_STATE_0:
			/*
			 * Magic here: If we listen() and a new link dies
			 * before it is accepted() it isn't 'dead' so doesn't
			 * get removed.
			 */
			if (sock_flag(sk, SOCK_DESTROY) ||
			    (sk->sk_state == TCP_LISTEN &&
			     sock_flag(sk, SOCK_DEAD))) {
				bh_unlock_sock(sk);
				x25_destroy_socket_from_timer(sk);
				return;
			}
			break;

		case X25_STATE_3:
			/*
			 * Check for the state of the receive buffer.
			 */
			x25_check_rbuf(sk);
			break;
	}
restart_heartbeat:
	x25_start_heartbeat(sk);
	bh_unlock_sock(sk);
}

/*
 *	Timer has expired, it may have been T2, T21, T22, or T23. We can tell
 *	by the state machine state.
 */
static inline void x25_do_timer_expiry(struct sock * sk)
{
	struct x25_sock *x25 = x25_sk(sk);

	switch (x25->state) {

		case X25_STATE_3:	/* T2 */
			if (x25->condition & X25_COND_ACK_PENDING) {
				x25->condition &= ~X25_COND_ACK_PENDING;
				x25_enquiry_response(sk);
			}
			break;

		case X25_STATE_1:	/* T21 */
		case X25_STATE_4:	/* T22 */
			x25_write_internal(sk, X25_CLEAR_REQUEST);
			x25->state = X25_STATE_2;
			x25_start_t23timer(sk);
			break;

		case X25_STATE_2:	/* T23 */
			x25_disconnect(sk, ETIMEDOUT, 0, 0);
			break;
	}
}

static void x25_timer_expiry(struct timer_list *t)
{
	struct x25_sock *x25 = from_timer(x25, t, timer);
	struct sock *sk = &x25->sk;

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk)) { /* can currently only occur in state 3 */
		if (x25_sk(sk)->state == X25_STATE_3)
			x25_start_t2timer(sk);
	} else
		x25_do_timer_expiry(sk);
	bh_unlock_sock(sk);
}
Commit	Line	Data
ee5d8f4d	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* X.25 Packet Layer release 002
	4	*
	5	* This is ALPHA test software. This code may break your machine,
	6	* randomly fail to work with new releases, misbehave and/or generally
f8e1d201	7	* screw up. It might even work.
1da177e4 LT	8	*
	9	* This code REQUIRES 2.1.15 or higher
	10	*
1da177e4 LT	11	* History
	12	* X.25 001 Jonathan Naylor Started coding.
	13	* X.25 002 Jonathan Naylor New timer architecture.
	14	* Centralised disconnection processing.
	15	*/
	16
	17	#include <linux/errno.h>
	18	#include <linux/jiffies.h>
	19	#include <linux/timer.h>
	20	#include <net/sock.h>
c752f073	21	#include <net/tcp_states.h>
1da177e4 LT	22	#include <net/x25.h>
1da177e4 LT	23
99767f27 KC	24	static void x25_heartbeat_expiry(struct timer_list *t);
99767f27 KC	25	static void x25_timer_expiry(struct timer_list *t);
1da177e4 LT	26
	27	void x25_init_timers(struct sock *sk)
	28	{
	29	struct x25_sock *x25 = x25_sk(sk);
	30
99767f27	31	timer_setup(&x25->timer, x25_timer_expiry, 0);
1da177e4 LT	32
1da177e4 LT	33	/* initialized by sock_init_data */
841b86f3	34	sk->sk_timer.function = x25_heartbeat_expiry;
1da177e4 LT	35	}
	36
	37	void x25_start_heartbeat(struct sock *sk)
	38	{
	39	mod_timer(&sk->sk_timer, jiffies + 5 * HZ);
	40	}
	41
	42	void x25_stop_heartbeat(struct sock *sk)
	43	{
	44	del_timer(&sk->sk_timer);
	45	}
	46
	47	void x25_start_t2timer(struct sock *sk)
	48	{
	49	struct x25_sock *x25 = x25_sk(sk);
	50
	51	mod_timer(&x25->timer, jiffies + x25->t2);
	52	}
	53
	54	void x25_start_t21timer(struct sock *sk)
	55	{
	56	struct x25_sock *x25 = x25_sk(sk);
	57
	58	mod_timer(&x25->timer, jiffies + x25->t21);
	59	}
	60
	61	void x25_start_t22timer(struct sock *sk)
	62	{
	63	struct x25_sock *x25 = x25_sk(sk);
	64
	65	mod_timer(&x25->timer, jiffies + x25->t22);
	66	}
	67
	68	void x25_start_t23timer(struct sock *sk)
	69	{
	70	struct x25_sock *x25 = x25_sk(sk);
	71
	72	mod_timer(&x25->timer, jiffies + x25->t23);
	73	}
	74
	75	void x25_stop_timer(struct sock *sk)
	76	{
	77	del_timer(&x25_sk(sk)->timer);
	78	}
	79
	80	unsigned long x25_display_timer(struct sock *sk)
	81	{
	82	struct x25_sock *x25 = x25_sk(sk);
	83
	84	if (!timer_pending(&x25->timer))
	85	return 0;
	86
	87	return x25->timer.expires - jiffies;
	88	}
	89
99767f27	90	static void x25_heartbeat_expiry(struct timer_list *t)
1da177e4	91	{
99767f27	92	struct sock *sk = from_timer(sk, t, sk_timer);
1da177e4	93
f8e1d201 YH	94	bh_lock_sock(sk);
f8e1d201 YH	95	if (sock_owned_by_user(sk)) /* can currently only occur in state 3 */
1da177e4 LT	96	goto restart_heartbeat;
	97
	98	switch (x25_sk(sk)->state) {
	99
	100	case X25_STATE_0:
	101	/*
	102	* Magic here: If we listen() and a new link dies
	103	* before it is accepted() it isn't 'dead' so doesn't
	104	* get removed.
	105	*/
	106	if (sock_flag(sk, SOCK_DESTROY) \|\|
	107	(sk->sk_state == TCP_LISTEN &&
	108	sock_flag(sk, SOCK_DEAD))) {
43dff98b	109	bh_unlock_sock(sk);
14ebaf81	110	x25_destroy_socket_from_timer(sk);
43dff98b	111	return;
1da177e4 LT	112	}
	113	break;
	114
	115	case X25_STATE_3:
	116	/*
	117	* Check for the state of the receive buffer.
	118	*/
	119	x25_check_rbuf(sk);
	120	break;
	121	}
	122	restart_heartbeat:
	123	x25_start_heartbeat(sk);
1da177e4 LT	124	bh_unlock_sock(sk);
	125	}
	126
	127	/*
	128	* Timer has expired, it may have been T2, T21, T22, or T23. We can tell
	129	* by the state machine state.
	130	*/
	131	static inline void x25_do_timer_expiry(struct sock * sk)
	132	{
	133	struct x25_sock *x25 = x25_sk(sk);
	134
	135	switch (x25->state) {
	136
	137	case X25_STATE_3: /* T2 */
	138	if (x25->condition & X25_COND_ACK_PENDING) {
	139	x25->condition &= ~X25_COND_ACK_PENDING;
	140	x25_enquiry_response(sk);
	141	}
	142	break;
	143
	144	case X25_STATE_1: /* T21 */
	145	case X25_STATE_4: /* T22 */
	146	x25_write_internal(sk, X25_CLEAR_REQUEST);
	147	x25->state = X25_STATE_2;
	148	x25_start_t23timer(sk);
	149	break;
	150
	151	case X25_STATE_2: /* T23 */
	152	x25_disconnect(sk, ETIMEDOUT, 0, 0);
	153	break;
	154	}
	155	}
	156
99767f27	157	static void x25_timer_expiry(struct timer_list *t)
1da177e4	158	{
99767f27 KC	159	struct x25_sock *x25 = from_timer(x25, t, timer);
99767f27 KC	160	struct sock *sk = &x25->sk;
1da177e4 LT	161
	162	bh_lock_sock(sk);
	163	if (sock_owned_by_user(sk)) { /* can currently only occur in state 3 */
	164	if (x25_sk(sk)->state == X25_STATE_3)
	165	x25_start_t2timer(sk);
	166	} else
	167	x25_do_timer_expiry(sk);
	168	bh_unlock_sock(sk);
	169	}