/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2017 by Delphix. All rights reserved.
 */

/*
 * The TCP congestion control algorithm extracted from the pre-framework
 * implementation of TCP congestion control.
 */

#include <sys/errno.h>
#include <inet/tcp.h>
#include <inet/tcp_impl.h>
#include <inet/cc.h>
#include <inet/cc/cc_module.h>

static void	sunreno_ack_received(struct cc_var *ccv, uint16_t type);
static void	sunreno_after_idle(struct cc_var *ccv);
static void	sunreno_cong_signal(struct cc_var *ccv, uint32_t type);
static void	sunreno_post_recovery(struct cc_var *ccv);

#define	CC_SUNRENO_ALGO_NAME "sunreno"

static struct modlmisc cc_sunreno_modlmisc = {
	&mod_miscops,
	"SUNReno Congestion Control"
};

static struct modlinkage cc_sunreno_modlinkage = {
	MODREV_1,
	&cc_sunreno_modlmisc,
	NULL
};

struct cc_algo sunreno_cc_algo = {
	.name = CC_SUNRENO_ALGO_NAME,
	.ack_received = sunreno_ack_received,
	.after_idle = sunreno_after_idle,
	.cong_signal = sunreno_cong_signal,
	.post_recovery = sunreno_post_recovery,
};

int
_init(void)
{
	int err;

	if ((err = cc_register_algo(&sunreno_cc_algo)) == 0) {
		if ((err = mod_install(&cc_sunreno_modlinkage)) != 0)
			(void) cc_deregister_algo(&sunreno_cc_algo);
	}
	return (err);
}

int
_fini(void)
{
	return (EBUSY);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&cc_sunreno_modlinkage, modinfop));
}

static void
sunreno_ack_received(struct cc_var *ccv, uint16_t type)
{
	uint32_t add;
	uint32_t cwnd;
	int mss;

	if (type == CC_ACK && !IN_RECOVERY(ccv->flags)) {
		mss = CCV(ccv, tcp_mss);
		cwnd = CCV(ccv, tcp_cwnd);
		add = mss;

		if (cwnd >= CCV(ccv, tcp_cwnd_ssthresh)) {
			/*
			 * This is to prevent an increase of less than 1 MSS of
			 * tcp_cwnd.  With partial increase, tcp_wput_data()
			 * may send out tinygrams in order to preserve mblk
			 * boundaries.
			 *
			 * By initializing tcp_cwnd_cnt to new tcp_cwnd and
			 * decrementing it by 1 MSS for every ACKs, tcp_cwnd is
			 * increased by 1 MSS for every RTTs.
			 */
			if (CCV(ccv, tcp_cwnd_cnt) <= 0) {
				CCV(ccv, tcp_cwnd_cnt) = cwnd + add;
			} else {
				CCV(ccv, tcp_cwnd_cnt) -= add;
				add = 0;
			}
		}
		CCV(ccv, tcp_cwnd) = MIN(cwnd + add, CCV(ccv, tcp_cwnd_max));
	}
}

static void
sunreno_after_idle(struct cc_var *ccv)
{
	int32_t	num_sack_blk = 0;
	int mss;

	if (CCV(ccv, tcp_snd_sack_ok) && CCV(ccv, tcp_num_sack_blk) > 0) {
		int32_t	opt_len;

		num_sack_blk = MIN(CCV(ccv, tcp_max_sack_blk),
		    CCV(ccv, tcp_num_sack_blk));
		opt_len = num_sack_blk * sizeof (sack_blk_t) + TCPOPT_NOP_LEN *
		    2 + TCPOPT_HEADER_LEN;
		mss = CCV(ccv, tcp_mss) - opt_len;
	} else {
		mss = CCV(ccv, tcp_mss);
	}

	TCP_SET_INIT_CWND(CCV_PROTO(ccv), mss,
	    CCSV(ccv, tcps_slow_start_after_idle));
}

/*
 * Perform any necessary tasks before we enter congestion recovery.
 */
static void
sunreno_cong_signal(struct cc_var *ccv, uint32_t type)
{
	int npkt;
	int mss;

	/* Catch algos which mistakenly leak private signal types. */
	ASSERT((type & CC_SIGPRIVMASK) == 0);

	mss = CCV(ccv, tcp_mss);
	npkt = ((CCV(ccv, tcp_snxt) - CCV(ccv, tcp_suna)) >> 1) / mss;

	switch (type) {
	case CC_NDUPACK:
		if (!IN_FASTRECOVERY(ccv->flags)) {
			if (!IN_CONGRECOVERY(ccv->flags)) {
				CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) *
				    mss;
				CCV(ccv, tcp_cwnd) = (npkt +
				    CCV(ccv, tcp_dupack_cnt)) * mss;
			}
			ENTER_RECOVERY(ccv->flags);
		}
		break;
	case CC_ECN:
		if (!IN_CONGRECOVERY(ccv->flags) && !CCV(ccv, tcp_cwr)) {
			CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) * mss;
			CCV(ccv, tcp_cwnd) = npkt * mss;
			if (CCV(ccv, tcp_cwnd) == 0) {
				/*
				 * This makes sure that when the ACK comes
				 * back, we will increase tcp_cwnd by 1 MSS.
				 */
				CCV(ccv, tcp_cwnd_cnt) = 0;
			}
			ENTER_CONGRECOVERY(ccv->flags);
		}
		break;
	case CC_RTO:
		/*
		 * After retransmission, we need to do slow start.  Set the
		 * ssthresh to one half of current effective window and cwnd to
		 * one MSS.  Also reset tcp_cwnd_cnt.
		 *
		 * Note that if tcp_ssthresh is reduced because of ECN, do not
		 * reduce it again unless it is already one window of data away
		 * (tcp_cwr should then be cleared) or this is a timeout for a
		 * retransmitted segment.
		 */
		if (!CCV(ccv, tcp_cwr) || CCV(ccv, tcp_rexmit)) {
			if (CCV(ccv, tcp_timer_backoff) != 0)
				npkt = CCV(ccv, tcp_cwnd_ssthresh) / 2 / mss;
			CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) * mss;
		}
		CCV(ccv, tcp_cwnd) = mss;
		CCV(ccv, tcp_cwnd_cnt) = 0;
		break;
	}
}

/*
 * Perform any necessary tasks before we exit congestion recovery.
 */
static void
sunreno_post_recovery(struct cc_var *ccv)
{
	/*
	 * Restore the congestion window back to ssthresh as per RFC 5681
	 * section 3.2.
	 */
	if (IN_FASTRECOVERY(ccv->flags)) {
		if (CCV(ccv, tcp_cwnd) > CCV(ccv, tcp_cwnd_ssthresh)) {
			CCV(ccv, tcp_cwnd) = CCV(ccv, tcp_cwnd_ssthresh);
		}
	}
	CCV(ccv, tcp_cwnd_cnt) = 0;
}