mirror of
https://github.com/torvalds/linux.git
synced 2025-11-04 10:40:15 +02:00
3c202d14a9
Convert the final two users of prandom_u32_max() that slipped in during 6.2-rc1 to use get_random_u32_below(). Then, with no more users left, we can finally remove the deprecated function. Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
109 lines
3.7 KiB
C
109 lines
3.7 KiB
C
/* Protective Load Balancing (PLB)
|
|
*
|
|
* PLB was designed to reduce link load imbalance across datacenter
|
|
* switches. PLB is a host-based optimization; it leverages congestion
|
|
* signals from the transport layer to randomly change the path of the
|
|
* connection experiencing sustained congestion. PLB prefers to repath
|
|
* after idle periods to minimize packet reordering. It repaths by
|
|
* changing the IPv6 Flow Label on the packets of a connection, which
|
|
* datacenter switches include as part of ECMP/WCMP hashing.
|
|
*
|
|
* PLB is described in detail in:
|
|
*
|
|
* Mubashir Adnan Qureshi, Yuchung Cheng, Qianwen Yin, Qiaobin Fu,
|
|
* Gautam Kumar, Masoud Moshref, Junhua Yan, Van Jacobson,
|
|
* David Wetherall,Abdul Kabbani:
|
|
* "PLB: Congestion Signals are Simple and Effective for
|
|
* Network Load Balancing"
|
|
* In ACM SIGCOMM 2022, Amsterdam Netherlands.
|
|
*
|
|
*/
|
|
|
|
#include <net/tcp.h>
|
|
|
|
/* Called once per round-trip to update PLB state for a connection. */
|
|
void tcp_plb_update_state(const struct sock *sk, struct tcp_plb_state *plb,
|
|
const int cong_ratio)
|
|
{
|
|
struct net *net = sock_net(sk);
|
|
|
|
if (!READ_ONCE(net->ipv4.sysctl_tcp_plb_enabled))
|
|
return;
|
|
|
|
if (cong_ratio >= 0) {
|
|
if (cong_ratio < READ_ONCE(net->ipv4.sysctl_tcp_plb_cong_thresh))
|
|
plb->consec_cong_rounds = 0;
|
|
else if (plb->consec_cong_rounds <
|
|
READ_ONCE(net->ipv4.sysctl_tcp_plb_rehash_rounds))
|
|
plb->consec_cong_rounds++;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(tcp_plb_update_state);
|
|
|
|
/* Check whether recent congestion has been persistent enough to warrant
|
|
* a load balancing decision that switches the connection to another path.
|
|
*/
|
|
void tcp_plb_check_rehash(struct sock *sk, struct tcp_plb_state *plb)
|
|
{
|
|
struct net *net = sock_net(sk);
|
|
u32 max_suspend;
|
|
bool forced_rehash = false, idle_rehash = false;
|
|
|
|
if (!READ_ONCE(net->ipv4.sysctl_tcp_plb_enabled))
|
|
return;
|
|
|
|
forced_rehash = plb->consec_cong_rounds >=
|
|
READ_ONCE(net->ipv4.sysctl_tcp_plb_rehash_rounds);
|
|
/* If sender goes idle then we check whether to rehash. */
|
|
idle_rehash = READ_ONCE(net->ipv4.sysctl_tcp_plb_idle_rehash_rounds) &&
|
|
!tcp_sk(sk)->packets_out &&
|
|
plb->consec_cong_rounds >=
|
|
READ_ONCE(net->ipv4.sysctl_tcp_plb_idle_rehash_rounds);
|
|
|
|
if (!forced_rehash && !idle_rehash)
|
|
return;
|
|
|
|
/* Note that tcp_jiffies32 can wrap; we detect wraps by checking for
|
|
* cases where the max suspension end is before the actual suspension
|
|
* end. We clear pause_until to 0 to indicate there is no recent
|
|
* RTO event that constrains PLB rehashing.
|
|
*/
|
|
max_suspend = 2 * READ_ONCE(net->ipv4.sysctl_tcp_plb_suspend_rto_sec) * HZ;
|
|
if (plb->pause_until &&
|
|
(!before(tcp_jiffies32, plb->pause_until) ||
|
|
before(tcp_jiffies32 + max_suspend, plb->pause_until)))
|
|
plb->pause_until = 0;
|
|
|
|
if (plb->pause_until)
|
|
return;
|
|
|
|
sk_rethink_txhash(sk);
|
|
plb->consec_cong_rounds = 0;
|
|
tcp_sk(sk)->plb_rehash++;
|
|
NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPLBREHASH);
|
|
}
|
|
EXPORT_SYMBOL_GPL(tcp_plb_check_rehash);
|
|
|
|
/* Upon RTO, disallow load balancing for a while, to avoid having load
|
|
* balancing decisions switch traffic to a black-holed path that was
|
|
* previously avoided with a sk_rethink_txhash() call at RTO time.
|
|
*/
|
|
void tcp_plb_update_state_upon_rto(struct sock *sk, struct tcp_plb_state *plb)
|
|
{
|
|
struct net *net = sock_net(sk);
|
|
u32 pause;
|
|
|
|
if (!READ_ONCE(net->ipv4.sysctl_tcp_plb_enabled))
|
|
return;
|
|
|
|
pause = READ_ONCE(net->ipv4.sysctl_tcp_plb_suspend_rto_sec) * HZ;
|
|
pause += get_random_u32_below(pause);
|
|
plb->pause_until = tcp_jiffies32 + pause;
|
|
|
|
/* Reset PLB state upon RTO, since an RTO causes a sk_rethink_txhash() call
|
|
* that may switch this connection to a path with completely different
|
|
* congestion characteristics.
|
|
*/
|
|
plb->consec_cong_rounds = 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(tcp_plb_update_state_upon_rto);
|