[linux-block.git] / net / ipv4 / tcp_lp.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * TCP Low Priority (TCP-LP)
 *
 * TCP Low Priority is a distributed algorithm whose goal is to utilize only
 *   the excess network bandwidth as compared to the ``fair share`` of
 *   bandwidth as targeted by TCP.
 *
 * As of 2.6.13, Linux supports pluggable congestion control algorithms.
 * Due to the limitation of the API, we take the following changes from
 * the original TCP-LP implementation:
 *   o We use newReno in most core CA handling. Only add some checking
 *     within cong_avoid.
 *   o Error correcting in remote HZ, therefore remote HZ will be keeped
 *     on checking and updating.
 *   o Handling calculation of One-Way-Delay (OWD) within rtt_sample, since
 *     OWD have a similar meaning as RTT. Also correct the buggy formular.
 *   o Handle reaction for Early Congestion Indication (ECI) within
 *     pkts_acked, as mentioned within pseudo code.
 *   o OWD is handled in relative format, where local time stamp will in
 *     tcp_time_stamp format.
 *
 * Original Author:
 *   Aleksandar Kuzmanovic <akuzma@northwestern.edu>
 * Available from:
 *   http://www.ece.rice.edu/~akuzma/Doc/akuzma/TCP-LP.pdf
 * Original implementation for 2.4.19:
 *   http://www-ece.rice.edu/networks/TCP-LP/
 *
 * 2.6.x module Authors:
 *   Wong Hoi Sing, Edison <hswong3i@gmail.com>
 *   Hung Hing Lun, Mike <hlhung3i@gmail.com>
 * SourceForge project page:
 *   http://tcp-lp-mod.sourceforge.net/
 */

#include <linux/module.h>
#include <net/tcp.h>

/* resolution of owd */
#define LP_RESOL       TCP_TS_HZ

/**
 * enum tcp_lp_state
 * @LP_VALID_RHZ: is remote HZ valid?
 * @LP_VALID_OWD: is OWD valid?
 * @LP_WITHIN_THR: are we within threshold?
 * @LP_WITHIN_INF: are we within inference?
 *
 * TCP-LP's state flags.
 * We create this set of state flag mainly for debugging.
 */
enum tcp_lp_state {
	LP_VALID_RHZ = (1 << 0),
	LP_VALID_OWD = (1 << 1),
	LP_WITHIN_THR = (1 << 3),
	LP_WITHIN_INF = (1 << 4),
};

/**
 * struct lp
 * @flag: TCP-LP state flag
 * @sowd: smoothed OWD << 3
 * @owd_min: min OWD
 * @owd_max: max OWD
 * @owd_max_rsv: reserved max owd
 * @remote_hz: estimated remote HZ
 * @remote_ref_time: remote reference time
 * @local_ref_time: local reference time
 * @last_drop: time for last active drop
 * @inference: current inference
 *
 * TCP-LP's private struct.
 * We get the idea from original TCP-LP implementation where only left those we
 * found are really useful.
 */
struct lp {
	u32 flag;
	u32 sowd;
	u32 owd_min;
	u32 owd_max;
	u32 owd_max_rsv;
	u32 remote_hz;
	u32 remote_ref_time;
	u32 local_ref_time;
	u32 last_drop;
	u32 inference;
};

/**
 * tcp_lp_init
 * @sk: socket to initialize congestion control algorithm for
 *
 * Init all required variables.
 * Clone the handling from Vegas module implementation.
 */
static void tcp_lp_init(struct sock *sk)
{
	struct lp *lp = inet_csk_ca(sk);

	lp->flag = 0;
	lp->sowd = 0;
	lp->owd_min = 0xffffffff;
	lp->owd_max = 0;
	lp->owd_max_rsv = 0;
	lp->remote_hz = 0;
	lp->remote_ref_time = 0;
	lp->local_ref_time = 0;
	lp->last_drop = 0;
	lp->inference = 0;
}

/**
 * tcp_lp_cong_avoid
 * @sk: socket to avoid congesting
 *
 * Implementation of cong_avoid.
 * Will only call newReno CA when away from inference.
 * From TCP-LP's paper, this will be handled in additive increasement.
 */
static void tcp_lp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{
	struct lp *lp = inet_csk_ca(sk);

	if (!(lp->flag & LP_WITHIN_INF))
		tcp_reno_cong_avoid(sk, ack, acked);
}

/**
 * tcp_lp_remote_hz_estimator
 * @sk: socket which needs an estimate for the remote HZs
 *
 * Estimate remote HZ.
 * We keep on updating the estimated value, where original TCP-LP
 * implementation only guest it for once and use forever.
 */
static u32 tcp_lp_remote_hz_estimator(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct lp *lp = inet_csk_ca(sk);
	s64 rhz = lp->remote_hz << 6;	/* remote HZ << 6 */
	s64 m = 0;

	/* not yet record reference time
	 * go away!! record it before come back!! */
	if (lp->remote_ref_time == 0 || lp->local_ref_time == 0)
		goto out;

	/* we can't calc remote HZ with no different!! */
	if (tp->rx_opt.rcv_tsval == lp->remote_ref_time ||
	    tp->rx_opt.rcv_tsecr == lp->local_ref_time)
		goto out;

	m = TCP_TS_HZ *
	    (tp->rx_opt.rcv_tsval - lp->remote_ref_time) /
	    (tp->rx_opt.rcv_tsecr - lp->local_ref_time);
	if (m < 0)
		m = -m;

	if (rhz > 0) {
		m -= rhz >> 6;	/* m is now error in remote HZ est */
		rhz += m;	/* 63/64 old + 1/64 new */
	} else
		rhz = m << 6;

 out:
	/* record time for successful remote HZ calc */
	if ((rhz >> 6) > 0)
		lp->flag |= LP_VALID_RHZ;
	else
		lp->flag &= ~LP_VALID_RHZ;

	/* record reference time stamp */
	lp->remote_ref_time = tp->rx_opt.rcv_tsval;
	lp->local_ref_time = tp->rx_opt.rcv_tsecr;

	return rhz >> 6;
}

/**
 * tcp_lp_owd_calculator
 * @sk: socket to calculate one way delay for
 *
 * Calculate one way delay (in relative format).
 * Original implement OWD as minus of remote time difference to local time
 * difference directly. As this time difference just simply equal to RTT, when
 * the network status is stable, remote RTT will equal to local RTT, and result
 * OWD into zero.
 * It seems to be a bug and so we fixed it.
 */
static u32 tcp_lp_owd_calculator(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct lp *lp = inet_csk_ca(sk);
	s64 owd = 0;

	lp->remote_hz = tcp_lp_remote_hz_estimator(sk);

	if (lp->flag & LP_VALID_RHZ) {
		owd =
		    tp->rx_opt.rcv_tsval * (LP_RESOL / lp->remote_hz) -
		    tp->rx_opt.rcv_tsecr * (LP_RESOL / TCP_TS_HZ);
		if (owd < 0)
			owd = -owd;
	}

	if (owd > 0)
		lp->flag |= LP_VALID_OWD;
	else
		lp->flag &= ~LP_VALID_OWD;

	return owd;
}

/**
 * tcp_lp_rtt_sample
 * @sk: socket to add a rtt sample to
 * @rtt: round trip time, which is ignored!
 *
 * Implementation or rtt_sample.
 * Will take the following action,
 *   1. calc OWD,
 *   2. record the min/max OWD,
 *   3. calc smoothed OWD (SOWD).
 * Most ideas come from the original TCP-LP implementation.
 */
static void tcp_lp_rtt_sample(struct sock *sk, u32 rtt)
{
	struct lp *lp = inet_csk_ca(sk);
	s64 mowd = tcp_lp_owd_calculator(sk);

	/* sorry that we don't have valid data */
	if (!(lp->flag & LP_VALID_RHZ) || !(lp->flag & LP_VALID_OWD))
		return;

	/* record the next min owd */
	if (mowd < lp->owd_min)
		lp->owd_min = mowd;

	/* always forget the max of the max
	 * we just set owd_max as one below it */
	if (mowd > lp->owd_max) {
		if (mowd > lp->owd_max_rsv) {
			if (lp->owd_max_rsv == 0)
				lp->owd_max = mowd;
			else
				lp->owd_max = lp->owd_max_rsv;
			lp->owd_max_rsv = mowd;
		} else
			lp->owd_max = mowd;
	}

	/* calc for smoothed owd */
	if (lp->sowd != 0) {
		mowd -= lp->sowd >> 3;	/* m is now error in owd est */
		lp->sowd += mowd;	/* owd = 7/8 owd + 1/8 new */
	} else
		lp->sowd = mowd << 3;	/* take the measured time be owd */
}

/**
 * tcp_lp_pkts_acked
 * @sk: socket requiring congestion avoidance calculations
 *
 * Implementation of pkts_acked.
 * Deal with active drop under Early Congestion Indication.
 * Only drop to half and 1 will be handle, because we hope to use back
 * newReno in increase case.
 * We work it out by following the idea from TCP-LP's paper directly
 */
static void tcp_lp_pkts_acked(struct sock *sk, const struct ack_sample *sample)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct lp *lp = inet_csk_ca(sk);
	u32 now = tcp_time_stamp(tp);
	u32 delta;

	if (sample->rtt_us > 0)
		tcp_lp_rtt_sample(sk, sample->rtt_us);

	/* calc inference */
	delta = now - tp->rx_opt.rcv_tsecr;
	if ((s32)delta > 0)
		lp->inference = 3 * delta;

	/* test if within inference */
	if (lp->last_drop && (now - lp->last_drop < lp->inference))
		lp->flag |= LP_WITHIN_INF;
	else
		lp->flag &= ~LP_WITHIN_INF;

	/* test if within threshold */
	if (lp->sowd >> 3 <
	    lp->owd_min + 15 * (lp->owd_max - lp->owd_min) / 100)
		lp->flag |= LP_WITHIN_THR;
	else
		lp->flag &= ~LP_WITHIN_THR;

	pr_debug("TCP-LP: %05o|%5u|%5u|%15u|%15u|%15u\n", lp->flag,
		 tcp_snd_cwnd(tp), lp->remote_hz, lp->owd_min, lp->owd_max,
		 lp->sowd >> 3);

	if (lp->flag & LP_WITHIN_THR)
		return;

	/* FIXME: try to reset owd_min and owd_max here
	 * so decrease the chance the min/max is no longer suitable
	 * and will usually within threshold when within inference */
	lp->owd_min = lp->sowd >> 3;
	lp->owd_max = lp->sowd >> 2;
	lp->owd_max_rsv = lp->sowd >> 2;

	/* happened within inference
	 * drop snd_cwnd into 1 */
	if (lp->flag & LP_WITHIN_INF)
		tcp_snd_cwnd_set(tp, 1U);

	/* happened after inference
	 * cut snd_cwnd into half */
	else
		tcp_snd_cwnd_set(tp, max(tcp_snd_cwnd(tp) >> 1U, 1U));

	/* record this drop time */
	lp->last_drop = now;
}

static struct tcp_congestion_ops tcp_lp __read_mostly = {
	.init = tcp_lp_init,
	.ssthresh = tcp_reno_ssthresh,
	.undo_cwnd = tcp_reno_undo_cwnd,
	.cong_avoid = tcp_lp_cong_avoid,
	.pkts_acked = tcp_lp_pkts_acked,

	.owner = THIS_MODULE,
	.name = "lp"
};

static int __init tcp_lp_register(void)
{
	BUILD_BUG_ON(sizeof(struct lp) > ICSK_CA_PRIV_SIZE);
	return tcp_register_congestion_control(&tcp_lp);
}

static void __exit tcp_lp_unregister(void)
{
	tcp_unregister_congestion_control(&tcp_lp);
}

module_init(tcp_lp_register);
module_exit(tcp_lp_unregister);

MODULE_AUTHOR("Wong Hoi Sing Edison, Hung Hing Lun Mike");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("TCP Low Priority");
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
7c106d7e WHSE	2	/*
	3	* TCP Low Priority (TCP-LP)
	4	*
	5	* TCP Low Priority is a distributed algorithm whose goal is to utilize only
	6	* the excess network bandwidth as compared to the ``fair share`` of
3795da47	7	* bandwidth as targeted by TCP.
7c106d7e	8	*
7c106d7e WHSE	9	* As of 2.6.13, Linux supports pluggable congestion control algorithms.
	10	* Due to the limitation of the API, we take the following changes from
	11	* the original TCP-LP implementation:
	12	* o We use newReno in most core CA handling. Only add some checking
	13	* within cong_avoid.
	14	* o Error correcting in remote HZ, therefore remote HZ will be keeped
	15	* on checking and updating.
25985edc	16	* o Handling calculation of One-Way-Delay (OWD) within rtt_sample, since
7c106d7e WHSE	17	* OWD have a similar meaning as RTT. Also correct the buggy formular.
	18	* o Handle reaction for Early Congestion Indication (ECI) within
	19	* pkts_acked, as mentioned within pseudo code.
	20	* o OWD is handled in relative format, where local time stamp will in
	21	* tcp_time_stamp format.
	22	*
3795da47 WHSE	23	* Original Author:
	24	* Aleksandar Kuzmanovic <akuzma@northwestern.edu>
	25	* Available from:
	26	* http://www.ece.rice.edu/~akuzma/Doc/akuzma/TCP-LP.pdf
	27	* Original implementation for 2.4.19:
	28	* http://www-ece.rice.edu/networks/TCP-LP/
7c106d7e	29	*
3795da47 WHSE	30	* 2.6.x module Authors:
	31	* Wong Hoi Sing, Edison <hswong3i@gmail.com>
	32	* Hung Hing Lun, Mike <hlhung3i@gmail.com>
	33	* SourceForge project page:
	34	* http://tcp-lp-mod.sourceforge.net/
7c106d7e WHSE	35	*/
7c106d7e WHSE	36
7c106d7e WHSE	37	#include <linux/module.h>
	38	#include <net/tcp.h>
	39
	40	/* resolution of owd */
9a568de4	41	#define LP_RESOL TCP_TS_HZ
7c106d7e WHSE	42
	43	/**
	44	* enum tcp_lp_state
	45	* @LP_VALID_RHZ: is remote HZ valid?
	46	* @LP_VALID_OWD: is OWD valid?
	47	* @LP_WITHIN_THR: are we within threshold?
	48	* @LP_WITHIN_INF: are we within inference?
	49	*
	50	* TCP-LP's state flags.
	51	* We create this set of state flag mainly for debugging.
	52	*/
	53	enum tcp_lp_state {
	54	LP_VALID_RHZ = (1 << 0),
	55	LP_VALID_OWD = (1 << 1),
	56	LP_WITHIN_THR = (1 << 3),
	57	LP_WITHIN_INF = (1 << 4),
	58	};
	59
	60	/**
	61	* struct lp
	62	* @flag: TCP-LP state flag
	63	* @sowd: smoothed OWD << 3
	64	* @owd_min: min OWD
	65	* @owd_max: max OWD
e5ca43e8	66	* @owd_max_rsv: reserved max owd
7c106d7e WHSE	67	* @remote_hz: estimated remote HZ
	68	* @remote_ref_time: remote reference time
	69	* @local_ref_time: local reference time
	70	* @last_drop: time for last active drop
	71	* @inference: current inference
	72	*
	73	* TCP-LP's private struct.
	74	* We get the idea from original TCP-LP implementation where only left those we
	75	* found are really useful.
	76	*/
	77	struct lp {
	78	u32 flag;
	79	u32 sowd;
	80	u32 owd_min;
	81	u32 owd_max;
	82	u32 owd_max_rsv;
	83	u32 remote_hz;
	84	u32 remote_ref_time;
	85	u32 local_ref_time;
	86	u32 last_drop;
	87	u32 inference;
	88	};
	89
	90	/**
	91	* tcp_lp_init
726e5e49	92	* @sk: socket to initialize congestion control algorithm for
7c106d7e WHSE	93	*
	94	* Init all required variables.
	95	* Clone the handling from Vegas module implementation.
	96	*/
	97	static void tcp_lp_init(struct sock *sk)
	98	{
	99	struct lp *lp = inet_csk_ca(sk);
	100
	101	lp->flag = 0;
	102	lp->sowd = 0;
	103	lp->owd_min = 0xffffffff;
	104	lp->owd_max = 0;
	105	lp->owd_max_rsv = 0;
	106	lp->remote_hz = 0;
	107	lp->remote_ref_time = 0;
	108	lp->local_ref_time = 0;
	109	lp->last_drop = 0;
	110	lp->inference = 0;
	111	}
	112
	113	/**
	114	* tcp_lp_cong_avoid
726e5e49	115	* @sk: socket to avoid congesting
7c106d7e WHSE	116	*
	117	* Implementation of cong_avoid.
	118	* Will only call newReno CA when away from inference.
	119	* From TCP-LP's paper, this will be handled in additive increasement.
	120	*/
24901551	121	static void tcp_lp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
7c106d7e WHSE	122	{
	123	struct lp *lp = inet_csk_ca(sk);
	124
	125	if (!(lp->flag & LP_WITHIN_INF))
24901551	126	tcp_reno_cong_avoid(sk, ack, acked);
7c106d7e WHSE	127	}
	128
	129	/**
	130	* tcp_lp_remote_hz_estimator
726e5e49	131	* @sk: socket which needs an estimate for the remote HZs
7c106d7e WHSE	132	*
	133	* Estimate remote HZ.
	134	* We keep on updating the estimated value, where original TCP-LP
	135	* implementation only guest it for once and use forever.
	136	*/
	137	static u32 tcp_lp_remote_hz_estimator(struct sock *sk)
	138	{
	139	struct tcp_sock *tp = tcp_sk(sk);
	140	struct lp *lp = inet_csk_ca(sk);
	141	s64 rhz = lp->remote_hz << 6; /* remote HZ << 6 */
	142	s64 m = 0;
	143
	144	/* not yet record reference time
	145	* go away!! record it before come back!! */
	146	if (lp->remote_ref_time == 0 \|\| lp->local_ref_time == 0)
	147	goto out;
	148
	149	/* we can't calc remote HZ with no different!! */
9d4fb27d JP	150	if (tp->rx_opt.rcv_tsval == lp->remote_ref_time \|\|
9d4fb27d JP	151	tp->rx_opt.rcv_tsecr == lp->local_ref_time)
7c106d7e WHSE	152	goto out;
7c106d7e WHSE	153
9a568de4 ED	154	m = TCP_TS_HZ *
	155	(tp->rx_opt.rcv_tsval - lp->remote_ref_time) /
	156	(tp->rx_opt.rcv_tsecr - lp->local_ref_time);
7c106d7e WHSE	157	if (m < 0)
	158	m = -m;
	159
3795da47	160	if (rhz > 0) {
7c106d7e WHSE	161	m -= rhz >> 6; /* m is now error in remote HZ est */
	162	rhz += m; /* 63/64 old + 1/64 new */
	163	} else
	164	rhz = m << 6;
	165
3795da47	166	out:
7c106d7e	167	/* record time for successful remote HZ calc */
bfbea8a8	168	if ((rhz >> 6) > 0)
3795da47 WHSE	169	lp->flag \|= LP_VALID_RHZ;
	170	else
	171	lp->flag &= ~LP_VALID_RHZ;
7c106d7e	172
7c106d7e WHSE	173	/* record reference time stamp */
	174	lp->remote_ref_time = tp->rx_opt.rcv_tsval;
	175	lp->local_ref_time = tp->rx_opt.rcv_tsecr;
	176
	177	return rhz >> 6;
	178	}
	179
	180	/**
	181	* tcp_lp_owd_calculator
726e5e49	182	* @sk: socket to calculate one way delay for
7c106d7e WHSE	183	*
	184	* Calculate one way delay (in relative format).
	185	* Original implement OWD as minus of remote time difference to local time
	186	* difference directly. As this time difference just simply equal to RTT, when
	187	* the network status is stable, remote RTT will equal to local RTT, and result
	188	* OWD into zero.
	189	* It seems to be a bug and so we fixed it.
	190	*/
	191	static u32 tcp_lp_owd_calculator(struct sock *sk)
	192	{
	193	struct tcp_sock *tp = tcp_sk(sk);
	194	struct lp *lp = inet_csk_ca(sk);
	195	s64 owd = 0;
	196
	197	lp->remote_hz = tcp_lp_remote_hz_estimator(sk);
	198
	199	if (lp->flag & LP_VALID_RHZ) {
	200	owd =
	201	tp->rx_opt.rcv_tsval * (LP_RESOL / lp->remote_hz) -
9a568de4	202	tp->rx_opt.rcv_tsecr * (LP_RESOL / TCP_TS_HZ);
7c106d7e WHSE	203	if (owd < 0)
	204	owd = -owd;
	205	}
	206
	207	if (owd > 0)
	208	lp->flag \|= LP_VALID_OWD;
	209	else
	210	lp->flag &= ~LP_VALID_OWD;
	211
	212	return owd;
	213	}
	214
	215	/**
	216	* tcp_lp_rtt_sample
726e5e49 AL	217	* @sk: socket to add a rtt sample to
726e5e49 AL	218	* @rtt: round trip time, which is ignored!
7c106d7e WHSE	219	*
	220	* Implementation or rtt_sample.
	221	* Will take the following action,
	222	* 1. calc OWD,
	223	* 2. record the min/max OWD,
	224	* 3. calc smoothed OWD (SOWD).
	225	* Most ideas come from the original TCP-LP implementation.
	226	*/
164891aa	227	static void tcp_lp_rtt_sample(struct sock *sk, u32 rtt)
7c106d7e WHSE	228	{
	229	struct lp *lp = inet_csk_ca(sk);
	230	s64 mowd = tcp_lp_owd_calculator(sk);
	231
	232	/* sorry that we don't have valid data */
	233	if (!(lp->flag & LP_VALID_RHZ) \|\| !(lp->flag & LP_VALID_OWD))
	234	return;
	235
	236	/* record the next min owd */
	237	if (mowd < lp->owd_min)
	238	lp->owd_min = mowd;
	239
	240	/* always forget the max of the max
	241	* we just set owd_max as one below it */
	242	if (mowd > lp->owd_max) {
	243	if (mowd > lp->owd_max_rsv) {
	244	if (lp->owd_max_rsv == 0)
	245	lp->owd_max = mowd;
	246	else
	247	lp->owd_max = lp->owd_max_rsv;
	248	lp->owd_max_rsv = mowd;
	249	} else
	250	lp->owd_max = mowd;
	251	}
	252
	253	/* calc for smoothed owd */
	254	if (lp->sowd != 0) {
	255	mowd -= lp->sowd >> 3; /* m is now error in owd est */
	256	lp->sowd += mowd; /* owd = 7/8 owd + 1/8 new */
	257	} else
	258	lp->sowd = mowd << 3; /* take the measured time be owd */
	259	}
	260
	261	/**
	262	* tcp_lp_pkts_acked
726e5e49	263	* @sk: socket requiring congestion avoidance calculations
7c106d7e WHSE	264	*
	265	* Implementation of pkts_acked.
	266	* Deal with active drop under Early Congestion Indication.
	267	* Only drop to half and 1 will be handle, because we hope to use back
	268	* newReno in increase case.
	269	* We work it out by following the idea from TCP-LP's paper directly
	270	*/
756ee172	271	static void tcp_lp_pkts_acked(struct sock sk, const struct ack_sample sample)
7c106d7e WHSE	272	{
	273	struct tcp_sock *tp = tcp_sk(sk);
	274	struct lp *lp = inet_csk_ca(sk);
9a568de4	275	u32 now = tcp_time_stamp(tp);
a9f11f96	276	u32 delta;
7c106d7e	277
756ee172 LB	278	if (sample->rtt_us > 0)
756ee172 LB	279	tcp_lp_rtt_sample(sk, sample->rtt_us);
164891aa	280
7c106d7e	281	/* calc inference */
46bf466f	282	delta = now - tp->rx_opt.rcv_tsecr;
a9f11f96 ED	283	if ((s32)delta > 0)
a9f11f96 ED	284	lp->inference = 3 * delta;
7c106d7e WHSE	285
7c106d7e WHSE	286	/* test if within inference */
46bf466f	287	if (lp->last_drop && (now - lp->last_drop < lp->inference))
7c106d7e WHSE	288	lp->flag \|= LP_WITHIN_INF;
	289	else
	290	lp->flag &= ~LP_WITHIN_INF;
	291
	292	/* test if within threshold */
	293	if (lp->sowd >> 3 <
	294	lp->owd_min + 15 * (lp->owd_max - lp->owd_min) / 100)
	295	lp->flag \|= LP_WITHIN_THR;
	296	else
	297	lp->flag &= ~LP_WITHIN_THR;
	298
	299	pr_debug("TCP-LP: %05o\|%5u\|%5u\|%15u\|%15u\|%15u\n", lp->flag,
40570375	300	tcp_snd_cwnd(tp), lp->remote_hz, lp->owd_min, lp->owd_max,
7c106d7e WHSE	301	lp->sowd >> 3);
	302
	303	if (lp->flag & LP_WITHIN_THR)
	304	return;
	305
	306	/* FIXME: try to reset owd_min and owd_max here
	307	* so decrease the chance the min/max is no longer suitable
e5ca43e8	308	* and will usually within threshold when within inference */
7c106d7e WHSE	309	lp->owd_min = lp->sowd >> 3;
	310	lp->owd_max = lp->sowd >> 2;
	311	lp->owd_max_rsv = lp->sowd >> 2;
	312
	313	/* happened within inference
	314	* drop snd_cwnd into 1 */
	315	if (lp->flag & LP_WITHIN_INF)
40570375	316	tcp_snd_cwnd_set(tp, 1U);
7c106d7e WHSE	317
	318	/* happened after inference
	319	* cut snd_cwnd into half */
	320	else
40570375	321	tcp_snd_cwnd_set(tp, max(tcp_snd_cwnd(tp) >> 1U, 1U));
7c106d7e WHSE	322
7c106d7e WHSE	323	/* record this drop time */
46bf466f	324	lp->last_drop = now;
7c106d7e WHSE	325	}
7c106d7e WHSE	326
a252bebe	327	static struct tcp_congestion_ops tcp_lp __read_mostly = {
7c106d7e WHSE	328	.init = tcp_lp_init,
7c106d7e WHSE	329	.ssthresh = tcp_reno_ssthresh,
e9799183	330	.undo_cwnd = tcp_reno_undo_cwnd,
7c106d7e	331	.cong_avoid = tcp_lp_cong_avoid,
7c106d7e WHSE	332	.pkts_acked = tcp_lp_pkts_acked,
	333
	334	.owner = THIS_MODULE,
	335	.name = "lp"
	336	};
	337
	338	static int __init tcp_lp_register(void)
	339	{
29896972	340	BUILD_BUG_ON(sizeof(struct lp) > ICSK_CA_PRIV_SIZE);
7c106d7e WHSE	341	return tcp_register_congestion_control(&tcp_lp);
	342	}
	343
	344	static void __exit tcp_lp_unregister(void)
	345	{
	346	tcp_unregister_congestion_control(&tcp_lp);
	347	}
	348
	349	module_init(tcp_lp_register);
	350	module_exit(tcp_lp_unregister);
	351
3795da47	352	MODULE_AUTHOR("Wong Hoi Sing Edison, Hung Hing Lun Mike");
7c106d7e WHSE	353	MODULE_LICENSE("GPL");
7c106d7e WHSE	354	MODULE_DESCRIPTION("TCP Low Priority");