/*
   * 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       1000
  
  /**
   * 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: resrved 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
   *
   * 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
   *
   * 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,
  			      u32 in_flight)
  {
  	struct lp *lp = inet_csk_ca(sk);
  
  	if (!(lp->flag & LP_WITHIN_INF))
  		tcp_reno_cong_avoid(sk, ack, acked, in_flight);
  }
  
  /**
   * tcp_lp_remote_hz_estimator
   *
   * 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 = 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
   *
   * 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 / 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
   *
   * 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
   *
   * 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, u32 num_acked, s32 rtt_us)
  {
  	struct tcp_sock *tp = tcp_sk(sk);
  	struct lp *lp = inet_csk_ca(sk);
  
  	if (rtt_us > 0)
  		tcp_lp_rtt_sample(sk, rtt_us);
  
  	/* calc inference */
  	if (tcp_time_stamp > tp->rx_opt.rcv_tsecr)
  		lp->inference = 3 * (tcp_time_stamp - tp->rx_opt.rcv_tsecr);
  
  	/* test if within inference */
  	if (lp->last_drop && (tcp_time_stamp - 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
  ", lp->flag,
  		 tp->snd_cwnd, 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 whithin 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)
  		tp->snd_cwnd = 1U;
  
  	/* happened after inference
  	 * cut snd_cwnd into half */
  	else
  		tp->snd_cwnd = max(tp->snd_cwnd >> 1U, 1U);
  
  	/* record this drop time */
  	lp->last_drop = tcp_time_stamp;
  }
  
  static struct tcp_congestion_ops tcp_lp __read_mostly = {
  	.flags = TCP_CONG_RTT_STAMP,
  	.init = tcp_lp_init,
  	.ssthresh = tcp_reno_ssthresh,
  	.cong_avoid = tcp_lp_cong_avoid,
  	.min_cwnd = tcp_reno_min_cwnd,
  	.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");