Linux Audio

Check our new training course

Loading...
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/* DataCenter TCP (DCTCP) congestion control.
  3 *
  4 * http://simula.stanford.edu/~alizade/Site/DCTCP.html
  5 *
  6 * This is an implementation of DCTCP over Reno, an enhancement to the
  7 * TCP congestion control algorithm designed for data centers. DCTCP
  8 * leverages Explicit Congestion Notification (ECN) in the network to
  9 * provide multi-bit feedback to the end hosts. DCTCP's goal is to meet
 10 * the following three data center transport requirements:
 11 *
 12 *  - High burst tolerance (incast due to partition/aggregate)
 13 *  - Low latency (short flows, queries)
 14 *  - High throughput (continuous data updates, large file transfers)
 15 *    with commodity shallow buffered switches
 16 *
 17 * The algorithm is described in detail in the following two papers:
 18 *
 19 * 1) Mohammad Alizadeh, Albert Greenberg, David A. Maltz, Jitendra Padhye,
 20 *    Parveen Patel, Balaji Prabhakar, Sudipta Sengupta, and Murari Sridharan:
 21 *      "Data Center TCP (DCTCP)", Data Center Networks session
 22 *      Proc. ACM SIGCOMM, New Delhi, 2010.
 23 *   http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp-final.pdf
 24 *
 25 * 2) Mohammad Alizadeh, Adel Javanmard, and Balaji Prabhakar:
 26 *      "Analysis of DCTCP: Stability, Convergence, and Fairness"
 27 *      Proc. ACM SIGMETRICS, San Jose, 2011.
 28 *   http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp_analysis-full.pdf
 29 *
 30 * Initial prototype from Abdul Kabbani, Masato Yasuda and Mohammad Alizadeh.
 31 *
 32 * Authors:
 33 *
 34 *	Daniel Borkmann <dborkman@redhat.com>
 35 *	Florian Westphal <fw@strlen.de>
 36 *	Glenn Judd <glenn.judd@morganstanley.com>
 37 */
 38
 39#include <linux/btf.h>
 40#include <linux/btf_ids.h>
 41#include <linux/module.h>
 42#include <linux/mm.h>
 43#include <net/tcp.h>
 44#include <linux/inet_diag.h>
 45#include "tcp_dctcp.h"
 46
 47#define DCTCP_MAX_ALPHA	1024U
 48
 49struct dctcp {
 50	u32 old_delivered;
 51	u32 old_delivered_ce;
 52	u32 prior_rcv_nxt;
 53	u32 dctcp_alpha;
 54	u32 next_seq;
 55	u32 ce_state;
 56	u32 loss_cwnd;
 57	struct tcp_plb_state plb;
 58};
 59
 60static unsigned int dctcp_shift_g __read_mostly = 4; /* g = 1/2^4 */
 61
 62static int dctcp_shift_g_set(const char *val, const struct kernel_param *kp)
 63{
 64	return param_set_uint_minmax(val, kp, 0, 10);
 65}
 66
 67static const struct kernel_param_ops dctcp_shift_g_ops = {
 68	.set = dctcp_shift_g_set,
 69	.get = param_get_uint,
 70};
 71
 72module_param_cb(dctcp_shift_g, &dctcp_shift_g_ops, &dctcp_shift_g, 0644);
 73MODULE_PARM_DESC(dctcp_shift_g, "parameter g for updating dctcp_alpha");
 74
 75static unsigned int dctcp_alpha_on_init __read_mostly = DCTCP_MAX_ALPHA;
 76module_param(dctcp_alpha_on_init, uint, 0644);
 77MODULE_PARM_DESC(dctcp_alpha_on_init, "parameter for initial alpha value");
 78
 79static struct tcp_congestion_ops dctcp_reno;
 80
 81static void dctcp_reset(const struct tcp_sock *tp, struct dctcp *ca)
 82{
 83	ca->next_seq = tp->snd_nxt;
 84
 85	ca->old_delivered = tp->delivered;
 86	ca->old_delivered_ce = tp->delivered_ce;
 87}
 88
 89__bpf_kfunc static void dctcp_init(struct sock *sk)
 90{
 91	const struct tcp_sock *tp = tcp_sk(sk);
 92
 93	if ((tp->ecn_flags & TCP_ECN_OK) ||
 94	    (sk->sk_state == TCP_LISTEN ||
 95	     sk->sk_state == TCP_CLOSE)) {
 96		struct dctcp *ca = inet_csk_ca(sk);
 97
 98		ca->prior_rcv_nxt = tp->rcv_nxt;
 99
100		ca->dctcp_alpha = min(dctcp_alpha_on_init, DCTCP_MAX_ALPHA);
101
102		ca->loss_cwnd = 0;
103		ca->ce_state = 0;
104
105		dctcp_reset(tp, ca);
106		tcp_plb_init(sk, &ca->plb);
107
108		return;
109	}
110
111	/* No ECN support? Fall back to Reno. Also need to clear
112	 * ECT from sk since it is set during 3WHS for DCTCP.
113	 */
114	inet_csk(sk)->icsk_ca_ops = &dctcp_reno;
115	INET_ECN_dontxmit(sk);
116}
117
118__bpf_kfunc static u32 dctcp_ssthresh(struct sock *sk)
119{
120	struct dctcp *ca = inet_csk_ca(sk);
121	struct tcp_sock *tp = tcp_sk(sk);
122
123	ca->loss_cwnd = tcp_snd_cwnd(tp);
124	return max(tcp_snd_cwnd(tp) - ((tcp_snd_cwnd(tp) * ca->dctcp_alpha) >> 11U), 2U);
125}
126
127__bpf_kfunc static void dctcp_update_alpha(struct sock *sk, u32 flags)
128{
129	const struct tcp_sock *tp = tcp_sk(sk);
130	struct dctcp *ca = inet_csk_ca(sk);
131
132	/* Expired RTT */
133	if (!before(tp->snd_una, ca->next_seq)) {
134		u32 delivered = tp->delivered - ca->old_delivered;
135		u32 delivered_ce = tp->delivered_ce - ca->old_delivered_ce;
136		u32 alpha = ca->dctcp_alpha;
137		u32 ce_ratio = 0;
138
139		if (delivered > 0) {
140			/* dctcp_alpha keeps EWMA of fraction of ECN marked
141			 * packets. Because of EWMA smoothing, PLB reaction can
142			 * be slow so we use ce_ratio which is an instantaneous
143			 * measure of congestion. ce_ratio is the fraction of
144			 * ECN marked packets in the previous RTT.
145			 */
146			if (delivered_ce > 0)
147				ce_ratio = (delivered_ce << TCP_PLB_SCALE) / delivered;
148			tcp_plb_update_state(sk, &ca->plb, (int)ce_ratio);
149			tcp_plb_check_rehash(sk, &ca->plb);
150		}
151
152		/* alpha = (1 - g) * alpha + g * F */
153
154		alpha -= min_not_zero(alpha, alpha >> dctcp_shift_g);
155		if (delivered_ce) {
156
157			/* If dctcp_shift_g == 1, a 32bit value would overflow
158			 * after 8 M packets.
159			 */
160			delivered_ce <<= (10 - dctcp_shift_g);
161			delivered_ce /= max(1U, delivered);
162
163			alpha = min(alpha + delivered_ce, DCTCP_MAX_ALPHA);
164		}
165		/* dctcp_alpha can be read from dctcp_get_info() without
166		 * synchro, so we ask compiler to not use dctcp_alpha
167		 * as a temporary variable in prior operations.
168		 */
169		WRITE_ONCE(ca->dctcp_alpha, alpha);
170		dctcp_reset(tp, ca);
171	}
172}
173
174static void dctcp_react_to_loss(struct sock *sk)
175{
176	struct dctcp *ca = inet_csk_ca(sk);
177	struct tcp_sock *tp = tcp_sk(sk);
178
179	ca->loss_cwnd = tcp_snd_cwnd(tp);
180	tp->snd_ssthresh = max(tcp_snd_cwnd(tp) >> 1U, 2U);
181}
182
183__bpf_kfunc static void dctcp_state(struct sock *sk, u8 new_state)
184{
185	if (new_state == TCP_CA_Recovery &&
186	    new_state != inet_csk(sk)->icsk_ca_state)
187		dctcp_react_to_loss(sk);
188	/* We handle RTO in dctcp_cwnd_event to ensure that we perform only
189	 * one loss-adjustment per RTT.
190	 */
191}
192
193__bpf_kfunc static void dctcp_cwnd_event(struct sock *sk, enum tcp_ca_event ev)
194{
195	struct dctcp *ca = inet_csk_ca(sk);
196
197	switch (ev) {
198	case CA_EVENT_ECN_IS_CE:
199	case CA_EVENT_ECN_NO_CE:
200		dctcp_ece_ack_update(sk, ev, &ca->prior_rcv_nxt, &ca->ce_state);
201		break;
202	case CA_EVENT_LOSS:
203		tcp_plb_update_state_upon_rto(sk, &ca->plb);
204		dctcp_react_to_loss(sk);
205		break;
206	case CA_EVENT_TX_START:
207		tcp_plb_check_rehash(sk, &ca->plb); /* Maybe rehash when inflight is 0 */
208		break;
209	default:
210		/* Don't care for the rest. */
211		break;
212	}
213}
214
215static size_t dctcp_get_info(struct sock *sk, u32 ext, int *attr,
216			     union tcp_cc_info *info)
217{
218	const struct dctcp *ca = inet_csk_ca(sk);
219	const struct tcp_sock *tp = tcp_sk(sk);
220
221	/* Fill it also in case of VEGASINFO due to req struct limits.
222	 * We can still correctly retrieve it later.
223	 */
224	if (ext & (1 << (INET_DIAG_DCTCPINFO - 1)) ||
225	    ext & (1 << (INET_DIAG_VEGASINFO - 1))) {
226		memset(&info->dctcp, 0, sizeof(info->dctcp));
227		if (inet_csk(sk)->icsk_ca_ops != &dctcp_reno) {
228			info->dctcp.dctcp_enabled = 1;
229			info->dctcp.dctcp_ce_state = (u16) ca->ce_state;
230			info->dctcp.dctcp_alpha = ca->dctcp_alpha;
231			info->dctcp.dctcp_ab_ecn = tp->mss_cache *
232						   (tp->delivered_ce - ca->old_delivered_ce);
233			info->dctcp.dctcp_ab_tot = tp->mss_cache *
234						   (tp->delivered - ca->old_delivered);
235		}
236
237		*attr = INET_DIAG_DCTCPINFO;
238		return sizeof(info->dctcp);
239	}
240	return 0;
241}
242
243__bpf_kfunc static u32 dctcp_cwnd_undo(struct sock *sk)
244{
245	const struct dctcp *ca = inet_csk_ca(sk);
246	struct tcp_sock *tp = tcp_sk(sk);
247
248	return max(tcp_snd_cwnd(tp), ca->loss_cwnd);
249}
250
251static struct tcp_congestion_ops dctcp __read_mostly = {
252	.init		= dctcp_init,
253	.in_ack_event   = dctcp_update_alpha,
254	.cwnd_event	= dctcp_cwnd_event,
255	.ssthresh	= dctcp_ssthresh,
256	.cong_avoid	= tcp_reno_cong_avoid,
257	.undo_cwnd	= dctcp_cwnd_undo,
258	.set_state	= dctcp_state,
259	.get_info	= dctcp_get_info,
260	.flags		= TCP_CONG_NEEDS_ECN,
261	.owner		= THIS_MODULE,
262	.name		= "dctcp",
263};
264
265static struct tcp_congestion_ops dctcp_reno __read_mostly = {
266	.ssthresh	= tcp_reno_ssthresh,
267	.cong_avoid	= tcp_reno_cong_avoid,
268	.undo_cwnd	= tcp_reno_undo_cwnd,
269	.get_info	= dctcp_get_info,
270	.owner		= THIS_MODULE,
271	.name		= "dctcp-reno",
272};
273
274BTF_KFUNCS_START(tcp_dctcp_check_kfunc_ids)
 
 
275BTF_ID_FLAGS(func, dctcp_init)
276BTF_ID_FLAGS(func, dctcp_update_alpha)
277BTF_ID_FLAGS(func, dctcp_cwnd_event)
278BTF_ID_FLAGS(func, dctcp_ssthresh)
279BTF_ID_FLAGS(func, dctcp_cwnd_undo)
280BTF_ID_FLAGS(func, dctcp_state)
281BTF_KFUNCS_END(tcp_dctcp_check_kfunc_ids)
 
 
282
283static const struct btf_kfunc_id_set tcp_dctcp_kfunc_set = {
284	.owner = THIS_MODULE,
285	.set   = &tcp_dctcp_check_kfunc_ids,
286};
287
288static int __init dctcp_register(void)
289{
290	int ret;
291
292	BUILD_BUG_ON(sizeof(struct dctcp) > ICSK_CA_PRIV_SIZE);
293
294	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_STRUCT_OPS, &tcp_dctcp_kfunc_set);
295	if (ret < 0)
296		return ret;
297	return tcp_register_congestion_control(&dctcp);
298}
299
300static void __exit dctcp_unregister(void)
301{
302	tcp_unregister_congestion_control(&dctcp);
303}
304
305module_init(dctcp_register);
306module_exit(dctcp_unregister);
307
308MODULE_AUTHOR("Daniel Borkmann <dborkman@redhat.com>");
309MODULE_AUTHOR("Florian Westphal <fw@strlen.de>");
310MODULE_AUTHOR("Glenn Judd <glenn.judd@morganstanley.com>");
311
312MODULE_LICENSE("GPL v2");
313MODULE_DESCRIPTION("DataCenter TCP (DCTCP)");
v6.8
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/* DataCenter TCP (DCTCP) congestion control.
  3 *
  4 * http://simula.stanford.edu/~alizade/Site/DCTCP.html
  5 *
  6 * This is an implementation of DCTCP over Reno, an enhancement to the
  7 * TCP congestion control algorithm designed for data centers. DCTCP
  8 * leverages Explicit Congestion Notification (ECN) in the network to
  9 * provide multi-bit feedback to the end hosts. DCTCP's goal is to meet
 10 * the following three data center transport requirements:
 11 *
 12 *  - High burst tolerance (incast due to partition/aggregate)
 13 *  - Low latency (short flows, queries)
 14 *  - High throughput (continuous data updates, large file transfers)
 15 *    with commodity shallow buffered switches
 16 *
 17 * The algorithm is described in detail in the following two papers:
 18 *
 19 * 1) Mohammad Alizadeh, Albert Greenberg, David A. Maltz, Jitendra Padhye,
 20 *    Parveen Patel, Balaji Prabhakar, Sudipta Sengupta, and Murari Sridharan:
 21 *      "Data Center TCP (DCTCP)", Data Center Networks session
 22 *      Proc. ACM SIGCOMM, New Delhi, 2010.
 23 *   http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp-final.pdf
 24 *
 25 * 2) Mohammad Alizadeh, Adel Javanmard, and Balaji Prabhakar:
 26 *      "Analysis of DCTCP: Stability, Convergence, and Fairness"
 27 *      Proc. ACM SIGMETRICS, San Jose, 2011.
 28 *   http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp_analysis-full.pdf
 29 *
 30 * Initial prototype from Abdul Kabbani, Masato Yasuda and Mohammad Alizadeh.
 31 *
 32 * Authors:
 33 *
 34 *	Daniel Borkmann <dborkman@redhat.com>
 35 *	Florian Westphal <fw@strlen.de>
 36 *	Glenn Judd <glenn.judd@morganstanley.com>
 37 */
 38
 39#include <linux/btf.h>
 40#include <linux/btf_ids.h>
 41#include <linux/module.h>
 42#include <linux/mm.h>
 43#include <net/tcp.h>
 44#include <linux/inet_diag.h>
 45#include "tcp_dctcp.h"
 46
 47#define DCTCP_MAX_ALPHA	1024U
 48
 49struct dctcp {
 50	u32 old_delivered;
 51	u32 old_delivered_ce;
 52	u32 prior_rcv_nxt;
 53	u32 dctcp_alpha;
 54	u32 next_seq;
 55	u32 ce_state;
 56	u32 loss_cwnd;
 57	struct tcp_plb_state plb;
 58};
 59
 60static unsigned int dctcp_shift_g __read_mostly = 4; /* g = 1/2^4 */
 61module_param(dctcp_shift_g, uint, 0644);
 
 
 
 
 
 
 
 
 
 
 
 62MODULE_PARM_DESC(dctcp_shift_g, "parameter g for updating dctcp_alpha");
 63
 64static unsigned int dctcp_alpha_on_init __read_mostly = DCTCP_MAX_ALPHA;
 65module_param(dctcp_alpha_on_init, uint, 0644);
 66MODULE_PARM_DESC(dctcp_alpha_on_init, "parameter for initial alpha value");
 67
 68static struct tcp_congestion_ops dctcp_reno;
 69
 70static void dctcp_reset(const struct tcp_sock *tp, struct dctcp *ca)
 71{
 72	ca->next_seq = tp->snd_nxt;
 73
 74	ca->old_delivered = tp->delivered;
 75	ca->old_delivered_ce = tp->delivered_ce;
 76}
 77
 78__bpf_kfunc static void dctcp_init(struct sock *sk)
 79{
 80	const struct tcp_sock *tp = tcp_sk(sk);
 81
 82	if ((tp->ecn_flags & TCP_ECN_OK) ||
 83	    (sk->sk_state == TCP_LISTEN ||
 84	     sk->sk_state == TCP_CLOSE)) {
 85		struct dctcp *ca = inet_csk_ca(sk);
 86
 87		ca->prior_rcv_nxt = tp->rcv_nxt;
 88
 89		ca->dctcp_alpha = min(dctcp_alpha_on_init, DCTCP_MAX_ALPHA);
 90
 91		ca->loss_cwnd = 0;
 92		ca->ce_state = 0;
 93
 94		dctcp_reset(tp, ca);
 95		tcp_plb_init(sk, &ca->plb);
 96
 97		return;
 98	}
 99
100	/* No ECN support? Fall back to Reno. Also need to clear
101	 * ECT from sk since it is set during 3WHS for DCTCP.
102	 */
103	inet_csk(sk)->icsk_ca_ops = &dctcp_reno;
104	INET_ECN_dontxmit(sk);
105}
106
107__bpf_kfunc static u32 dctcp_ssthresh(struct sock *sk)
108{
109	struct dctcp *ca = inet_csk_ca(sk);
110	struct tcp_sock *tp = tcp_sk(sk);
111
112	ca->loss_cwnd = tcp_snd_cwnd(tp);
113	return max(tcp_snd_cwnd(tp) - ((tcp_snd_cwnd(tp) * ca->dctcp_alpha) >> 11U), 2U);
114}
115
116__bpf_kfunc static void dctcp_update_alpha(struct sock *sk, u32 flags)
117{
118	const struct tcp_sock *tp = tcp_sk(sk);
119	struct dctcp *ca = inet_csk_ca(sk);
120
121	/* Expired RTT */
122	if (!before(tp->snd_una, ca->next_seq)) {
123		u32 delivered = tp->delivered - ca->old_delivered;
124		u32 delivered_ce = tp->delivered_ce - ca->old_delivered_ce;
125		u32 alpha = ca->dctcp_alpha;
126		u32 ce_ratio = 0;
127
128		if (delivered > 0) {
129			/* dctcp_alpha keeps EWMA of fraction of ECN marked
130			 * packets. Because of EWMA smoothing, PLB reaction can
131			 * be slow so we use ce_ratio which is an instantaneous
132			 * measure of congestion. ce_ratio is the fraction of
133			 * ECN marked packets in the previous RTT.
134			 */
135			if (delivered_ce > 0)
136				ce_ratio = (delivered_ce << TCP_PLB_SCALE) / delivered;
137			tcp_plb_update_state(sk, &ca->plb, (int)ce_ratio);
138			tcp_plb_check_rehash(sk, &ca->plb);
139		}
140
141		/* alpha = (1 - g) * alpha + g * F */
142
143		alpha -= min_not_zero(alpha, alpha >> dctcp_shift_g);
144		if (delivered_ce) {
145
146			/* If dctcp_shift_g == 1, a 32bit value would overflow
147			 * after 8 M packets.
148			 */
149			delivered_ce <<= (10 - dctcp_shift_g);
150			delivered_ce /= max(1U, delivered);
151
152			alpha = min(alpha + delivered_ce, DCTCP_MAX_ALPHA);
153		}
154		/* dctcp_alpha can be read from dctcp_get_info() without
155		 * synchro, so we ask compiler to not use dctcp_alpha
156		 * as a temporary variable in prior operations.
157		 */
158		WRITE_ONCE(ca->dctcp_alpha, alpha);
159		dctcp_reset(tp, ca);
160	}
161}
162
163static void dctcp_react_to_loss(struct sock *sk)
164{
165	struct dctcp *ca = inet_csk_ca(sk);
166	struct tcp_sock *tp = tcp_sk(sk);
167
168	ca->loss_cwnd = tcp_snd_cwnd(tp);
169	tp->snd_ssthresh = max(tcp_snd_cwnd(tp) >> 1U, 2U);
170}
171
172__bpf_kfunc static void dctcp_state(struct sock *sk, u8 new_state)
173{
174	if (new_state == TCP_CA_Recovery &&
175	    new_state != inet_csk(sk)->icsk_ca_state)
176		dctcp_react_to_loss(sk);
177	/* We handle RTO in dctcp_cwnd_event to ensure that we perform only
178	 * one loss-adjustment per RTT.
179	 */
180}
181
182__bpf_kfunc static void dctcp_cwnd_event(struct sock *sk, enum tcp_ca_event ev)
183{
184	struct dctcp *ca = inet_csk_ca(sk);
185
186	switch (ev) {
187	case CA_EVENT_ECN_IS_CE:
188	case CA_EVENT_ECN_NO_CE:
189		dctcp_ece_ack_update(sk, ev, &ca->prior_rcv_nxt, &ca->ce_state);
190		break;
191	case CA_EVENT_LOSS:
192		tcp_plb_update_state_upon_rto(sk, &ca->plb);
193		dctcp_react_to_loss(sk);
194		break;
195	case CA_EVENT_TX_START:
196		tcp_plb_check_rehash(sk, &ca->plb); /* Maybe rehash when inflight is 0 */
197		break;
198	default:
199		/* Don't care for the rest. */
200		break;
201	}
202}
203
204static size_t dctcp_get_info(struct sock *sk, u32 ext, int *attr,
205			     union tcp_cc_info *info)
206{
207	const struct dctcp *ca = inet_csk_ca(sk);
208	const struct tcp_sock *tp = tcp_sk(sk);
209
210	/* Fill it also in case of VEGASINFO due to req struct limits.
211	 * We can still correctly retrieve it later.
212	 */
213	if (ext & (1 << (INET_DIAG_DCTCPINFO - 1)) ||
214	    ext & (1 << (INET_DIAG_VEGASINFO - 1))) {
215		memset(&info->dctcp, 0, sizeof(info->dctcp));
216		if (inet_csk(sk)->icsk_ca_ops != &dctcp_reno) {
217			info->dctcp.dctcp_enabled = 1;
218			info->dctcp.dctcp_ce_state = (u16) ca->ce_state;
219			info->dctcp.dctcp_alpha = ca->dctcp_alpha;
220			info->dctcp.dctcp_ab_ecn = tp->mss_cache *
221						   (tp->delivered_ce - ca->old_delivered_ce);
222			info->dctcp.dctcp_ab_tot = tp->mss_cache *
223						   (tp->delivered - ca->old_delivered);
224		}
225
226		*attr = INET_DIAG_DCTCPINFO;
227		return sizeof(info->dctcp);
228	}
229	return 0;
230}
231
232__bpf_kfunc static u32 dctcp_cwnd_undo(struct sock *sk)
233{
234	const struct dctcp *ca = inet_csk_ca(sk);
235	struct tcp_sock *tp = tcp_sk(sk);
236
237	return max(tcp_snd_cwnd(tp), ca->loss_cwnd);
238}
239
240static struct tcp_congestion_ops dctcp __read_mostly = {
241	.init		= dctcp_init,
242	.in_ack_event   = dctcp_update_alpha,
243	.cwnd_event	= dctcp_cwnd_event,
244	.ssthresh	= dctcp_ssthresh,
245	.cong_avoid	= tcp_reno_cong_avoid,
246	.undo_cwnd	= dctcp_cwnd_undo,
247	.set_state	= dctcp_state,
248	.get_info	= dctcp_get_info,
249	.flags		= TCP_CONG_NEEDS_ECN,
250	.owner		= THIS_MODULE,
251	.name		= "dctcp",
252};
253
254static struct tcp_congestion_ops dctcp_reno __read_mostly = {
255	.ssthresh	= tcp_reno_ssthresh,
256	.cong_avoid	= tcp_reno_cong_avoid,
257	.undo_cwnd	= tcp_reno_undo_cwnd,
258	.get_info	= dctcp_get_info,
259	.owner		= THIS_MODULE,
260	.name		= "dctcp-reno",
261};
262
263BTF_SET8_START(tcp_dctcp_check_kfunc_ids)
264#ifdef CONFIG_X86
265#ifdef CONFIG_DYNAMIC_FTRACE
266BTF_ID_FLAGS(func, dctcp_init)
267BTF_ID_FLAGS(func, dctcp_update_alpha)
268BTF_ID_FLAGS(func, dctcp_cwnd_event)
269BTF_ID_FLAGS(func, dctcp_ssthresh)
270BTF_ID_FLAGS(func, dctcp_cwnd_undo)
271BTF_ID_FLAGS(func, dctcp_state)
272#endif
273#endif
274BTF_SET8_END(tcp_dctcp_check_kfunc_ids)
275
276static const struct btf_kfunc_id_set tcp_dctcp_kfunc_set = {
277	.owner = THIS_MODULE,
278	.set   = &tcp_dctcp_check_kfunc_ids,
279};
280
281static int __init dctcp_register(void)
282{
283	int ret;
284
285	BUILD_BUG_ON(sizeof(struct dctcp) > ICSK_CA_PRIV_SIZE);
286
287	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_STRUCT_OPS, &tcp_dctcp_kfunc_set);
288	if (ret < 0)
289		return ret;
290	return tcp_register_congestion_control(&dctcp);
291}
292
293static void __exit dctcp_unregister(void)
294{
295	tcp_unregister_congestion_control(&dctcp);
296}
297
298module_init(dctcp_register);
299module_exit(dctcp_unregister);
300
301MODULE_AUTHOR("Daniel Borkmann <dborkman@redhat.com>");
302MODULE_AUTHOR("Florian Westphal <fw@strlen.de>");
303MODULE_AUTHOR("Glenn Judd <glenn.judd@morganstanley.com>");
304
305MODULE_LICENSE("GPL v2");
306MODULE_DESCRIPTION("DataCenter TCP (DCTCP)");