mirror of
https://github.com/torvalds/linux
synced 2024-09-06 18:01:05 +00:00
![Michal Swiatkowski](/assets/img/avatar_default.png)
From Arnd comments:
"The memcpy() in the ip_tunnel_info_opts_set() causes
a string.h fortification warning, with at least gcc-13:
In function 'fortify_memcpy_chk',
inlined from 'ip_tunnel_info_opts_set' at include/net/ip_tunnels.h:619:3,
inlined from 'pfcp_encap_recv' at drivers/net/pfcp.c:84:2:
include/linux/fortify-string.h:553:25: error: call to '__write_overflow_field' declared with attribute warning: detected write beyond size of field (1st parameter); maybe use struct_group()? [-Werror=attribute-warning]
553 | __write_overflow_field(p_size_field, size);"
It is a false-positivie caused by ambiguity of the union.
However, as Arnd noticed, copying here is unescessary. The code can be
simplified to avoid calling ip_tunnel_info_opts_set(), which is doing
copying, setting flags and options_len.
Set correct flags and options_len directly on tun_info.
Fixes: 6dd514f481
("pfcp: always set pfcp metadata")
Reported-by: Arnd Bergmann <arnd@arndb.de>
Closes: https://lore.kernel.org/netdev/701f8f93-f5fb-408b-822a-37a1d5c424ba@app.fastmail.com/
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Reviewed-by: Simon Horman <horms@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
302 lines
6.2 KiB
C
302 lines
6.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* PFCP according to 3GPP TS 29.244
|
|
*
|
|
* Copyright (C) 2022, Intel Corporation.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/rculist.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/types.h>
|
|
|
|
#include <net/udp.h>
|
|
#include <net/udp_tunnel.h>
|
|
#include <net/pfcp.h>
|
|
|
|
struct pfcp_dev {
|
|
struct list_head list;
|
|
|
|
struct socket *sock;
|
|
struct net_device *dev;
|
|
struct net *net;
|
|
|
|
struct gro_cells gro_cells;
|
|
};
|
|
|
|
static unsigned int pfcp_net_id __read_mostly;
|
|
|
|
struct pfcp_net {
|
|
struct list_head pfcp_dev_list;
|
|
};
|
|
|
|
static void
|
|
pfcp_session_recv(struct pfcp_dev *pfcp, struct sk_buff *skb,
|
|
struct pfcp_metadata *md)
|
|
{
|
|
struct pfcphdr_session *unparsed = pfcp_hdr_session(skb);
|
|
|
|
md->seid = unparsed->seid;
|
|
md->type = PFCP_TYPE_SESSION;
|
|
}
|
|
|
|
static void
|
|
pfcp_node_recv(struct pfcp_dev *pfcp, struct sk_buff *skb,
|
|
struct pfcp_metadata *md)
|
|
{
|
|
md->type = PFCP_TYPE_NODE;
|
|
}
|
|
|
|
static int pfcp_encap_recv(struct sock *sk, struct sk_buff *skb)
|
|
{
|
|
IP_TUNNEL_DECLARE_FLAGS(flags) = { };
|
|
struct metadata_dst *tun_dst;
|
|
struct pfcp_metadata *md;
|
|
struct pfcphdr *unparsed;
|
|
struct pfcp_dev *pfcp;
|
|
|
|
if (unlikely(!pskb_may_pull(skb, PFCP_HLEN)))
|
|
goto drop;
|
|
|
|
pfcp = rcu_dereference_sk_user_data(sk);
|
|
if (unlikely(!pfcp))
|
|
goto drop;
|
|
|
|
unparsed = pfcp_hdr(skb);
|
|
|
|
ip_tunnel_flags_zero(flags);
|
|
tun_dst = udp_tun_rx_dst(skb, sk->sk_family, flags, 0,
|
|
sizeof(*md));
|
|
if (unlikely(!tun_dst))
|
|
goto drop;
|
|
|
|
md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
|
|
if (unlikely(!md))
|
|
goto drop;
|
|
|
|
if (unparsed->flags & PFCP_SEID_FLAG)
|
|
pfcp_session_recv(pfcp, skb, md);
|
|
else
|
|
pfcp_node_recv(pfcp, skb, md);
|
|
|
|
__set_bit(IP_TUNNEL_PFCP_OPT_BIT, tun_dst->u.tun_info.key.tun_flags);
|
|
tun_dst->u.tun_info.options_len = sizeof(*md);
|
|
|
|
if (unlikely(iptunnel_pull_header(skb, PFCP_HLEN, skb->protocol,
|
|
!net_eq(sock_net(sk),
|
|
dev_net(pfcp->dev)))))
|
|
goto drop;
|
|
|
|
skb_dst_set(skb, (struct dst_entry *)tun_dst);
|
|
|
|
skb_reset_network_header(skb);
|
|
skb_reset_mac_header(skb);
|
|
skb->dev = pfcp->dev;
|
|
|
|
gro_cells_receive(&pfcp->gro_cells, skb);
|
|
|
|
return 0;
|
|
drop:
|
|
kfree_skb(skb);
|
|
return 0;
|
|
}
|
|
|
|
static void pfcp_del_sock(struct pfcp_dev *pfcp)
|
|
{
|
|
udp_tunnel_sock_release(pfcp->sock);
|
|
pfcp->sock = NULL;
|
|
}
|
|
|
|
static void pfcp_dev_uninit(struct net_device *dev)
|
|
{
|
|
struct pfcp_dev *pfcp = netdev_priv(dev);
|
|
|
|
gro_cells_destroy(&pfcp->gro_cells);
|
|
pfcp_del_sock(pfcp);
|
|
}
|
|
|
|
static int pfcp_dev_init(struct net_device *dev)
|
|
{
|
|
struct pfcp_dev *pfcp = netdev_priv(dev);
|
|
|
|
pfcp->dev = dev;
|
|
|
|
return gro_cells_init(&pfcp->gro_cells, dev);
|
|
}
|
|
|
|
static const struct net_device_ops pfcp_netdev_ops = {
|
|
.ndo_init = pfcp_dev_init,
|
|
.ndo_uninit = pfcp_dev_uninit,
|
|
.ndo_get_stats64 = dev_get_tstats64,
|
|
};
|
|
|
|
static const struct device_type pfcp_type = {
|
|
.name = "pfcp",
|
|
};
|
|
|
|
static void pfcp_link_setup(struct net_device *dev)
|
|
{
|
|
dev->netdev_ops = &pfcp_netdev_ops;
|
|
dev->needs_free_netdev = true;
|
|
SET_NETDEV_DEVTYPE(dev, &pfcp_type);
|
|
|
|
dev->hard_header_len = 0;
|
|
dev->addr_len = 0;
|
|
|
|
dev->type = ARPHRD_NONE;
|
|
dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
|
|
dev->priv_flags |= IFF_NO_QUEUE;
|
|
|
|
netif_keep_dst(dev);
|
|
}
|
|
|
|
static struct socket *pfcp_create_sock(struct pfcp_dev *pfcp)
|
|
{
|
|
struct udp_tunnel_sock_cfg tuncfg = {};
|
|
struct udp_port_cfg udp_conf = {
|
|
.local_ip.s_addr = htonl(INADDR_ANY),
|
|
.family = AF_INET,
|
|
};
|
|
struct net *net = pfcp->net;
|
|
struct socket *sock;
|
|
int err;
|
|
|
|
udp_conf.local_udp_port = htons(PFCP_PORT);
|
|
|
|
err = udp_sock_create(net, &udp_conf, &sock);
|
|
if (err)
|
|
return ERR_PTR(err);
|
|
|
|
tuncfg.sk_user_data = pfcp;
|
|
tuncfg.encap_rcv = pfcp_encap_recv;
|
|
tuncfg.encap_type = 1;
|
|
|
|
setup_udp_tunnel_sock(net, sock, &tuncfg);
|
|
|
|
return sock;
|
|
}
|
|
|
|
static int pfcp_add_sock(struct pfcp_dev *pfcp)
|
|
{
|
|
pfcp->sock = pfcp_create_sock(pfcp);
|
|
|
|
return PTR_ERR_OR_ZERO(pfcp->sock);
|
|
}
|
|
|
|
static int pfcp_newlink(struct net *net, struct net_device *dev,
|
|
struct nlattr *tb[], struct nlattr *data[],
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
struct pfcp_dev *pfcp = netdev_priv(dev);
|
|
struct pfcp_net *pn;
|
|
int err;
|
|
|
|
pfcp->net = net;
|
|
|
|
err = pfcp_add_sock(pfcp);
|
|
if (err) {
|
|
netdev_dbg(dev, "failed to add pfcp socket %d\n", err);
|
|
goto exit_err;
|
|
}
|
|
|
|
err = register_netdevice(dev);
|
|
if (err) {
|
|
netdev_dbg(dev, "failed to register pfcp netdev %d\n", err);
|
|
goto exit_del_pfcp_sock;
|
|
}
|
|
|
|
pn = net_generic(dev_net(dev), pfcp_net_id);
|
|
list_add_rcu(&pfcp->list, &pn->pfcp_dev_list);
|
|
|
|
netdev_dbg(dev, "registered new PFCP interface\n");
|
|
|
|
return 0;
|
|
|
|
exit_del_pfcp_sock:
|
|
pfcp_del_sock(pfcp);
|
|
exit_err:
|
|
pfcp->net = NULL;
|
|
return err;
|
|
}
|
|
|
|
static void pfcp_dellink(struct net_device *dev, struct list_head *head)
|
|
{
|
|
struct pfcp_dev *pfcp = netdev_priv(dev);
|
|
|
|
list_del_rcu(&pfcp->list);
|
|
unregister_netdevice_queue(dev, head);
|
|
}
|
|
|
|
static struct rtnl_link_ops pfcp_link_ops __read_mostly = {
|
|
.kind = "pfcp",
|
|
.priv_size = sizeof(struct pfcp_dev),
|
|
.setup = pfcp_link_setup,
|
|
.newlink = pfcp_newlink,
|
|
.dellink = pfcp_dellink,
|
|
};
|
|
|
|
static int __net_init pfcp_net_init(struct net *net)
|
|
{
|
|
struct pfcp_net *pn = net_generic(net, pfcp_net_id);
|
|
|
|
INIT_LIST_HEAD(&pn->pfcp_dev_list);
|
|
return 0;
|
|
}
|
|
|
|
static void __net_exit pfcp_net_exit(struct net *net)
|
|
{
|
|
struct pfcp_net *pn = net_generic(net, pfcp_net_id);
|
|
struct pfcp_dev *pfcp;
|
|
LIST_HEAD(list);
|
|
|
|
rtnl_lock();
|
|
list_for_each_entry(pfcp, &pn->pfcp_dev_list, list)
|
|
pfcp_dellink(pfcp->dev, &list);
|
|
|
|
unregister_netdevice_many(&list);
|
|
rtnl_unlock();
|
|
}
|
|
|
|
static struct pernet_operations pfcp_net_ops = {
|
|
.init = pfcp_net_init,
|
|
.exit = pfcp_net_exit,
|
|
.id = &pfcp_net_id,
|
|
.size = sizeof(struct pfcp_net),
|
|
};
|
|
|
|
static int __init pfcp_init(void)
|
|
{
|
|
int err;
|
|
|
|
err = register_pernet_subsys(&pfcp_net_ops);
|
|
if (err)
|
|
goto exit_err;
|
|
|
|
err = rtnl_link_register(&pfcp_link_ops);
|
|
if (err)
|
|
goto exit_unregister_subsys;
|
|
return 0;
|
|
|
|
exit_unregister_subsys:
|
|
unregister_pernet_subsys(&pfcp_net_ops);
|
|
exit_err:
|
|
pr_err("loading PFCP module failed: err %d\n", err);
|
|
return err;
|
|
}
|
|
late_initcall(pfcp_init);
|
|
|
|
static void __exit pfcp_exit(void)
|
|
{
|
|
rtnl_link_unregister(&pfcp_link_ops);
|
|
unregister_pernet_subsys(&pfcp_net_ops);
|
|
|
|
pr_info("PFCP module unloaded\n");
|
|
}
|
|
module_exit(pfcp_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Wojciech Drewek <wojciech.drewek@intel.com>");
|
|
MODULE_DESCRIPTION("Interface driver for PFCP encapsulated traffic");
|
|
MODULE_ALIAS_RTNL_LINK("pfcp");
|