path: root/net/ipv4/tcp_mytcp.c

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/inet_diag.h>
//#include </home/tcp/linux-5.7/linux-5.7.10/arch/arm/include/asm/div64.h>
//#include <div64.h>
//#include <math.h>

#include <net/tcp.h>
#include <linux/time.h>    // for gettimeofday()
#include <linux/kernel.h>
#include "/home/player/Desktop/ohos/src/kernel/linux/linux-5.10/drivers/net/wireless/ath/ath10k/core.h"
#include "/home/player/Desktop/ohos/src/kernel/linux/linux-5.10/include/net/mac80211.h"
#include "tcp_vegas.h"

#include "tcp_mytcp.h"

//extern unsigned long mytcp_max_tx_queue;
//extern unsigned long mytcp_actual_max_queue;
//extern unsigned long mytcp_actual_min_queue;
//extern unsigned long mytcp_min_tx_queue;
//extern unsigned long receive_num_in_RTT;
//extern unsigned long mytcp_round_count;
//extern unsigned long mytcp_round_max;

//extern void __skb_tstamp_tx;

//extern int mytcp_flow_num;
//int this_flow_num;

static int gamma = 2;
static int RQ_allow = 40;

module_param(gamma, int, 0644);
MODULE_PARM_DESC(gamma, "limit on increase (scale by 2)");


static void mytcp_enable(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	//struct tcp_sock *tp = tcp_sk(sk);
	struct mytcp *mytcp = inet_csk_ca(sk);

	/* Begin taking mytcp samples next time we send something. */
//	printk(KERN_DEBUG "enable mytcp\n");
	mytcp->doing_mytcp_now = 1;
	tp->mytcp_enable_flag = 1;

	/* Set the beginning of the next send window. */
	
	mytcp->beg_snd_nxt = 0x7fffffff;
//	mytcp->minRTT = 0x7fffffff;
//	mytcp->slow_start_end = 0;
	mytcp->full_flag_1 = 0;
	mytcp->full_flag_2 = 0;
	mytcp->full_flag_3 = 0;
	mytcp->cong_flag = 0;
//	mytcp->bytes_rtt = 0;
//	receive_num_in_RTT = 0;
//	mytcp_round_count = 0;
	tp->mytcp_round_flag = 0;
	mytcp->min_rtt = 1000000;

	mytcp->time_now = 0;
//	mytcp->time_last = 0;

//	mytcp->num_i = 0;


}

/* Stop taking mytcp samples for now. */
static inline void mytcp_disable(struct sock *sk)
{
	struct mytcp *mytcp = inet_csk_ca(sk);
	struct tcp_sock *tp = tcp_sk(sk);

	mytcp->doing_mytcp_now = 0;
	tp->mytcp_enable_flag = 0;
}

void tcp_mytcp_init(struct sock *sk)
{
	struct mytcp *mytcp = inet_csk_ca(sk);
	//struct tcp_sock *tp = tcp_sk(sk);
	mytcp->baseRTT = 0x7fffffff;
	mytcp->max_queue_within_t = 0;
	mytcp->min_queue_within_t = 1000;
//	mytcp_flow_num++;
//	this_flow_num = mytcp_flow_num;
	
	//printk(KERN_DEBUG "init mytcp, the time is %u\n", tcp_jiffies32);
//	printk(KERN_DEBUG "init mytcp\n");
	//printk(KERN_DEBUG "init mytcp, the ssth is %u\n", tp->snd_ssthresh);

	mytcp_enable(sk);
}
EXPORT_SYMBOL_GPL(tcp_mytcp_init);

static const u32 mytcp_interval_ms = 1;

void tcp_mytcp_pkts_acked(struct sock *sk, const struct ack_sample *sample)
{
	struct mytcp *mytcp = inet_csk_ca(sk);
	struct tcp_sock *tp = tcp_sk(sk);
//	int time_interval;
	int buffer_queue;
	//u32 msecstojiffies;
	u32 vrtt;

	if (sample->rtt_us < 0)
		return;
	
	vrtt = sample->rtt_us + 1;
//	mytcp->rtt_of_this_packet = sample->rtt_us;
	tp->my_ip_rtt = sample->rtt_us;

	buffer_queue = tp->write_seq - tp->snd_una;   //sndbuffer中的当前队列长度，单位为byte
//	printk(KERN_DEBUG "packets inflight are %u\n", tp->packets_out);
	printk(KERN_DEBUG "the mytcp RTT is %u\n",sample->rtt_us);


	/* Filter to find propagation delay: */
	if (vrtt < mytcp->baseRTT)
		mytcp->baseRTT = vrtt;

	/* Find the min RTT during the last RTT to find
	 * the current prop. delay + queuing delay:
	 */
//	mytcp->minRTT = min(mytcp->minRTT, vrtt);
	if (sample->rtt_us < mytcp->min_rtt){
		mytcp->min_rtt = sample->rtt_us;
//		printk(KERN_DEBUG "the min RTT is %u\n",mytcp->min_rtt);
	}

	if (tp->myfast_cal_bdp_start_flag == 1){
		if (tp->myfast_min_rtt == 0){
			tp->myfast_min_rtt = sample->rtt_us;
		}
		else{
			tp->myfast_min_rtt = min(tp->myfast_min_rtt, sample->rtt_us);
		}
	}	


}
EXPORT_SYMBOL_GPL(tcp_mytcp_pkts_acked);

void tcp_mytcp_state(struct sock *sk, u8 ca_state)
{
	struct tcp_sock *tp = tcp_sk(sk);
//	struct mytcp *mytcp = inet_csk_ca(sk);
	if (ca_state == TCP_CA_Open){
//		mytcp_enable(sk);
		tp->snd_cwnd = tp->snd_cwnd;
//		printk(KERN_DEBUG "nothing happens, the cwnd is %u\n", tp->snd_cwnd);
//		printk(KERN_DEBUG "nothing happens, \n");
	}
	else{
//		mytcp_disable(sk);
		tp->snd_cwnd = tp->snd_cwnd;
//		printk(KERN_DEBUG "bad things happen, the cwnd is %u, the snd_ssthresh is %u\n", tp->snd_cwnd, tp->snd_ssthresh);
//		printk(KERN_DEBUG "bad things happens\n");
	}
}
EXPORT_SYMBOL_GPL(tcp_mytcp_state);


void tcp_mytcp_cwnd_event(struct sock *sk, enum tcp_ca_event event)
{
//	struct tcp_sock *tp = tcp_sk(sk);
//	struct mytcp *mytcp = inet_csk_ca(sk);

	if (event == CA_EVENT_CWND_RESTART||
	    event == CA_EVENT_TX_START){
//		printk(KERN_DEBUG "event CA_EVENT_CWND_RESTART happens, init mytcp\n");
		tcp_mytcp_init(sk);
	}

}
EXPORT_SYMBOL_GPL(tcp_mytcp_cwnd_event);


//因为有是基于残余队列进行控制，不再依赖丢包信息，因此与BBR相似即使有丢包也不会将cwnd减半
//由于限制了队列堆积程度，QCC的丢包较少，即使可能由于链路容量突然变小有拥塞丢包，也会检测到RQ的存在而降低cwnd
u32 tcp_mytcp_ssthresh(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct mytcp *mytcp = inet_csk_ca(sk);
	tp->snd_cwnd = tp->snd_cwnd;
//	tp->snd_ssthresh = tp->snd_cwnd/2;
//	printk(KERN_DEBUG "the thresh is %u, cwnd is %u\n", tp->snd_ssthresh, tp->snd_cwnd);
//	mytcp->loss_cnt++;
//	return tcp_sk(sk)->snd_ssthresh;
	return tp->snd_cwnd;
}

static void tcp_mytcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct mytcp *mytcp = inet_csk_ca(sk);
	int buffer_queue;
	int min_inflight;

	mytcp->inflight_2pre = mytcp->inflight_1pre;
	mytcp->inflight_1pre = mytcp->inflight_now;

	buffer_queue = tp->write_seq - tp->snd_una;   //sndbuffer中的当前队列长度，单位为byte
	mytcp->inflight_now = tp->packets_out;
	if (mytcp->inflight_1pre < mytcp->inflight_2pre && mytcp->inflight_1pre < mytcp->inflight_now){
		min_inflight = mytcp->inflight_1pre;
//		printk(KERN_DEBUG "min inflight is %u\n", min_inflight);
//		printk(KERN_DEBUG "min_queue is %d\n", mytcp->min_queue_within_t);
	}


	mytcp->cwnd_last = tp->snd_cwnd;
//	mytcp->mytcp_max_driver_queue = mytcp_actual_max_queue;
	mytcp->mytcp_max_driver_queue = tp->mytcp_est_max_queue_real;


//	printk(KERN_DEBUG "mytcp_max_driver_queue is %u\n", mytcp->mytcp_max_driver_queue);
//	printk(KERN_DEBUG "max_queue_within_t is %u\n", mytcp->max_queue_within_t);

	if (mytcp->mytcp_max_driver_queue > mytcp->max_queue_within_t){				//mytcp+++++++//
		 mytcp->max_queue_within_t = mytcp->mytcp_max_driver_queue;
	}

//	mytcp->min_queue_within_t = mytcp_min_tx_queue;
//	mytcp->min_queue = mytcp_min_tx_queue;

	mytcp->min_queue_within_t = tp->mytcp_est_rq;
	mytcp->min_queue = tp->mytcp_est_rq;

	if ((mytcp->min_queue_within_t > 0) && (mytcp->max_queue_within_t > mytcp->min_queue_within_t)){
		mytcp->one_full_ronund_send = mytcp->max_queue_within_t - mytcp->min_queue_within_t;
		mytcp->threshold = (mytcp->one_full_ronund_send * 5) / 100;
		mytcp->threshold = max(mytcp->threshold,RQ_allow);
	}
	else{
		mytcp->threshold = RQ_allow;
	}
//	printk(KERN_DEBUG "min_queue_within_t is %d\n", mytcp->min_queue_within_t);
//	printk(KERN_DEBUG "max_queue_within_t is %d\n", mytcp->max_queue_within_t);
//	printk(KERN_DEBUG "one_full_ronund_send is %d\n", mytcp->one_full_ronund_send);
//	printk(KERN_DEBUG "mytcp->threshold is %u\n", mytcp->threshold);


	if (!mytcp->doing_mytcp_now) {
		tcp_reno_cong_avoid(sk, ack, acked);
//		printk(KERN_DEBUG "in reno_cong_avoid, the cwnd is %u\n", tp->snd_cwnd);
		return;
	}


	if (tcp_in_slow_start(tp)) {	
		tcp_slow_start(tp, acked);
		mytcp->cwnd_hold = tp->snd_cwnd;
	}

//当没有显式拥塞的信息返回时，按照正常的QCC逻辑利用驱动残余队列调整cwnd
	if (!tp->mytcp_ece_flag){

		//与BBR类似，当连续三轮网卡发送检测出超过阈值的堆积时，才判定占满带宽，退出慢启动。
		if(/*mytcp_round_count*/ tp->mytcp_round_flag >= 1 && tcp_in_slow_start(tp)){
			//mytcp_round_count = 0;
			tp->mytcp_round_flag = 0;
			if (tcp_in_slow_start(tp)) {
				int flag_count = 0;
				mytcp->full_flag_3 = mytcp->full_flag_2;
				mytcp->full_flag_2 = mytcp->full_flag_1;
				mytcp->min_queue_within_t = tp->mytcp_est_rq;
				mytcp->full_flag_1 = mytcp->min_queue_within_t;
				if(mytcp->full_flag_1 > mytcp->threshold){
					flag_count ++;
					tp->mytcp_full_pipe_flag = 1;
				}
				else{
					tp->mytcp_full_pipe_flag = 0;
				}
				if(mytcp->full_flag_2 > mytcp->threshold){
					flag_count ++;
				}
				if(mytcp->full_flag_3 > mytcp->threshold){
					flag_count ++;
				}
//				printk(KERN_DEBUG "in slow start, the flag1 is %d, the flag2 is %d, the flag3 is %d\n", mytcp->full_flag_1, mytcp->full_flag_2, mytcp->full_flag_3);
				//判定占满的条件是残余队列连续三轮大于阈值，或者一旦超过50（表明此时堆积很大）
				//50这个参数取的经验值，调试分析发现这一个值可以有一定变化影响也不大，因为于拥塞避免阶段也具有调整能力
				if ((flag_count >= 3 && /*mytcp_round_max*/tp->mytcp_est_max_queue_real > 50) || (mytcp->full_flag_1 > 80) || (mytcp->loss_cnt > 3))
				{
	//				mytcp->time_last = ktime_get_real_ns();
	//				mytcp->cwnd_first = tp->snd_cwnd - mytcp->full_flag_1;
					mytcp->cwnd_first = tp->snd_cwnd;
	//				tp->snd_cwnd = mytcp->cwnd_first;
	//				tp->snd_ssthresh = tcp_mytcp_ssthresh(tp)/2;
					tp->snd_ssthresh = mytcp->cwnd_first/2;
					mytcp->time_last = ktime_get_real_ns();
					mytcp->beg_snd_nxt  = tp->snd_nxt;
					tp->mytcp_bytes_send = 0;
					tp->mytcp_acked_seq_last = ack;
					printk(KERN_DEBUG "in slow start, full, the snd_cwnd is %d, the ssh is %d\n", mytcp->cwnd_first, tp->snd_ssthresh);
				}
//				printk(KERN_DEBUG "in slow start, the source port is %d, the snd_cwnd is %d, \n", tp->myfast_source, tp->snd_cwnd);
			}
			
	//		receive_num_in_RTT = 0;
			mytcp->max_queue_within_t = 0;
//			mytcp_actual_max_queue = 0;
//			mytcp_round_max = 0;
			tp->mytcp_est_max_queue_real = 0;
//			mytcp->min_queue_within_t = 1000;
//			mytcp_actual_min_queue = 1000;
			mytcp->cwnd_hold = tp->snd_cwnd;
		}

		else if(/*mytcp_round_count*/ tp->mytcp_round_flag >= 1 && !tcp_in_slow_start(tp)){

			if(mytcp->max_queue_within_t > /*mytcp_round_max*/tp->mytcp_est_max_queue_real){
				mytcp->max_queue_now = mytcp->max_queue_within_t;
			}
			else{
				mytcp->max_queue_now = /*mytcp_round_max*/tp->mytcp_est_max_queue_real;
			}
			//mytcp->max_queue_within_t;
	//		mytcp_round_count = 0;
			tp->mytcp_round_flag = 0;
	//		mytcp->cwnd_last = tp->snd_cwnd;
			if (mytcp->cong_flag == 3){
				tp->snd_cwnd = mytcp->cwnd_first;
				if(mytcp->max_queue_within_t > /*mytcp_round_max*/tp->mytcp_est_max_queue_real){
					mytcp->max_queue_first = mytcp->max_queue_within_t;
				}
				else{
					mytcp->max_queue_first = /*mytcp_round_max*/tp->mytcp_est_max_queue_real;
				}
	//			mytcp->max_queue_first = mytcp_round_max; //mytcp->max_queue_within_t;
				mytcp->queue_now = (mytcp->max_queue_first - mytcp->min_queue_within_t) + 1;
				mytcp->min_last = mytcp->min_queue_within_t;
				mytcp->cong_flag = 99;
	//			mytcp->time_tmp = ktime_get_real_ns();
			}

			else if (mytcp->cong_flag < 3){
				tp->snd_cwnd = mytcp->cwnd_first;
				mytcp->cong_flag ++;
//				printk(KERN_DEBUG "mytcp->cong_flag < 3, snd_cwnd is %u\n", tp->snd_cwnd);
			}

			else{
				mytcp->queue_last = mytcp->queue_now;
				if(mytcp->min_last == 0 && mytcp->min_queue_within_t == 0){   //连续n轮最小队列长度为0，则cwnd增长步长变为n*10
	//				mytcp->cwnd_last = mytcp->cwnd_last + mytcp->threshold;
					mytcp->cwnd_last = mytcp->cwnd_last + RQ_allow;
				}

				else {
					mytcp->cwnd_first = mytcp->cwnd_first;
				}

				mytcp->min_last = mytcp->min_queue_within_t;

				if(mytcp->min_queue_within_t > 0 && mytcp->min_queue_within_t < mytcp->threshold){
					tp->snd_cwnd = tp->snd_cwnd;
					mytcp->cwnd_first = tp->snd_cwnd;
					mytcp->max_queue_first = mytcp->max_queue_now;
//					printk(KERN_DEBUG "suitable, snd_cwnd is %u\n", tp->snd_cwnd);
	//				printk(KERN_DEBUG "111111111111111111111111111, into the update, snd_cwnd is %u\n", tp->snd_cwnd);
				}
//				else if(/*mytcp->max_queue_now > 10 && */mytcp->queue_now > 5){   //确保队列中至少有5个包的进出
				else{
					if(mytcp->min_queue_within_t > mytcp->threshold){
						tp->snd_cwnd = mytcp->cwnd_last - (mytcp->min_queue_within_t - mytcp->threshold);
//						printk(KERN_DEBUG "too_long, snd_cwnd is %u\n", tp->snd_cwnd);
					}
					if(mytcp->min_queue_within_t == 0){
						tp->snd_cwnd = mytcp->cwnd_last +  mytcp->threshold;
//						printk(KERN_DEBUG "empty, snd_cwnd is %u\n", tp->snd_cwnd);
					}
				}
//					else{
//						tp->snd_cwnd = tp->snd_cwnd;
//					}
//				}
//				else{
//					tp->snd_cwnd = tp->snd_cwnd;
					
//				}

			}
			
			printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, tp->snd_cwnd is %u\n", tp->snd_cwnd);
			printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, min_queue_within_t is %d\n", mytcp->min_queue_within_t);
	//		printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, queue last is %d\n", mytcp->queue_last);
	//		printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, queue now is %d\n", mytcp->queue_now);

		//		mytcp->min_queue_within_t = mytcp->max_queue_within_t;
			mytcp->max_queue_within_t = 0;
//			mytcp_actual_max_queue = 0;
//			mytcp_round_max = 0;
			tp->mytcp_est_max_queue_real = 0;
//			mytcp->min_queue_within_t = 1000;
//			mytcp_actual_min_queue = 1000;
			if (tp->snd_cwnd < 10)
				tp->snd_cwnd = 10;
		//		if (tp->snd_cwnd > 30)
		//			tp->snd_cwnd = 30;
			else if (tp->snd_cwnd > tp->snd_cwnd_clamp)
				tp->snd_cwnd = tp->snd_cwnd_clamp;
	//			tp->snd_ssthresh = tcp_current_ssthresh(sk);
//			printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, the last_cwnd is %u\n", mytcp->cwnd_last);
	//		printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, the cwnd is %u\n", tp->snd_cwnd);
			mytcp->cwnd_hold = tp->snd_cwnd;
		}

		else{
			tp->snd_cwnd = mytcp->cwnd_hold;
//			printk(KERN_DEBUG "111111111111111111111111111, else, the cwnd is %u\n", tp->snd_cwnd);
		}
	}

//	每一个rtt统计一次有线瓶颈的场景
	if (after(ack, mytcp->beg_snd_nxt) && !tcp_in_slow_start(tp)){    //瓶颈为有线部分时的处理
   
		int packets_in_air;
		int RQ_wire;
		int RQ_wire2;
		int extra_cwnd;
		int throughput2;

		mytcp->beg_snd_nxt  = tp->snd_nxt;
		mytcp->time_now = ktime_get_real_ns();

		//从确认占满链路后100ms再开始计算吞吐量，避免慢启动发送窗口耗尽对带宽估算的影响。
//		if ((mytcp->time_now - mytcp->time_last)>(100*1000)){

		tp->mytcp_acked_bytes = ack - tp->mytcp_acked_seq_last;	
		mytcp->throughput_now = (tp->mytcp_bytes_send * 8) / ((mytcp->time_now - mytcp->time_last)/1000);
		throughput2 = (tp->mytcp_acked_bytes * 8) / ((mytcp->time_now - mytcp->time_last)/1000);

		if (mytcp->throughput_now  > 0){
			packets_in_air = (((mytcp->throughput_now * 2)/1) * mytcp->min_rtt)/(tp->mss_cache*8);
			RQ_wire = tp->packets_out - mytcp->min_queue - packets_in_air;
		}

		else {
			RQ_wire = 0;
		}

		if(RQ_wire < 0){
			RQ_wire = 0;
		}

		if(RQ_wire > mytcp->threshold){
			extra_cwnd = RQ_wire - mytcp->threshold;
//				tp->snd_cwnd = mytcp->cwnd_last - (RQ_wire - mytcp->threshold);
		}

		else{
			extra_cwnd = 0;
//				tp->snd_cwnd = tp->snd_cwnd;
		}

		tp->snd_cwnd = mytcp->cwnd_last - max(tp->mytcp_ece_count, extra_cwnd);

		if (tp->snd_cwnd > (2*packets_in_air)){
			tp->snd_cwnd = (2*packets_in_air);
		}

//			printk(KERN_DEBUG "the bytes ackes is %llu, time interval is %llu\n", tp->bytes_acked, mytcp->time_now - mytcp->time_last);
		printk(KERN_DEBUG "the throughput is %u, throughput2 is %u, RQ_wire is %u\n", mytcp->throughput_now, throughput2, RQ_wire);
		printk(KERN_DEBUG "wired bottle, the packets out is %u, min queue is %u, packets in air is %d, the RQ wire is %d\n",
			tp->packets_out, mytcp->min_queue, packets_in_air, RQ_wire);
//		printk(KERN_DEBUG "wired bottle, the mytcp_ece_count is %u, extra_cwnd is %u\n",tp->mytcp_ece_count, extra_cwnd);
		printk(KERN_DEBUG "111111111111111111111111111, wired bottle, into the cong_avoid, the cwnd is %u\n", tp->snd_cwnd);
//		}
		//将ece计数器置0，重新开始统计下一轮rtt内的ece数量
		tp->mytcp_ece_count = 0;	
		tp->mytcp_bytes_send = 0;
		tp->mytcp_acked_bytes = ack;
		mytcp->time_last = mytcp->time_now;	
		mytcp->cwnd_hold = tp->snd_cwnd;
	}

	else{
			tp->snd_cwnd = mytcp->cwnd_hold;
//			printk(KERN_DEBUG "111111111111111111111111111, else, the cwnd is %u\n", tp->snd_cwnd);
		}


	

//	printk(KERN_DEBUG "111111111111111111111111111, into the cong_avoid, the actual cwnd is %u\n", tp->snd_cwnd);

}



/* Extract info for Tcp socket info provided via netlink. */
size_t tcp_mytcp_get_info(struct sock *sk, u32 ext, int *attr,
			  union tcp_cc_info *info)
{
	const struct mytcp *ca = inet_csk_ca(sk);

	if (ext & (1 << (INET_DIAG_MYTCPINFO - 1))) {
		info->mytcp.tcpv_enabled = ca->doing_mytcp_now;
		info->mytcp.tcpv_rttcnt	= ca->cntRTT;
		info->mytcp.tcpv_rtt = ca->baseRTT;
		info->mytcp.tcpv_minrtt = ca->min_rtt;

		*attr = INET_DIAG_MYTCPINFO;
		return sizeof(struct tcpmytcp_info);
	}
	return 0;
}
//EXPORT_SYMBOL_GPL(tcp_mytcp_get_info);

static struct tcp_congestion_ops tcp_mytcp __read_mostly = {
	.init		= tcp_mytcp_init,
	.ssthresh	= tcp_mytcp_ssthresh,
	.undo_cwnd	= tcp_reno_undo_cwnd,
	.cong_avoid	= tcp_mytcp_cong_avoid,
	.pkts_acked	= tcp_mytcp_pkts_acked,
//	.set_state	= tcp_mytcp_state,
//	.cwnd_event	= tcp_mytcp_cwnd_event,
	.get_info	= tcp_mytcp_get_info,

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

static int __init tcp_mytcp_register(void)
{
	BUILD_BUG_ON(sizeof(struct mytcp) > ICSK_CA_PRIV_SIZE);
	tcp_register_congestion_control(&tcp_mytcp);
	return 0;
}

static void __exit tcp_mytcp_unregister(void)
{
	tcp_unregister_congestion_control(&tcp_mytcp);
}

module_init(tcp_mytcp_register);
module_exit(tcp_mytcp_unregister);

MODULE_AUTHOR("LLG");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("TCP mytcp");