flow_dissector: Dissect UDP encapsulation protocols
Subsystems (11)
v3 cover flow_dissector: Dissect UDP encapsulation protocols
Add support in flow_dissector for dissecting into UDP encapsulations like VXLAN. __skb_flow_dissect_udp is called for IPPROTO_UDP. The flag FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS enables parsing of UDP encapsulations. If the flag is set when parsing a UDP packet then a socket lookup is performed. The offset of the base network header, either an IPv4 or IPv6 header, is tracked and passed to __skb_flow_dissect_udp so that it can perform the socket lookup. If a socket is found and it's for a UDP encapsulation (encap_type is set in the UDP socket) then a switch is performed on the encap_type value (cases are UDP_ENCAP_* values)
Changes in the patch set:
- Unconstantify struct net argument in flowdis functions so we can call UDP socket lookup functions
- Dissect ETH_P_TEB in main flow dissector loop, move ETH_P_TEB check out of __skb_flow_dissect_gre and process it in main loop
- Add UDP_ENCAP constants for tipc, fou, gue, sctp, rxe, pfcp, wireguard, bareudp, vxlan, vxlan_gpe, geneve, and amt
- For the various UDP encapsulation protocols, Instead of just setting UDP tunnel encap type to 1, set it to the corresponding UDP_ENCAP constant. This allows identify the encapsulation protocol for a UDP socket by the encap_type
- Add function __skb_flow_dissect_udp in flow_dissector and call it for UDP packets. If a UDP encapsulation is present then the function returns either FLOW_DISSECT_RET_PROTO_AGAIN or FLOW_DISSECT_RET_IPPROTO_AGAIN
- Add flag FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS that indicates UDP encapsulations should be dissected
- Add __skb_flow_dissect_vxlan which is called when encap_type is UDP_ENCAP_VXLAN or UDP_ENCAP_VXLAN_GPE. Dissect VXLAN and return a next protocol and offset
- Add __skb_flow_dissect_fou which is called when encap_type is UDP_ENCAP_FOU. Dissect FOU and return a next protocol and offset
- Add support for ESP, L2TP, and SCTP in UDP in __skb_flow_dissect_udp. All we need to do is return FLOW_DISSECT_RET_IPPROTO_AGAIN and the corresponding IP protocol number
- Add __skb_flow_dissect_geneve which is called when encap_type is UDP_ENCAP_GENEVE. Dissect geneve and return a next protocol and offset
- Add __skb_flow_dissect_gue which is called when encap_type is UDP_ENCAP_GUE. Dissect gue and return a next protocol and offset
- Add __skb_flow_dissect_gtp which is called when encap_type is UDP_ENCAP_GTP. Dissect gtp and return a next protocol and offset
Tested: Verified fou, gue, vxlan, and geneve are properly dissected for IPv4 and IPv6 cases. This includes testing ETH_P_TEB case
v2:
- Add #if IS_ENABLED(CONFIG_IPV6) around IPv6 cases when dissecting UDP. Also, c all ipv6_bpf_stub->udp6_lib_lookup instead of udp6_lib_lookup directly since udp6_lib_lookup in the IPv6 module
- Drop patch to unconstantify struct net argument in flowdis functions, edumazet added const to ne argument in UDP socket lookup functions
- As support in flowdis ipproto switch for no-next-hdr. Just exit flowdis on good result when this is seen
- Merge patches that move TEB processing out of GRE and moved into main protocol switch
- Rename bpoff in UDP flow dissector functions to be base_nhoff for clarity
- Parse GTPv1 extension headers (part of this is moving gtp_parse_exthdrs to a header file
- Exit flowdis on good result if NPDU or SEQ GTPv1 flags are set
v3:
- Add udp6_lib_lookup to ipv6_stubs
- Call ipv6_stubs->udp6_lib_lookup instead of ipv6_bpf_stubs variant
- Use _HF_ variants of VLXAN flags (those in network byte order)
- Use encap type from socket to determine if a packet is VXLAN-GPE instead of getting this from flags
- Protect both IPv4 and IPv6 cases with #ifdef CONFIG_INET
- Added a comment why UDP_ENCAP constants are in uapi
- Added a comment in ETH_P_TEB case why NET_IP_ALIGN is needed
- Add a check in __skb_flow_dissect_udp that the netns for the skb device is the same as the caller's netns, and also only dissect UDP is we haven't yet encountered any encapsulation. The goal is to ensure that the socket lookup is being done in the right netns. Encapsulations may push packets into different name spaces, so this scheme is restricting UDP dieesction to cases where there are not name spaces or at least the original name space. This should capture the majority of use cases for UDP encaps, if we do encounter a UDP encapsulation within a different namespace then the only effect is we don't attempt UDP dissection
Tom Herbert (13):
ipv6: Add udp6_lib_lookup to IPv6 stubs
flow_dissector: Parse ETH_P_TEB and move out of GRE
udp_encaps: Add new UDP_ENCAP constants
udp_encaps: Set proper UDP_ENCAP types in tunnel setup
flow_dissector: UDP encap infrastructure
flow_dissector: Parse vxlan in UDP
flow_dissector: Parse foo-over-udp (FOU)
flow_dissector: Parse ESP, L2TP, and SCTP in UDP
flow_dissector: Parse Geneve in UDP
flow_dissector: Parse GUE in UDP
gtp: Move gtp_parse_exthdrs into net/gtp.h
flow_dissector: Parse gtp in UDP
flow_dissector: Add case in ipproto switch for NEXTHDR_NONE
drivers/infiniband/sw/rxe/rxe_net.c | 2 +- drivers/net/amt.c | 2 +- drivers/net/bareudp.c | 2 +- drivers/net/geneve.c | 2 +- drivers/net/gtp.c | 37 --- drivers/net/pfcp.c | 2 +- drivers/net/vxlan/vxlan_core.c | 3 +- drivers/net/wireguard/socket.c | 2 +- include/net/flow_dissector.h | 1 + include/net/fou.h | 16 + include/net/gtp.h | 38 +++ include/net/ipv6_stubs.h | 5 + include/uapi/linux/udp.h | 19 +- net/core/flow_dissector.c | 468 ++++++++++++++++++++++++++-- net/ipv4/fou_core.c | 19 +- net/ipv6/af_inet6.c | 1 + net/sctp/protocol.c | 2 +- net/tipc/udp_media.c | 2 +- 18 files changed, 533 insertions(+), 90 deletions(-)
Signature · 1 line
2.34.1
PATCH v3 1/13 ipv6: Add udp6_lib_lookup to IPv6 stubs
Want to do a UDP socket lookup from flow dissector so create a stub for udp6_lib_lookup
--- include/net/ipv6_stubs.h | 5 +++++ net/ipv6/af_inet6.c | 1 + 2 files changed, 6 insertions(+)
include/net/ipv6_stubs.h +5 -0
@@ -75,6 +75,11 @@ struct ipv6_stub { struct net_device *dev);int (*ip6_xmit)(const struct sock *sk,struct sk_buff *skb,struct flowi6 *fl6,__u32 mark,struct ipv6_txoptions *opt,int tclass,u32 priority); +struct sock *(*udp6_lib_lookup)(const struct net *net, +const struct in6_addr *saddr,__be16 sport, +const struct in6_addr *daddr,__be16 dport, +int dif,int sdif,struct udp_table *tbl, +struct sk_buff *skb); };extern const struct ipv6_stub *ipv6_stub__read_mostly ;
net/ipv6/af_inet6.c +1 -0
@@ -1061,6 +1061,7 @@ static const struct ipv6_stub ipv6_stub_impl = { .ipv6_fragment = ip6_fragment, .ipv6_dev_find = ipv6_dev_find, .ip6_xmit = ip6_xmit, + .udp6_lib_lookup = __udp6_lib_lookup, };static const struct ipv6_bpf_stub ipv6_bpf_stub_impl = {
Signature · 1 line
2.34.1
PATCH v3 2/13 flow_dissector: Parse ETH_P_TEB and move out of GRE
In reply to Tom HerbertETH_P_TEB (Trans Ether Bridging) is the EtherType to carry a plain Etherent frame. Add case in skb_flow_dissect to parse packets of this type
If the GRE protocol is ETH_P_TEB then just process that as any another EtherType since it's now supported in the main loop
--- net/core/flow_dissector.c | 71 +++++++++++++++++++++++++-------------- 1 file changed, 45 insertions(+), 26 deletions(-)
net/core/flow_dissector.c +45 -26
@@ -654,7 +654,7 @@ __skb_flow_dissect_gre(const struct sk_buff *skb,struct flow_dissector_key_control *key_control, struct flow_dissector *flow_dissector, void *target_container, const void *data, - __be16 *p_proto, int *p_nhoff, int *p_hlen, + __be16 *p_proto, int *p_nhoff, int hlen, unsigned int flags) { struct flow_dissector_key_keyid *key_keyid;
@@ -663,7 +663,7 @@ __skb_flow_dissect_gre(const struct sk_buff *skb,u16 gre_ver; hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), - data, *p_hlen, &_hdr); + data, hlen, &_hdr);if (!hdr)return FLOW_DISSECT_RET_OUT_BAD ;
@@ -695,7 +695,7 @@ __skb_flow_dissect_gre(const struct sk_buff *skb, keyid =__skb_header_pointer (skb, *p_nhoff + offset,sizeof (_keyid), - data, *p_hlen, &_keyid); + data, hlen, &_keyid);if (!keyid)return FLOW_DISSECT_RET_OUT_BAD ;
@@ -715,27 +715,11 @@ __skb_flow_dissect_gre(const struct sk_buff *skb,if (hdr->flags &GRE_SEQ ) offset += sizeof_field(struct pptp_gre_header, seq); -if (gre_ver ==0 ) { -if (*p_proto ==htons (ETH_P_TEB )) { -const struct ethhdr *eth; -struct ethhdr _eth; - - eth =__skb_header_pointer (skb, *p_nhoff + offset, -sizeof (_eth), - data, *p_hlen, &_eth); -if (!eth) -return FLOW_DISSECT_RET_OUT_BAD ; - *p_proto = eth->h_proto; - offset +=sizeof (*eth); - -/* Cap headers that we access via pointers at the -* end of the Ethernet header as our maximum alignment -* at that point is only 2 bytes. -*/ -if (NET_IP_ALIGN ) - *p_hlen = *p_nhoff + offset; - } - }else {/* version 1, must be PPTP */ +/* For GRE version 0 p_proto is already correctly set (including if +* it is ETH_P_TEB) +*/ + +if (gre_ver ==1 ) {/* Version 1 is PPP */ u8 _ppp_hdr[PPP_HDRLEN ];u8 *ppp_hdr;
@@ -744,7 +728,7 @@ __skb_flow_dissect_gre(const struct sk_buff *skb, ppp_hdr =__skb_header_pointer (skb, *p_nhoff + offset,sizeof (_ppp_hdr), - data, *p_hlen, _ppp_hdr); + data, hlen, _ppp_hdr);if (!ppp_hdr)return FLOW_DISSECT_RET_OUT_BAD ;
@@ -1284,6 +1268,41 @@ bool __skb_flow_dissect(const struct net *net,break ; } +case htons (ETH_P_TEB ): { +const struct ethhdr *eth; +struct ethhdr _eth; + + eth =__skb_header_pointer (skb, nhoff,sizeof (_eth), + data, hlen, &_eth); +if (!eth) + goto out_bad; + + proto = eth->h_proto; + nhoff +=sizeof (*eth); + +/* Cap headers that we access via pointers at the end of the +* Ethernet header as our maximum alignment at that point is +* only 2 bytes. +* +* For the real Ethernet header the receive skbuf is offset by +* two so that device places the packet such that the Ethernet +* payload, i.e. IP header, is aligned to four bytes (14+2=16 +* which will be offset of IP header). When a packet contains +* an encapsulated Ethernet header, the offset of the header is +* aligned to four bytes which means the payload of that +* Ethernet header, i.e. an encapsulated IP header, is not four +* byte aligned and neither are any subsequent headers (TCP, +* UDP, etc.). On some architectures, performing unaligned +* loads is expensive compared to aligned loads, so hlen is +* being capped here to avoid having flow dissector do unaligned +* loads on unaligned headers after the Ethernet header. +*/ +if (NET_IP_ALIGN ) + hlen = nhoff; + + fdret =FLOW_DISSECT_RET_PROTO_AGAIN ; +break ; + }case htons (ETH_P_8021AD ):case htons (ETH_P_8021Q ): {const struct vlan_hdr *vlan =NULL ;
@@ -1531,7 +1550,7 @@ bool __skb_flow_dissect(const struct net *net, fdret =__skb_flow_dissect_gre (skb, key_control, flow_dissector, target_container, data, - &proto, &nhoff, &hlen, flags); + &proto, &nhoff, hlen, flags);break ;case NEXTHDR_HOP :
Signature · 1 line
2.34.1
PATCH v3 3/13 udp_encaps: Add new UDP_ENCAP constants
In reply to Tom HerbertAdd constants for various UDP encapsulations that are supported
--- include/uapi/linux/udp.h | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
include/uapi/linux/udp.h +18 -1
@@ -35,7 +35,12 @@ struct udphdr {#define UDP_SEGMENT 103/* Set GSO segmentation size */ #define UDP_GRO 104/* This socket can receive UDP GRO packets */ -/* UDP encapsulation types */ +/* UDP encapsulation types +* +* Note that these are defined in UAPI since we may need to use them externally, +* for instance by eBPF +*/ +#define UDP_ENCAP_NONE 0#define UDP_ENCAP_ESPINUDP_NON_IKE 1/* unused draft-ietf-ipsec-nat-t-ike-00/01 */ #define UDP_ENCAP_ESPINUDP 2/* draft-ietf-ipsec-udp-encaps-06 */ #define UDP_ENCAP_L2TPINUDP 3/* rfc2661 */
@@ -43,5 +48,17 @@ struct udphdr {#define UDP_ENCAP_GTP1U 5/* 3GPP TS 29.060 */ #define UDP_ENCAP_RXRPC 6#define TCP_ENCAP_ESPINTCP 7/* Yikes, this is really xfrm encap types. */ +#define UDP_ENCAP_TIPC 8 +#define UDP_ENCAP_FOU 9 +#define UDP_ENCAP_GUE 10 +#define UDP_ENCAP_SCTP 11 +#define UDP_ENCAP_RXE 12 +#define UDP_ENCAP_PFCP 13 +#define UDP_ENCAP_WIREGUARD 14 +#define UDP_ENCAP_BAREUDP 15 +#define UDP_ENCAP_VXLAN 16 +#define UDP_ENCAP_VXLAN_GPE 17 +#define UDP_ENCAP_GENEVE 18 +#define UDP_ENCAP_AMT 19#endif /* _UAPI_LINUX_UDP_H */
Signature · 1 line
2.34.1
PATCH v3 4/13 udp_encaps: Set proper UDP_ENCAP types in tunnel setup
In reply to Tom HerbertInstead of just setting UDP tunnel config encap_type to 1, use the appropriate constat for the tunnel type. This value can be used to determine the encapsulated protocol in UDP by looking at the socket
--- drivers/infiniband/sw/rxe/rxe_net.c | 2 +- drivers/net/amt.c | 2 +- drivers/net/bareudp.c | 2 +- drivers/net/geneve.c | 2 +- drivers/net/pfcp.c | 2 +- drivers/net/vxlan/vxlan_core.c | 3 ++- drivers/net/wireguard/socket.c | 2 +- net/ipv4/fou_core.c | 3 ++- net/sctp/protocol.c | 2 +- net/tipc/udp_media.c | 2 +- 10 files changed, 12 insertions(+), 10 deletions(-)
drivers/infiniband/sw/rxe/rxe_net.c +1 -1
@@ -193,7 +193,7 @@ static struct socket *rxe_setup_udp_tunnel(struct net *net, __be16 port,if (err <0 )return ERR_PTR (err); - tnl_cfg.encap_type =1 ; + tnl_cfg.encap_type =UDP_ENCAP_RXE ; tnl_cfg.encap_rcv = rxe_udp_encap_recv;/* Setup UDP tunnel */
drivers/net/amt.c +1 -1
@@ -2970,7 +2970,7 @@ static int amt_socket_create(struct amt_dev *amt)/* Mark socket as an encapsulation socket */ memset (&tunnel_cfg,0 ,sizeof (tunnel_cfg)); tunnel_cfg.sk_user_data = amt; - tunnel_cfg.encap_type =1 ; + tunnel_cfg.encap_type =UDP_ENCAP_AMT ; tunnel_cfg.encap_rcv = amt_rcv; tunnel_cfg.encap_err_lookup = amt_err_lookup; tunnel_cfg.encap_destroy =NULL ;
drivers/net/bareudp.c +1 -1
@@ -248,7 +248,7 @@ static int bareudp_socket_create(struct bareudp_dev *bareudp, __be16 port)/* Mark socket as an encapsulation socket */ memset (&tunnel_cfg,0 ,sizeof (tunnel_cfg)); tunnel_cfg.sk_user_data = bareudp; - tunnel_cfg.encap_type =1 ; + tunnel_cfg.encap_type =UDP_ENCAP_BAREUDP ; tunnel_cfg.encap_rcv = bareudp_udp_encap_recv; tunnel_cfg.encap_err_lookup = bareudp_err_lookup; tunnel_cfg.encap_destroy =NULL ;
drivers/net/geneve.c +1 -1
@@ -611,7 +611,7 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,/* Mark socket as an encapsulation socket */ memset (&tunnel_cfg,0 ,sizeof (tunnel_cfg)); tunnel_cfg.sk_user_data = gs; - tunnel_cfg.encap_type =1 ; + tunnel_cfg.encap_type =UDP_ENCAP_GENEVE ; tunnel_cfg.gro_receive = geneve_gro_receive; tunnel_cfg.gro_complete = geneve_gro_complete; tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
drivers/net/pfcp.c +1 -1
@@ -170,7 +170,7 @@ static struct socket *pfcp_create_sock(struct pfcp_dev *pfcp) tuncfg.sk_user_data = pfcp; tuncfg.encap_rcv = pfcp_encap_recv; - tuncfg.encap_type =1 ; + tuncfg.encap_type =UDP_ENCAP_PFCP ;setup_udp_tunnel_sock (net, sock, &tuncfg);
drivers/net/vxlan/vxlan_core.c +2 -1
@@ -3572,7 +3572,8 @@ static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,/* Mark socket as an encapsulation socket. */ memset (&tunnel_cfg,0 ,sizeof (tunnel_cfg)); tunnel_cfg.sk_user_data = vs; - tunnel_cfg.encap_type =1 ; + tunnel_cfg.encap_type = vs->flags &VXLAN_F_GPE ? +UDP_ENCAP_VXLAN_GPE :UDP_ENCAP_VXLAN ; tunnel_cfg.encap_rcv = vxlan_rcv; tunnel_cfg.encap_err_lookup = vxlan_err_lookup; tunnel_cfg.encap_destroy =NULL ;
drivers/net/wireguard/socket.c +1 -1
@@ -352,7 +352,7 @@ int wg_socket_init(struct wg_device *wg, u16 port)int ret;struct udp_tunnel_sock_cfg cfg = { .sk_user_data = wg, - .encap_type =1 , + .encap_type =UDP_ENCAP_WIREGUARD , .encap_rcv = wg_receive };struct socket *new4 =NULL , *new6 =NULL ;
net/ipv4/fou_core.c +2 -1
@@ -578,19 +578,20 @@ static int fou_create(struct net *net, struct fou_cfg *cfg, fou->sock = sock;memset (&tunnel_cfg,0 ,sizeof (tunnel_cfg)); - tunnel_cfg.encap_type =1 ; tunnel_cfg.sk_user_data = fou; tunnel_cfg.encap_destroy =NULL ;/* Initial for fou type */ switch (cfg->type) {case FOU_ENCAP_DIRECT : + tunnel_cfg.encap_type =UDP_ENCAP_FOU ; tunnel_cfg.encap_rcv = fou_udp_recv; tunnel_cfg.gro_receive = fou_gro_receive; tunnel_cfg.gro_complete = fou_gro_complete; fou->protocol = cfg->protocol;break ;case FOU_ENCAP_GUE : + tunnel_cfg.encap_type =UDP_ENCAP_GUE ; tunnel_cfg.encap_rcv = gue_udp_recv; tunnel_cfg.gro_receive = gue_gro_receive; tunnel_cfg.gro_complete = gue_gro_complete;
net/sctp/protocol.c +1 -1
@@ -876,7 +876,7 @@ int sctp_udp_sock_start(struct net *net)return err; } - tuncfg.encap_type =1 ; + tuncfg.encap_type =UDP_ENCAP_SCTP ; tuncfg.encap_rcv = sctp_udp_rcv; tuncfg.encap_err_lookup = sctp_udp_v4_err;setup_udp_tunnel_sock (net, sock, &tuncfg);
net/tipc/udp_media.c +1 -1
@@ -771,7 +771,7 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,if (err) goto err; tuncfg.sk_user_data = ub; - tuncfg.encap_type =1 ; + tuncfg.encap_type =UDP_ENCAP_TIPC ; tuncfg.encap_rcv = tipc_udp_recv; tuncfg.encap_destroy =NULL ;setup_udp_tunnel_sock (net, ub->ubsock, &tuncfg);
Signature · 1 line
2.34.1
PATCH v3 5/13 flow_dissector: UDP encap infrastructure
In reply to Tom HerbertAdd infrastructure for parsing into UDP encapsulations
Add function __skb_flow_dissect_udp that is called for IPPROTO_UDP. The flag FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS enables parsing of UDP encapsulations. If the flag is set when parsing a UDP packet then a socket lookup is performed. The offset of the base network header, either an IPv4 or IPv6 header, is tracked and passed to __skb_flow_dissect_udp so that it can perform the socket lookup
If a socket is found and it's for a UDP encapsulation (encap_type is set in the UDP socket) then a switch is performed on the encap_type value (cases are UDP_ENCAP_* values)
An encapsulated packet in UDP can either be indicated by an EtherType or IP protocol. The processing for dissecting a UDP encap protocol returns a flow dissector return code. If FLOW_DISSECT_RET_PROTO_AGAIN or FLOW_DISSECT_RET_IPPROTO_AGAIN is returned then the corresponding encapsulated protocol is dissected. The nhoff is set to point to the header to process. In the case FLOW_DISSECT_RET_PROTO_AGAIN the EtherType protocol is returned and the IP protocol is set to zero. In the case of FLOW_DISSECT_RET_IPPROTO_AGAIN, the IP protocol is returned and the EtherType protocol is returned unchanged
--- include/net/flow_dissector.h | 1 + net/core/flow_dissector.c | 137 +++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+)
include/net/flow_dissector.h +1 -0
@@ -384,6 +384,7 @@ enum flow_dissector_key_id {#define FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL BIT(1)#define FLOW_DISSECTOR_F_STOP_AT_ENCAP BIT(2)#define FLOW_DISSECTOR_F_STOP_BEFORE_ENCAP BIT(3) +#define FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS BIT(4)struct flow_dissector_key {enum flow_dissector_key_id key_id;
net/core/flow_dissector.c +137 -0
167 lines not on this page · raw message
Signature · 1 line
2.34.1
kernel test robot
build botRe: [PATCH net-next v3 05/13] flow_dissector: UDP encap infrastructure
kernel test robot noticed the following build warnings:
Hi Tom,
kernel test robot noticed the following build warnings:
[auto build test WARNING on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Tom-Herbert/ipv6-Add-udp6_lib_lookup-to-IPv6-stubs/20240822-052515 base: net-next/main patch link: https://lore.kernel.org/r/20240821212212.1795357-6-tom%40herbertland.com patch subject: [PATCH net-next v3 05/13] flow_dissector: UDP encap infrastructure config: x86_64-buildonly-randconfig-001-20240822 (https://download.01.org/0day-ci/archive/20240822/[email protected]/config) compiler: gcc-12 (Debian 12.2.0-14) 12.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240822/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
net/core/flow_dissector.c: In function '__skb_flow_dissect_udp':
>> net/core/flow_dissector.c:821:22: warning: unused variable 'sk' [-Wunused-variable]
821 | struct sock *sk;
| ^~
>> net/core/flow_dissector.c:819:30: warning: unused variable 'udph' [-Wunused-variable]
819 | const struct udphdr *udph;
| ^~~~vim +/sk +821 net/core/flow_dissector.c
809
810 static enum flow_dissect_ret
811 __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net,
812 struct flow_dissector *flow_dissector,
813 void *target_container, const void *data,
814 int *p_nhoff, int hlen, __be16 *p_proto,
815 u8 *p_ip_proto, int base_nhoff, unsigned int flags,
816 unsigned int num_hdrs)
817 {
818 enum flow_dissect_ret ret;
> 819 const struct udphdr *udph;
820 struct udphdr _udph;
> 821 struct sock *sk;
822 __u8 encap_type;
823 int nhoff;
824
825 if (!(flags & FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS))
826 return FLOW_DISSECT_RET_OUT_GOOD;
827
828 /* Check that the netns for the skb device is the same as the caller's,
829 * and only dissect UDP if we haven't yet encountered any encapsulation.
830 * The goal is to ensure that the socket lookup is being done in the
831 * right netns. Encapsulations may push packets into different name
832 * spaces, so this scheme is restricting UDP dissection to cases where
833 * they are in the same name spaces or at least the original name space.
834 * This should capture the majority of use cases for UDP encaps, and
835 * if we do encounter a UDP encapsulation within a different namespace
836 * then the only effect is we don't attempt UDP dissection
837 */
838 if (dev_net(skb->dev) != net || num_hdrs > 0)
839 return FLOW_DISSECT_RET_OUT_GOOD;
840
841 switch (*p_proto) {
842 #ifdef CONFIG_INET
843 case htons(ETH_P_IP): {
844 const struct iphdr *iph;
845 struct iphdr _iph;
846
847 iph = __skb_header_pointer(skb, base_nhoff, sizeof(_iph), data,
848 hlen, &_iph);
849 if (!iph)
850 return FLOW_DISSECT_RET_OUT_BAD;
851
852 udph = __skb_header_pointer(skb, *p_nhoff, sizeof(_udph), data,
853 hlen, &_udph);
854 if (!udph)
855 return FLOW_DISSECT_RET_OUT_BAD;
856
857 rcu_read_lock();
858 /* Look up the UDPv4 socket and get the encap_type */
859 sk = __udp4_lib_lookup(net, iph->saddr, udph->source,
860 iph->daddr, udph->dest,
861 inet_iif(skb), inet_sdif(skb),
862 net->ipv4.udp_table, NULL);
863 if (!sk || !udp_sk(sk)->encap_type) { 864 rcu_read_unlock();
865 return FLOW_DISSECT_RET_OUT_GOOD;
866 }
867
868 encap_type = udp_sk(sk)->encap_type;
869 rcu_read_unlock();
870
871 break;
872 }
873 #if IS_ENABLED(CONFIG_IPV6)
874 case htons(ETH_P_IPV6): {
875 const struct ipv6hdr *iph;
876 struct ipv6hdr _iph;
877
878 if (!likely(ipv6_stub))
879 return FLOW_DISSECT_RET_OUT_GOOD;
880
881 iph = __skb_header_pointer(skb, base_nhoff, sizeof(_iph), data,
882 hlen, &_iph);
883 if (!iph)
884 return FLOW_DISSECT_RET_OUT_BAD;
885
886 udph = __skb_header_pointer(skb, *p_nhoff, sizeof(_udph), data,
887 hlen, &_udph);
888 if (!udph)
889 return FLOW_DISSECT_RET_OUT_BAD;
890
891 rcu_read_lock();
892 /* Look up the UDPv6 socket and get the encap_type */
893 sk = ipv6_stub->udp6_lib_lookup(net,
894 &iph->saddr, udph->source,
895 &iph->daddr, udph->dest,
896 inet_iif(skb), inet_sdif(skb),
897 net->ipv4.udp_table, NULL);
898
899 if (!sk || !udp_sk(sk)->encap_type) {
900 rcu_read_unlock();
901 return FLOW_DISSECT_RET_OUT_GOOD;
902 }
903
904 encap_type = udp_sk(sk)->encap_type;
905 rcu_read_unlock();
906
907 break;
908 }
909 #endif /* CONFIG_IPV6 */
910 #endif /* CONFIG_INET */
911 default:
912 return FLOW_DISSECT_RET_OUT_GOOD;
913 }
914
915 nhoff = *p_nhoff + sizeof(_udph);
916 ret = FLOW_DISSECT_RET_OUT_GOOD;
917
918 switch (encap_type) {
919 default:
920 break;
921 }
922
923 switch (ret) {
924 case FLOW_DISSECT_RET_PROTO_AGAIN:
925 *p_ip_proto = 0;
926 fallthrough;
927 case FLOW_DISSECT_RET_IPPROTO_AGAIN:
928 *p_nhoff = nhoff;
929 break;
930 default:
931 break;
932 }
933
934 return ret;
935 }
936
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
PATCH v3 6/13 flow_dissector: Parse vxlan in UDP
In reply to Tom HerbertParse vxlan in a UDP encapsulation
--- net/core/flow_dissector.c | 47 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
net/core/flow_dissector.c +47 -0
@@ -13,7 +13,9 @@#include <net/gre.h> #include <net/pptp.h> #include <net/tipc.h> +#include <net/tun_proto.h> #include <net/udp.h> +#include <net/vxlan.h> #include <linux/igmp.h> #include <linux/icmp.h> #include <linux/sctp.h>
@@ -756,6 +758,44 @@ __skb_flow_dissect_gre(const struct sk_buff *skb,return FLOW_DISSECT_RET_PROTO_AGAIN ; } +static enum flow_dissect_ret +__skb_flow_dissect_vxlan (const struct sk_buff *skb, +struct flow_dissector *flow_dissector, +void *target_container,const void *data, +__be16 *p_proto,int *p_nhoff,int hlen, +unsigned int flags,bool is_gpe) +{ +struct vxlanhdr *hdr, _hdr; +__be16 protocol; + + hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), data, hlen, + &_hdr); +if (!hdr) +return FLOW_DISSECT_RET_OUT_BAD ; + +/* VNI flag always required to be set */ +if (!(hdr->vx_flags &VXLAN_HF_VNI )) +return FLOW_DISSECT_RET_OUT_BAD ; + +if (is_gpe) { +struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)hdr; + +if (!gpe->np_applied || gpe->version !=0 || gpe->oam_flag) +return FLOW_DISSECT_RET_OUT_GOOD ; + + protocol =tun_p_to_eth_p (gpe->next_protocol); +if (!protocol) +return FLOW_DISSECT_RET_OUT_GOOD ; + }else { + protocol =htons (ETH_P_TEB ); + } + + *p_nhoff +=sizeof (struct vxlanhdr ); + *p_proto = protocol; + +return FLOW_DISSECT_RET_PROTO_AGAIN ; +} +/** * __skb_flow_dissect_batadv() - dissect batman-adv header * @skb: sk_buff to with the batman-adv header
@@ -916,6 +956,13 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, ret =FLOW_DISSECT_RET_OUT_GOOD ;switch (encap_type) { +case UDP_ENCAP_VXLAN : +case UDP_ENCAP_VXLAN_GPE : + ret =__skb_flow_dissect_vxlan (skb, flow_dissector, + target_container, data, + p_proto, &nhoff, hlen, flags, + encap_type ==UDP_ENCAP_VXLAN_GPE ); +break ;default :break ; }
Signature · 1 line
2.34.1
PATCH v3 7/13 flow_dissector: Parse foo-over-udp (FOU)
In reply to Tom HerbertParse FOU by getting the FOU protocol from the matching socket. This includes moving "struct fou" and "fou_from_sock" to fou.h
--- include/net/fou.h | 16 ++++++++++++++++ net/core/flow_dissector.c | 13 ++++++++++++- net/ipv4/fou_core.c | 16 ---------------- 3 files changed, 28 insertions(+), 17 deletions(-)
include/net/fou.h +16 -0
@@ -17,6 +17,22 @@ int __fou_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,int __gue_build_header (struct sk_buff *skb,struct ip_tunnel_encap *e,u8 *protocol,__be16 *sport,int type); +struct fou { +struct socket *sock; +u8 protocol; +u8 flags; +__be16 port; +u8 family; +u16 type; +struct list_head list; +struct rcu_head rcu; +}; + +static inline struct fou *fou_from_sock (struct sock *sk) +{ +return sk->sk_user_data; +} +int register_fou_bpf (void );#endif
net/core/flow_dissector.c +12 -1
@@ -8,6 +8,7 @@#include <linux/filter.h> #include <net/dsa.h> #include <net/dst_metadata.h> +#include <net/fou.h> #include <net/ip.h> #include <net/ipv6.h> #include <net/gre.h>
@@ -855,11 +856,11 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, u8 *p_ip_proto, int base_nhoff, unsigned int flags, unsigned int num_hdrs) { + __u8 encap_type, fou_protocol;enum flow_dissect_ret ret;const struct udphdr *udph;struct udphdr _udph;struct sock *sk; -__u8 encap_type;int nhoff;if (!(flags &FLOW_DISSECTOR_F_PARSE_UDP_ENCAPS ))
@@ -906,6 +907,9 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, } encap_type =udp_sk (sk)->encap_type; +if (encap_type ==UDP_ENCAP_FOU ) + fou_protocol =fou_from_sock (sk)->protocol; +rcu_read_unlock ();break ;
@@ -942,6 +946,9 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, } encap_type =udp_sk (sk)->encap_type; +if (encap_type ==UDP_ENCAP_FOU ) + fou_protocol =fou_from_sock (sk)->protocol; +rcu_read_unlock ();break ;
@@ -956,6 +963,10 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, ret =FLOW_DISSECT_RET_OUT_GOOD ;switch (encap_type) { +case UDP_ENCAP_FOU : + *p_ip_proto = fou_protocol; + ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ; +break ;case UDP_ENCAP_VXLAN :case UDP_ENCAP_VXLAN_GPE : ret = __skb_flow_dissect_vxlan(skb, flow_dissector,
net/ipv4/fou_core.c +0 -16
@@ -21,17 +21,6 @@#include "fou_nl.h" -struct fou { -struct socket *sock; -u8 protocol; -u8 flags; -__be16 port; -u8 family; -u16 type; -struct list_head list; -struct rcu_head rcu; -}; -#define FOU_F_REMCSUM_NOPARTIAL BIT(0)struct fou_cfg {
@@ -48,11 +37,6 @@ struct fou_net {struct mutex fou_lock; }; -static inline struct fou *fou_from_sock (struct sock *sk) -{ -return sk->sk_user_data; -} -static int fou_recv_pull (struct sk_buff *skb,struct fou *fou,size_t len) {/* Remove 'len' bytes from the packet (UDP header and
Signature · 1 line
2.34.1
PATCH v3 8/13 flow_dissector: Parse ESP, L2TP, and SCTP in UDP
In reply to Tom HerbertThese don't have an encapsulation header so it's fairly easy to support them
--- net/core/flow_dissector.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
net/core/flow_dissector.c +13 -0
@@ -963,10 +963,23 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, ret =FLOW_DISSECT_RET_OUT_GOOD ;switch (encap_type) { +case UDP_ENCAP_ESPINUDP_NON_IKE : +case UDP_ENCAP_ESPINUDP : + *p_ip_proto =IPPROTO_ESP ; + ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ; +break ; +case UDP_ENCAP_L2TPINUDP : + *p_ip_proto =IPPROTO_L2TP ; + ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ; +break ;case UDP_ENCAP_FOU : *p_ip_proto = fou_protocol; ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ;break ; +case UDP_ENCAP_SCTP : + *p_ip_proto =IPPROTO_SCTP ; + ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ; +break ;case UDP_ENCAP_VXLAN :case UDP_ENCAP_VXLAN_GPE : ret = __skb_flow_dissect_vxlan(skb, flow_dissector,
Signature · 1 line
2.34.1
PATCH v3 9/13 flow_dissector: Parse Geneve in UDP
In reply to Tom HerbertParse Geneve in a UDP encapsulation
--- net/core/flow_dissector.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
net/core/flow_dissector.c +29 -0
@@ -11,6 +11,7 @@#include <net/fou.h> #include <net/ip.h> #include <net/ipv6.h> +#include <net/geneve.h> #include <net/gre.h> #include <net/pptp.h> #include <net/tipc.h>
@@ -797,6 +798,29 @@ __skb_flow_dissect_vxlan(const struct sk_buff *skb,return FLOW_DISSECT_RET_PROTO_AGAIN ; } +static enum flow_dissect_ret +__skb_flow_dissect_geneve (const struct sk_buff *skb, +struct flow_dissector *flow_dissector, +void *target_container,const void *data, +__be16 *p_proto,int *p_nhoff,int hlen, +unsigned int flags) +{ +struct genevehdr *hdr, _hdr; + + hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), data, hlen, + &_hdr); +if (!hdr) +return FLOW_DISSECT_RET_OUT_BAD ; + +if (hdr->ver !=0 ) +return FLOW_DISSECT_RET_OUT_GOOD ; + + *p_proto = hdr->proto_type; + *p_nhoff +=sizeof (struct genevehdr ) + (hdr->opt_len *4 ); + +return FLOW_DISSECT_RET_PROTO_AGAIN ; +} +/** * __skb_flow_dissect_batadv() - dissect batman-adv header * @skb: sk_buff to with the batman-adv header
@@ -987,6 +1011,11 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, p_proto, &nhoff, hlen, flags, encap_type == UDP_ENCAP_VXLAN_GPE);break ; +case UDP_ENCAP_GENEVE : + ret =__skb_flow_dissect_geneve (skb, flow_dissector, + target_container, data, + p_proto, &nhoff, hlen, flags); +break ;default :break ; }
Signature · 1 line
2.34.1
PATCH v3 10/13 flow_dissector: Parse GUE in UDP
In reply to Tom HerbertParse both version 0 and 1 of GUE encapsulated in UDP. Add helper function __skb_direct_ip_dissect to convert an IP header to IPPROTO_IPIP or IPPROTO_IPV6 (by looking just at the version number)
--- net/core/flow_dissector.c | 60 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+)
net/core/flow_dissector.c +60 -0
@@ -821,6 +821,61 @@ __skb_flow_dissect_geneve(const struct sk_buff *skb,return FLOW_DISSECT_RET_PROTO_AGAIN ; } +static __u8 +__skb_direct_ip_dissect (void *hdr) +{ +/* Direct encapsulation of IPv4 or IPv6 */ + +switch (((struct iphdr *)hdr)->version) { +case 4 : +return IPPROTO_IPIP ; +case 6 : +return IPPROTO_IPV6 ; +default : +return 0 ; + } +} + +static enum flow_dissect_ret +__skb_flow_dissect_gue (const struct sk_buff *skb, +struct flow_dissector *flow_dissector, +void *target_container,const void *data, +__u8 *p_ip_proto,int *p_nhoff, +int hlen,unsigned int flags) +{ +struct guehdr *hdr, _hdr; +__u8 proto; + + hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), data, hlen, + &_hdr); +if (!hdr) +return FLOW_DISSECT_RET_OUT_BAD ; + +switch (hdr->version) { +case 0 : +if (unlikely (hdr->control)) +return FLOW_DISSECT_RET_OUT_GOOD ; + + *p_nhoff +=sizeof (struct guehdr ) + (hdr->hlen <<2 ); + *p_ip_proto = hdr->proto_ctype; + +break ; +case 1 : +/* Direct encapsulation of IPv4 or IPv6 */ + + proto =__skb_direct_ip_dissect (hdr); +if (proto) { + *p_ip_proto = proto; +break ; + } + fallthrough; +default : +return FLOW_DISSECT_RET_OUT_GOOD ; + } + +return FLOW_DISSECT_RET_IPPROTO_AGAIN ; +} +/** * __skb_flow_dissect_batadv() - dissect batman-adv header * @skb: sk_buff to with the batman-adv header
@@ -1000,6 +1055,11 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, *p_ip_proto = fou_protocol; ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ;break ; +case UDP_ENCAP_GUE : + ret =__skb_flow_dissect_gue (skb, flow_dissector, + target_container, data, + p_ip_proto, p_nhoff, hlen, flags); +break ;case UDP_ENCAP_SCTP : *p_ip_proto =IPPROTO_SCTP ; ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ;
Signature · 1 line
2.34.1
PATCH v3 11/13 gtp: Move gtp_parse_exthdrs into net/gtp.h
In reply to Tom Herbertgtp_parse_exthdrs is a generic function, move into a header file so we can call it outside of the GTP driver (specifically, we can call it from flow dissector)
--- drivers/net/gtp.c | 37 ------------------------------------- include/net/gtp.h | 38 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 37 deletions(-)
drivers/net/gtp.c +0 -37
@@ -742,43 +742,6 @@ static int gtp1u_handle_echo_resp(struct gtp_dev *gtp, struct sk_buff *skb) msg, 0, GTP_GENL_MCGRP, GFP_ATOMIC); } -static int gtp_parse_exthdrs (struct sk_buff *skb,unsigned int *hdrlen) -{ -struct gtp_ext_hdr *gtp_exthdr, _gtp_exthdr; -unsigned int offset = *hdrlen; -__u8 *next_type, _next_type; - -/* From 29.060: "The Extension Header Length field specifies the length -* of the particular Extension header in 4 octets units." -* -* This length field includes length field size itself (1 byte), -* payload (variable length) and next type (1 byte). The extension -* header is aligned to to 4 bytes. -*/ - -do { - gtp_exthdr =skb_header_pointer (skb, offset,sizeof (*gtp_exthdr), - &_gtp_exthdr); -if (!gtp_exthdr || !gtp_exthdr->len) -return -1 ; - - offset += gtp_exthdr->len *4 ; - -/* From 29.060: "If no such Header follows, then the value of -* the Next Extension Header Type shall be 0." -*/ - next_type =skb_header_pointer (skb, offset -1 , -sizeof (_next_type), &_next_type); -if (!next_type) -return -1 ; - - }while (*next_type !=0 ); - - *hdrlen = offset; - -return 0 ; -} -static int gtp1u_udp_encap_recv (struct gtp_dev *gtp,struct sk_buff *skb) { unsigned int hdrlen = sizeof(struct udphdr) +
include/net/gtp.h +38 -0
@@ -83,4 +83,42 @@ struct gtp_ext_hdr { __u8 data[]; }; +static inline int gtp_parse_exthdrs (const struct sk_buff *skb, +unsigned int *hdrlen) +{ +struct gtp_ext_hdr *gtp_exthdr, _gtp_exthdr; +unsigned int offset = *hdrlen; +__u8 *next_type, _next_type; + +/* From 29.060: "The Extension Header Length field specifies the length +* of the particular Extension header in 4 octets units." +* +* This length field includes length field size itself (1 byte), +* payload (variable length) and next type (1 byte). The extension +* header is aligned to 4 bytes. +*/ + +do { + gtp_exthdr =skb_header_pointer (skb, offset,sizeof (*gtp_exthdr), + &_gtp_exthdr); +if (!gtp_exthdr || !gtp_exthdr->len) +return -1 ; + + offset += gtp_exthdr->len *4 ; + +/* From 29.060: "If no such Header follows, then the value of +* the Next Extension Header Type shall be 0." +*/ + next_type =skb_header_pointer (skb, offset -1 , +sizeof (_next_type), &_next_type); +if (!next_type) +return -1 ; + + }while (*next_type !=0 ); + + *hdrlen = offset; + +return 0 ; +} +#endif
Signature · 1 line
2.34.1
PATCH v3 12/13 flow_dissector: Parse gtp in UDP
In reply to Tom HerbertParse both version 0 and 1. Call __skb_direct_ip_dissect to determine IP version of the encapsulated packet
--- net/core/flow_dissector.c | 97 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+)
net/core/flow_dissector.c +97 -0
@@ -9,6 +9,7 @@#include <net/dsa.h> #include <net/dst_metadata.h> #include <net/fou.h> +#include <net/gtp.h> #include <net/ip.h> #include <net/ipv6.h> #include <net/geneve.h>
@@ -35,6 +36,7 @@#include <net/pkt_cls.h> #include <scsi/fc/fc_fcoe.h> #include <uapi/linux/batadv_packet.h> +#include <uapi/linux/gtp.h> #include <linux/bpf.h> #if IS_ENABLED (CONFIG_NF_CONNTRACK )#include <net/netfilter/nf_conntrack_core.h>
@@ -876,6 +878,91 @@ __skb_flow_dissect_gue(const struct sk_buff *skb,return FLOW_DISSECT_RET_IPPROTO_AGAIN ; } +static enum flow_dissect_ret +__skb_flow_dissect_gtp0 (const struct sk_buff *skb, +struct flow_dissector *flow_dissector, +void *target_container,const void *data, +__u8 *p_ip_proto,int *p_nhoff,int hlen, +unsigned int flags) +{ +__u8 *ip_version, _ip_version, proto; +struct gtp0_header *hdr, _hdr; + + hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), data, hlen, + &_hdr); +if (!hdr) +return FLOW_DISSECT_RET_OUT_BAD ; + +if ((hdr->flags >>5 ) !=GTP_V0 ) +return FLOW_DISSECT_RET_OUT_GOOD ; + + ip_version =skb_header_pointer (skb, *p_nhoff +sizeof (_hdr), +sizeof (*ip_version), + &_ip_version); +if (!ip_version) +return FLOW_DISSECT_RET_OUT_BAD ; + + proto =__skb_direct_ip_dissect (ip_version); +if (!proto) +return FLOW_DISSECT_RET_OUT_GOOD ; + + *p_ip_proto = proto; + *p_nhoff +=sizeof (struct gtp0_header ); + +return FLOW_DISSECT_RET_IPPROTO_AGAIN ; +} + +static enum flow_dissect_ret +__skb_flow_dissect_gtp1u (const struct sk_buff *skb, +struct flow_dissector *flow_dissector, +void *target_container,const void *data, +__u8 *p_ip_proto,int *p_nhoff,int hlen, +unsigned int flags) +{ +__u8 *ip_version, _ip_version, proto; +struct gtp1_header *hdr, _hdr; +int hdrlen =sizeof (_hdr); + + hdr =__skb_header_pointer (skb, *p_nhoff,sizeof (_hdr), data, hlen, + &_hdr); +if (!hdr) +return FLOW_DISSECT_RET_OUT_BAD ; + +if ((hdr->flags >>5 ) !=GTP_V1 ) +return FLOW_DISSECT_RET_OUT_GOOD ; + +if (hdr->type !=GTP_TPDU ) +return FLOW_DISSECT_RET_OUT_GOOD ; + +if (hdr->flags >P1_F_MASK ) + hdrlen +=4 ; + +/* Skip over GTP extension headers if they are present */ +if (hdr->flags >P1_F_EXTHDR && +gtp_parse_exthdrs (skb, &hdrlen) <0 ) +return FLOW_DISSECT_RET_OUT_BAD ; + +/* Exit if either NPDU or SEQ glags are set */ +if (hdr->flags >P1_F_NPDU || + hdr->flags >P1_F_SEQ ) +return FLOW_DISSECT_RET_OUT_GOOD ; + + ip_version =skb_header_pointer (skb, *p_nhoff + hdrlen, +sizeof (*ip_version), + &_ip_version); +if (!ip_version) +return FLOW_DISSECT_RET_OUT_GOOD ; + + proto =__skb_direct_ip_dissect (ip_version); +if (!proto) +return FLOW_DISSECT_RET_OUT_GOOD ; + + *p_ip_proto = proto; + *p_nhoff += hdrlen; + +return FLOW_DISSECT_RET_IPPROTO_AGAIN ; +} +/** * __skb_flow_dissect_batadv() - dissect batman-adv header * @skb: sk_buff to with the batman-adv header
@@ -1051,6 +1138,16 @@ __skb_flow_dissect_udp(const struct sk_buff *skb, const struct net *net, *p_ip_proto =IPPROTO_L2TP ; ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ;break ; +case UDP_ENCAP_GTP0 : + ret =__skb_flow_dissect_gtp0 (skb, flow_dissector, + target_container, data, + p_ip_proto, &nhoff, hlen, flags); +break ; +case UDP_ENCAP_GTP1U : + ret =__skb_flow_dissect_gtp1u (skb, flow_dissector, + target_container, data, + p_ip_proto, &nhoff, hlen, flags); +break ;case UDP_ENCAP_FOU : *p_ip_proto = fou_protocol; ret =FLOW_DISSECT_RET_IPPROTO_AGAIN ;
Signature · 1 line
2.34.1
PATCH v3 13/13 flow_dissector: Add case in ipproto switch for NEXTHDR_NONE
In reply to Tom HerbertProtocol number 59 (no-next-header) means nothing follows the IP header, break out of the flow dissector loop on FLOW_DISSECT_RET_OUT_GOOD when encountered in a packet
--- net/core/flow_dissector.c | 3 +++ 1 file changed, 3 insertions(+)
net/core/flow_dissector.c +3 -0
@@ -1991,6 +1991,9 @@ bool __skb_flow_dissect(const struct net *net, fdret =FLOW_DISSECT_RET_OUT_GOOD ;break ; } +case NEXTHDR_NONE : + fdret =FLOW_DISSECT_RET_OUT_GOOD ; +break ;case IPPROTO_IPIP :if (flags &FLOW_DISSECTOR_F_STOP_BEFORE_ENCAP ) { fdret =FLOW_DISSECT_RET_OUT_GOOD ;
Signature · 1 line
2.34.1