mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-07 05:46:40 +07:00
eccc1bb8d4
Linux tunnels were written before RFC6040 and therefore never implemented the corner case of ECN getting set in the outer header and the inner header not being ready for it. Section 4.2. Default Tunnel Egress Behaviour. o If the inner ECN field is Not-ECT, the decapsulator MUST NOT propagate any other ECN codepoint onwards. This is because the inner Not-ECT marking is set by transports that rely on dropped packets as an indication of congestion and would not understand or respond to any other ECN codepoint [RFC4774]. Specifically: * If the inner ECN field is Not-ECT and the outer ECN field is CE, the decapsulator MUST drop the packet. * If the inner ECN field is Not-ECT and the outer ECN field is Not-ECT, ECT(0), or ECT(1), the decapsulator MUST forward the outgoing packet with the ECN field cleared to Not-ECT. This patch moves the ECN decap logic out of the individual tunnels into a common place. It also adds logging to allow detecting broken systems that set ECN bits incorrectly when tunneling (or an intermediate router might be changing the header). Overloads rx_frame_error to keep track of ECN related error. Thanks to Chris Wright who caught this while reviewing the new VXLAN tunnel. This code was tested by injecting faulty logic in other end GRE to send incorrectly encapsulated packets. Signed-off-by: Stephen Hemminger <shemminger@vyatta.com> Signed-off-by: David S. Miller <davem@davemloft.net>
225 lines
5.5 KiB
C
225 lines
5.5 KiB
C
#ifndef _INET_ECN_H_
|
|
#define _INET_ECN_H_
|
|
|
|
#include <linux/ip.h>
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <net/inet_sock.h>
|
|
#include <net/dsfield.h>
|
|
|
|
enum {
|
|
INET_ECN_NOT_ECT = 0,
|
|
INET_ECN_ECT_1 = 1,
|
|
INET_ECN_ECT_0 = 2,
|
|
INET_ECN_CE = 3,
|
|
INET_ECN_MASK = 3,
|
|
};
|
|
|
|
extern int sysctl_tunnel_ecn_log;
|
|
|
|
static inline int INET_ECN_is_ce(__u8 dsfield)
|
|
{
|
|
return (dsfield & INET_ECN_MASK) == INET_ECN_CE;
|
|
}
|
|
|
|
static inline int INET_ECN_is_not_ect(__u8 dsfield)
|
|
{
|
|
return (dsfield & INET_ECN_MASK) == INET_ECN_NOT_ECT;
|
|
}
|
|
|
|
static inline int INET_ECN_is_capable(__u8 dsfield)
|
|
{
|
|
return dsfield & INET_ECN_ECT_0;
|
|
}
|
|
|
|
/*
|
|
* RFC 3168 9.1.1
|
|
* The full-functionality option for ECN encapsulation is to copy the
|
|
* ECN codepoint of the inside header to the outside header on
|
|
* encapsulation if the inside header is not-ECT or ECT, and to set the
|
|
* ECN codepoint of the outside header to ECT(0) if the ECN codepoint of
|
|
* the inside header is CE.
|
|
*/
|
|
static inline __u8 INET_ECN_encapsulate(__u8 outer, __u8 inner)
|
|
{
|
|
outer &= ~INET_ECN_MASK;
|
|
outer |= !INET_ECN_is_ce(inner) ? (inner & INET_ECN_MASK) :
|
|
INET_ECN_ECT_0;
|
|
return outer;
|
|
}
|
|
|
|
static inline void INET_ECN_xmit(struct sock *sk)
|
|
{
|
|
inet_sk(sk)->tos |= INET_ECN_ECT_0;
|
|
if (inet6_sk(sk) != NULL)
|
|
inet6_sk(sk)->tclass |= INET_ECN_ECT_0;
|
|
}
|
|
|
|
static inline void INET_ECN_dontxmit(struct sock *sk)
|
|
{
|
|
inet_sk(sk)->tos &= ~INET_ECN_MASK;
|
|
if (inet6_sk(sk) != NULL)
|
|
inet6_sk(sk)->tclass &= ~INET_ECN_MASK;
|
|
}
|
|
|
|
#define IP6_ECN_flow_init(label) do { \
|
|
(label) &= ~htonl(INET_ECN_MASK << 20); \
|
|
} while (0)
|
|
|
|
#define IP6_ECN_flow_xmit(sk, label) do { \
|
|
if (INET_ECN_is_capable(inet6_sk(sk)->tclass)) \
|
|
(label) |= htonl(INET_ECN_ECT_0 << 20); \
|
|
} while (0)
|
|
|
|
static inline int IP_ECN_set_ce(struct iphdr *iph)
|
|
{
|
|
u32 check = (__force u32)iph->check;
|
|
u32 ecn = (iph->tos + 1) & INET_ECN_MASK;
|
|
|
|
/*
|
|
* After the last operation we have (in binary):
|
|
* INET_ECN_NOT_ECT => 01
|
|
* INET_ECN_ECT_1 => 10
|
|
* INET_ECN_ECT_0 => 11
|
|
* INET_ECN_CE => 00
|
|
*/
|
|
if (!(ecn & 2))
|
|
return !ecn;
|
|
|
|
/*
|
|
* The following gives us:
|
|
* INET_ECN_ECT_1 => check += htons(0xFFFD)
|
|
* INET_ECN_ECT_0 => check += htons(0xFFFE)
|
|
*/
|
|
check += (__force u16)htons(0xFFFB) + (__force u16)htons(ecn);
|
|
|
|
iph->check = (__force __sum16)(check + (check>=0xFFFF));
|
|
iph->tos |= INET_ECN_CE;
|
|
return 1;
|
|
}
|
|
|
|
static inline void IP_ECN_clear(struct iphdr *iph)
|
|
{
|
|
iph->tos &= ~INET_ECN_MASK;
|
|
}
|
|
|
|
static inline void ipv4_copy_dscp(unsigned int dscp, struct iphdr *inner)
|
|
{
|
|
dscp &= ~INET_ECN_MASK;
|
|
ipv4_change_dsfield(inner, INET_ECN_MASK, dscp);
|
|
}
|
|
|
|
struct ipv6hdr;
|
|
|
|
static inline int IP6_ECN_set_ce(struct ipv6hdr *iph)
|
|
{
|
|
if (INET_ECN_is_not_ect(ipv6_get_dsfield(iph)))
|
|
return 0;
|
|
*(__be32*)iph |= htonl(INET_ECN_CE << 20);
|
|
return 1;
|
|
}
|
|
|
|
static inline void IP6_ECN_clear(struct ipv6hdr *iph)
|
|
{
|
|
*(__be32*)iph &= ~htonl(INET_ECN_MASK << 20);
|
|
}
|
|
|
|
static inline void ipv6_copy_dscp(unsigned int dscp, struct ipv6hdr *inner)
|
|
{
|
|
dscp &= ~INET_ECN_MASK;
|
|
ipv6_change_dsfield(inner, INET_ECN_MASK, dscp);
|
|
}
|
|
|
|
static inline int INET_ECN_set_ce(struct sk_buff *skb)
|
|
{
|
|
switch (skb->protocol) {
|
|
case cpu_to_be16(ETH_P_IP):
|
|
if (skb->network_header + sizeof(struct iphdr) <= skb->tail)
|
|
return IP_ECN_set_ce(ip_hdr(skb));
|
|
break;
|
|
|
|
case cpu_to_be16(ETH_P_IPV6):
|
|
if (skb->network_header + sizeof(struct ipv6hdr) <= skb->tail)
|
|
return IP6_ECN_set_ce(ipv6_hdr(skb));
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* RFC 6080 4.2
|
|
* To decapsulate the inner header at the tunnel egress, a compliant
|
|
* tunnel egress MUST set the outgoing ECN field to the codepoint at the
|
|
* intersection of the appropriate arriving inner header (row) and outer
|
|
* header (column) in Figure 4
|
|
*
|
|
* +---------+------------------------------------------------+
|
|
* |Arriving | Arriving Outer Header |
|
|
* | Inner +---------+------------+------------+------------+
|
|
* | Header | Not-ECT | ECT(0) | ECT(1) | CE |
|
|
* +---------+---------+------------+------------+------------+
|
|
* | Not-ECT | Not-ECT |Not-ECT(!!!)|Not-ECT(!!!)| <drop>(!!!)|
|
|
* | ECT(0) | ECT(0) | ECT(0) | ECT(1) | CE |
|
|
* | ECT(1) | ECT(1) | ECT(1) (!) | ECT(1) | CE |
|
|
* | CE | CE | CE | CE(!!!)| CE |
|
|
* +---------+---------+------------+------------+------------+
|
|
*
|
|
* Figure 4: New IP in IP Decapsulation Behaviour
|
|
*
|
|
* returns 0 on success
|
|
* 1 if something is broken and should be logged (!!! above)
|
|
* 2 if packet should be dropped
|
|
*/
|
|
static inline int INET_ECN_decapsulate(struct sk_buff *skb,
|
|
__u8 outer, __u8 inner)
|
|
{
|
|
if (INET_ECN_is_not_ect(inner)) {
|
|
switch (outer & INET_ECN_MASK) {
|
|
case INET_ECN_NOT_ECT:
|
|
return 0;
|
|
case INET_ECN_ECT_0:
|
|
case INET_ECN_ECT_1:
|
|
return 1;
|
|
case INET_ECN_CE:
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
if (INET_ECN_is_ce(outer))
|
|
INET_ECN_set_ce(skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int IP_ECN_decapsulate(const struct iphdr *oiph,
|
|
struct sk_buff *skb)
|
|
{
|
|
__u8 inner;
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
inner = ip_hdr(skb)->tos;
|
|
else if (skb->protocol == htons(ETH_P_IPV6))
|
|
inner = ipv6_get_dsfield(ipv6_hdr(skb));
|
|
else
|
|
return 0;
|
|
|
|
return INET_ECN_decapsulate(skb, oiph->tos, inner);
|
|
}
|
|
|
|
static inline int IP6_ECN_decapsulate(const struct ipv6hdr *oipv6h,
|
|
struct sk_buff *skb)
|
|
{
|
|
__u8 inner;
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
inner = ip_hdr(skb)->tos;
|
|
else if (skb->protocol == htons(ETH_P_IPV6))
|
|
inner = ipv6_get_dsfield(ipv6_hdr(skb));
|
|
else
|
|
return 0;
|
|
|
|
return INET_ECN_decapsulate(skb, ipv6_get_dsfield(oipv6h), inner);
|
|
}
|
|
#endif
|