mirror of
https://github.com/torvalds/linux
synced 2024-09-16 00:58:07 +00:00
5832c4a77d
Historically, tunnel flags like TUNNEL_CSUM or TUNNEL_ERSPAN_OPT have been defined as __be16. Now all of those 16 bits are occupied and there's no more free space for new flags. It can't be simply switched to a bigger container with no adjustments to the values, since it's an explicit Endian storage, and on LE systems (__be16)0x0001 equals to (__be64)0x0001000000000000. We could probably define new 64-bit flags depending on the Endianness, i.e. (__be64)0x0001 on BE and (__be64)0x00010000... on LE, but that would introduce an Endianness dependency and spawn a ton of Sparse warnings. To mitigate them, all of those places which were adjusted with this change would be touched anyway, so why not define stuff properly if there's no choice. Define IP_TUNNEL_*_BIT counterparts as a bit number instead of the value already coded and a fistful of <16 <-> bitmap> converters and helpers. The two flags which have a different bit position are SIT_ISATAP_BIT and VTI_ISVTI_BIT, as they were defined not as __cpu_to_be16(), but as (__force __be16), i.e. had different positions on LE and BE. Now they both have strongly defined places. Change all __be16 fields which were used to store those flags, to IP_TUNNEL_DECLARE_FLAGS() -> DECLARE_BITMAP(__IP_TUNNEL_FLAG_NUM) -> unsigned long[1] for now, and replace all TUNNEL_* occurrences to their bitmap counterparts. Use the converters in the places which talk to the userspace, hardware (NFP) or other hosts (GRE header). The rest must explicitly use the new flags only. This must be done at once, otherwise there will be too many conversions throughout the code in the intermediate commits. Finally, disable the old __be16 flags for use in the kernel code (except for the two 'irregular' flags mentioned above), to prevent any accidental (mis)use of them. For the userspace, nothing is changed, only additions were made. Most noticeable bloat-o-meter difference (.text): vmlinux: 307/-1 (306) gre.ko: 62/0 (62) ip_gre.ko: 941/-217 (724) [*] ip_tunnel.ko: 390/-900 (-510) [**] ip_vti.ko: 138/0 (138) ip6_gre.ko: 534/-18 (516) [*] ip6_tunnel.ko: 118/-10 (108) [*] gre_flags_to_tnl_flags() grew, but still is inlined [**] ip_tunnel_find() got uninlined, hence such decrease The average code size increase in non-extreme case is 100-200 bytes per module, mostly due to sizeof(long) > sizeof(__be16), as %__IP_TUNNEL_FLAG_NUM is less than %BITS_PER_LONG and the compilers are able to expand the majority of bitmap_*() calls here into direct operations on scalars. Reviewed-by: Simon Horman <horms@kernel.org> Signed-off-by: Alexander Lobakin <aleksander.lobakin@intel.com> Signed-off-by: David S. Miller <davem@davemloft.net>
148 lines
3.8 KiB
C
148 lines
3.8 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef __LINUX_GRE_H
|
|
#define __LINUX_GRE_H
|
|
|
|
#include <linux/skbuff.h>
|
|
#include <net/ip_tunnels.h>
|
|
|
|
struct gre_base_hdr {
|
|
__be16 flags;
|
|
__be16 protocol;
|
|
} __packed;
|
|
|
|
struct gre_full_hdr {
|
|
struct gre_base_hdr fixed_header;
|
|
__be16 csum;
|
|
__be16 reserved1;
|
|
__be32 key;
|
|
__be32 seq;
|
|
} __packed;
|
|
#define GRE_HEADER_SECTION 4
|
|
|
|
#define GREPROTO_CISCO 0
|
|
#define GREPROTO_PPTP 1
|
|
#define GREPROTO_MAX 2
|
|
#define GRE_IP_PROTO_MAX 2
|
|
|
|
struct gre_protocol {
|
|
int (*handler)(struct sk_buff *skb);
|
|
void (*err_handler)(struct sk_buff *skb, u32 info);
|
|
};
|
|
|
|
int gre_add_protocol(const struct gre_protocol *proto, u8 version);
|
|
int gre_del_protocol(const struct gre_protocol *proto, u8 version);
|
|
|
|
struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
|
|
u8 name_assign_type);
|
|
int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
|
|
bool *csum_err, __be16 proto, int nhs);
|
|
|
|
static inline bool netif_is_gretap(const struct net_device *dev)
|
|
{
|
|
return dev->rtnl_link_ops &&
|
|
!strcmp(dev->rtnl_link_ops->kind, "gretap");
|
|
}
|
|
|
|
static inline bool netif_is_ip6gretap(const struct net_device *dev)
|
|
{
|
|
return dev->rtnl_link_ops &&
|
|
!strcmp(dev->rtnl_link_ops->kind, "ip6gretap");
|
|
}
|
|
|
|
static inline int gre_calc_hlen(const unsigned long *o_flags)
|
|
{
|
|
int addend = 4;
|
|
|
|
if (test_bit(IP_TUNNEL_CSUM_BIT, o_flags))
|
|
addend += 4;
|
|
if (test_bit(IP_TUNNEL_KEY_BIT, o_flags))
|
|
addend += 4;
|
|
if (test_bit(IP_TUNNEL_SEQ_BIT, o_flags))
|
|
addend += 4;
|
|
return addend;
|
|
}
|
|
|
|
static inline void gre_flags_to_tnl_flags(unsigned long *dst, __be16 flags)
|
|
{
|
|
IP_TUNNEL_DECLARE_FLAGS(res) = { };
|
|
|
|
__assign_bit(IP_TUNNEL_CSUM_BIT, res, flags & GRE_CSUM);
|
|
__assign_bit(IP_TUNNEL_ROUTING_BIT, res, flags & GRE_ROUTING);
|
|
__assign_bit(IP_TUNNEL_KEY_BIT, res, flags & GRE_KEY);
|
|
__assign_bit(IP_TUNNEL_SEQ_BIT, res, flags & GRE_SEQ);
|
|
__assign_bit(IP_TUNNEL_STRICT_BIT, res, flags & GRE_STRICT);
|
|
__assign_bit(IP_TUNNEL_REC_BIT, res, flags & GRE_REC);
|
|
__assign_bit(IP_TUNNEL_VERSION_BIT, res, flags & GRE_VERSION);
|
|
|
|
ip_tunnel_flags_copy(dst, res);
|
|
}
|
|
|
|
static inline __be16 gre_tnl_flags_to_gre_flags(const unsigned long *tflags)
|
|
{
|
|
__be16 flags = 0;
|
|
|
|
if (test_bit(IP_TUNNEL_CSUM_BIT, tflags))
|
|
flags |= GRE_CSUM;
|
|
if (test_bit(IP_TUNNEL_ROUTING_BIT, tflags))
|
|
flags |= GRE_ROUTING;
|
|
if (test_bit(IP_TUNNEL_KEY_BIT, tflags))
|
|
flags |= GRE_KEY;
|
|
if (test_bit(IP_TUNNEL_SEQ_BIT, tflags))
|
|
flags |= GRE_SEQ;
|
|
if (test_bit(IP_TUNNEL_STRICT_BIT, tflags))
|
|
flags |= GRE_STRICT;
|
|
if (test_bit(IP_TUNNEL_REC_BIT, tflags))
|
|
flags |= GRE_REC;
|
|
if (test_bit(IP_TUNNEL_VERSION_BIT, tflags))
|
|
flags |= GRE_VERSION;
|
|
|
|
return flags;
|
|
}
|
|
|
|
static inline void gre_build_header(struct sk_buff *skb, int hdr_len,
|
|
const unsigned long *flags, __be16 proto,
|
|
__be32 key, __be32 seq)
|
|
{
|
|
IP_TUNNEL_DECLARE_FLAGS(cond) = { };
|
|
struct gre_base_hdr *greh;
|
|
|
|
skb_push(skb, hdr_len);
|
|
|
|
skb_set_inner_protocol(skb, proto);
|
|
skb_reset_transport_header(skb);
|
|
greh = (struct gre_base_hdr *)skb->data;
|
|
greh->flags = gre_tnl_flags_to_gre_flags(flags);
|
|
greh->protocol = proto;
|
|
|
|
__set_bit(IP_TUNNEL_KEY_BIT, cond);
|
|
__set_bit(IP_TUNNEL_CSUM_BIT, cond);
|
|
__set_bit(IP_TUNNEL_SEQ_BIT, cond);
|
|
|
|
if (ip_tunnel_flags_intersect(flags, cond)) {
|
|
__be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
|
|
|
|
if (test_bit(IP_TUNNEL_SEQ_BIT, flags)) {
|
|
*ptr = seq;
|
|
ptr--;
|
|
}
|
|
if (test_bit(IP_TUNNEL_KEY_BIT, flags)) {
|
|
*ptr = key;
|
|
ptr--;
|
|
}
|
|
if (test_bit(IP_TUNNEL_CSUM_BIT, flags) &&
|
|
!(skb_shinfo(skb)->gso_type &
|
|
(SKB_GSO_GRE | SKB_GSO_GRE_CSUM))) {
|
|
*ptr = 0;
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL) {
|
|
*(__sum16 *)ptr = csum_fold(lco_csum(skb));
|
|
} else {
|
|
skb->ip_summed = CHECKSUM_PARTIAL;
|
|
skb->csum_start = skb_transport_header(skb) - skb->head;
|
|
skb->csum_offset = sizeof(*greh);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|