Page MenuHomeFreeBSD
Differential D11616 Diff 31008 sys/netinet/cc/cc_newreno.c

Changeset View

Standalone View

View Options

sys/netinet/cc/cc_newreno.c

/*- /*-
* Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994, 1995 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994, 1995
* The Regents of the University of California. * The Regents of the University of California.
* Copyright (c) 2007-2008,2010 * Copyright (c) 2007-2008,2010,2014
* Swinburne University of Technology, Melbourne, Australia. * Swinburne University of Technology, Melbourne, Australia.
* Copyright (c) 2009-2010 Lawrence Stewart <lstewart@freebsd.org> * Copyright (c) 2009-2010 Lawrence Stewart <lstewart@freebsd.org>
* Copyright (c) 2010 The FreeBSD Foundation * Copyright (c) 2010 The FreeBSD Foundation
Context not available.
* University Research Program Fund at Community Foundation Silicon Valley. * University Research Program Fund at Community Foundation Silicon Valley.
* More details are available at: * More details are available at:
* http://caia.swin.edu.au/urp/newtcp/ * http://caia.swin.edu.au/urp/newtcp/
*
* Dec 2014 garmitage@swin.edu.au
* Borrowed code fragments from cc_cdg.c to add modifiable beta
* via sysctls.
lstewartUnsubmitted
Done
Inline Actions

If this is supposed to be an actual copyright attribution, you should add the appropriate year to the existing set attributed to Swinburne University in the main copyright block, and then extend the second informative comment block with these additional author attribution details.

That being said, given the size of the change it probably doesn't warrant copyright changes, so merging this in to the informative comment block is probably all that's needed.

lstewart: If this is supposed to be an actual copyright attribution, you should add the appropriate year…
*
*/ */
#include <sys/cdefs.h> #include <sys/cdefs.h>
Context not available.
#include <netinet/tcp_var.h> #include <netinet/tcp_var.h>
#include <netinet/cc/cc.h> #include <netinet/cc/cc.h>
#include <netinet/cc/cc_module.h> #include <netinet/cc/cc_module.h>
#include <netinet/cc/cc_newreno.h>
static MALLOC_DEFINE(M_NEWRENO, "newreno data",
"newreno beta values");
#define CAST_PTR_INT(X) (*((int*)(X)))
lstewartUnsubmitted
Done
Inline Actions

This #ifndef block is not needed

lstewart: This #ifndef block is not needed
static int newreno_cb_init(struct cc_var *ccv);
static void newreno_ack_received(struct cc_var *ccv, uint16_t type); static void newreno_ack_received(struct cc_var *ccv, uint16_t type);
static void newreno_after_idle(struct cc_var *ccv); static void newreno_after_idle(struct cc_var *ccv);
static void newreno_cong_signal(struct cc_var *ccv, uint32_t type); static void newreno_cong_signal(struct cc_var *ccv, uint32_t type);
static void newreno_post_recovery(struct cc_var *ccv); static void newreno_post_recovery(struct cc_var *ccv);
static int newreno_ctl_output(struct cc_var *ccv, struct sockopt *sopt, void *buf);
static VNET_DEFINE(uint32_t, newreno_beta) = 50;
static VNET_DEFINE(uint32_t, newreno_beta_ecn) = 80;
#define V_newreno_beta VNET(newreno_beta)
lstewartUnsubmitted
Not Done
Inline Actions

What about treating these as permanently defined variables which default to non-ABE behaviour i.e. 50 and 50, and toggling ABE simply explicitly sets them to draft-specified values? Perhaps renaming newreno_beta_loss to newreno_beta would also make sense, which specifies the default beta that gets overridden by other variables on a case by case basis.

lstewart: What about treating these as permanently defined variables which default to non-ABE behaviour i.
#define V_newreno_beta_ecn VNET(newreno_beta_ecn)
struct cc_algo newreno_cc_algo = { struct cc_algo newreno_cc_algo = {
.name = "newreno", .name = "newreno",
.cb_init = newreno_cb_init,
.ack_received = newreno_ack_received, .ack_received = newreno_ack_received,
.after_idle = newreno_after_idle, .after_idle = newreno_after_idle,
.cong_signal = newreno_cong_signal, .cong_signal = newreno_cong_signal,
.post_recovery = newreno_post_recovery, .post_recovery = newreno_post_recovery,
.ctl_output = newreno_ctl_output,
}; };
struct newreno {
uint32_t beta;
uint32_t beta_ecn;
};
int
newreno_cb_init(struct cc_var *ccv)
{
struct newreno *nreno;
nreno = malloc(sizeof(struct newreno), M_NEWRENO, M_NOWAIT|M_ZERO);
if (nreno != NULL) {
nreno->beta = V_newreno_beta;
nreno->beta_ecn = V_newreno_beta_ecn;
}
return (0);
}
static void static void
newreno_ack_received(struct cc_var *ccv, uint16_t type) newreno_ack_received(struct cc_var *ccv, uint16_t type)
{ {
Context not available.
static void static void
newreno_cong_signal(struct cc_var *ccv, uint32_t type) newreno_cong_signal(struct cc_var *ccv, uint32_t type)
{ {
uint32_t cwin, ssthresh_on_loss; struct newreno *nreno;
uint32_t cwin, ssthresh_on_loss, factor;
u_int mss; u_int mss;
factor = V_newreno_beta;
nreno = ccv->cc_data;
if (nreno != NULL) {
if (V_tcp_do_abe)
factor = (type == CC_ECN ? nreno->beta_ecn: nreno->beta);
else
factor = nreno->beta;
}
cwin = CCV(ccv, snd_cwnd); cwin = CCV(ccv, snd_cwnd);
mss = CCV(ccv, t_maxseg); mss = CCV(ccv, t_maxseg);
ssthresh_on_loss = ssthresh_on_loss =
Context not available.
KASSERT((type & CC_SIGPRIVMASK) == 0, KASSERT((type & CC_SIGPRIVMASK) == 0,
("%s: congestion signal type 0x%08x is private\n", __func__, type)); ("%s: congestion signal type 0x%08x is private\n", __func__, type));
cwin = max(cwin / 2 / mss, 2) * mss; cwin = max(((uint64_t)cwin * (uint64_t)factor) / (100ULL * (uint64_t)mss),
lstewartUnsubmitted
Done
Inline Actions

Let's avoid gratuitous code duplication, and perhaps reinstate this line as something like:

factor = (type == CC_ECN ? V_newreno_beta_ecn : V_newreno_beta_loss);
cwin = max((cwin * factor) / (100 * mss), 2) * mss;

lstewart: Let's avoid gratuitous code duplication, and perhaps reinstate this line as something like…
2) * mss;
switch (type) { switch (type) {
case CC_NDUPACK: case CC_NDUPACK:
lstewartUnsubmitted
Done
Inline Actions

This can change to sysctl_handle_int()

lstewart: This can change to sysctl_handle_int()
Context not available.
} }
} }
int
newreno_ctl_output(struct cc_var *ccv, struct sockopt *sopt, void *buf)
{
struct newreno *nreno;
struct cc_newreno_opts *opt;
if (sopt->sopt_valsize != sizeof(struct cc_newreno_opts))
return (EMSGSIZE);
nreno = ccv->cc_data;
opt = buf;
switch (sopt->sopt_dir) {
case SOPT_SET:
switch (opt->name) {
case CC_NEWRENO_BETA:
nreno->beta = opt->val;
break;
case CC_NEWRENO_BETA_ECN:
if (!V_tcp_do_abe)
return (EACCES);
nreno->beta_ecn = opt->val;
break;
default:
return (ENOPROTOOPT);
}
case SOPT_GET:
switch (opt->name) {
case CC_NEWRENO_BETA:
opt->val = nreno->beta;
break;
case CC_NEWRENO_BETA_ECN:
opt->val = nreno->beta_ecn;
break;
default:
return (ENOPROTOOPT);
}
default:
return (EINVAL);
}
return (0);
}
static int
newreno_beta_handler(SYSCTL_HANDLER_ARGS)
{
if (req->newptr != NULL ) {
if (arg1 == &VNET_NAME(newreno_beta_ecn) && !V_tcp_do_abe)
return (EACCES);
if (CAST_PTR_INT(req->newptr) < 0 || CAST_PTR_INT(req->newptr) > 100)
return (EINVAL);
}
return (sysctl_handle_int(oidp, arg1, arg2, req));
}
SYSCTL_DECL(_net_inet_tcp_cc_newreno);
SYSCTL_NODE(_net_inet_tcp_cc, OID_AUTO, newreno, CTLFLAG_RW, NULL,
"New Reno related settings");
SYSCTL_PROC(_net_inet_tcp_cc_newreno, OID_AUTO, beta,
CTLFLAG_VNET | CTLTYPE_UINT | CTLFLAG_RW,
&VNET_NAME(newreno_beta), 3, &newreno_beta_handler, "IU",
"New Reno beta, specified as number between 0 and 100");
SYSCTL_PROC(_net_inet_tcp_cc_newreno, OID_AUTO, beta_ecn,
CTLFLAG_VNET | CTLTYPE_UINT | CTLFLAG_RW,
&VNET_NAME(newreno_beta_ecn), 3, &newreno_beta_handler, "IU",
"New Reno beta ecn, specified as number between 0 and 100");
lstewartUnsubmitted
Done
Inline Actions

Please note in the sysctl description that net.inet.tcp.abe must be 1 for this variable to be settable.

lstewart: Please note in the sysctl description that net.inet.tcp.abe must be 1 for this variable to be…
DECLARE_CC_MODULE(newreno, &newreno_cc_algo); DECLARE_CC_MODULE(newreno, &newreno_cc_algo);
Context not available.