1// SPDX-License-Identifier: GPL-2.0-or-later
2/* L2TPv3 ethernet pseudowire driver
3 *
4 * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
5 */
6
7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
9#include <linux/module.h>
10#include <linux/skbuff.h>
11#include <linux/socket.h>
12#include <linux/hash.h>
13#include <linux/l2tp.h>
14#include <linux/in.h>
15#include <linux/etherdevice.h>
16#include <linux/spinlock.h>
17#include <net/sock.h>
18#include <net/ip.h>
19#include <net/icmp.h>
20#include <net/udp.h>
21#include <net/inet_common.h>
22#include <net/inet_hashtables.h>
23#include <net/tcp_states.h>
24#include <net/protocol.h>
25#include <net/xfrm.h>
26#include <net/net_namespace.h>
27#include <net/netns/generic.h>
28#include <linux/ip.h>
29#include <linux/ipv6.h>
30#include <linux/udp.h>
31
32#include "l2tp_core.h"
33
34/* Default device name. May be overridden by name specified by user */
35#define L2TP_ETH_DEV_NAME	"l2tpeth%d"
36
37/* via netdev_priv() */
38struct l2tp_eth {
39	struct l2tp_session	*session;
40};
41
42/* via l2tp_session_priv() */
43struct l2tp_eth_sess {
44	struct net_device __rcu *dev;
45};
46
47static int l2tp_eth_dev_init(struct net_device *dev)
48{
49	eth_hw_addr_random(dev);
50	eth_broadcast_addr(dev->broadcast);
51	netdev_lockdep_set_classes(dev);
52
53	return 0;
54}
55
56static void l2tp_eth_dev_uninit(struct net_device *dev)
57{
58	struct l2tp_eth *priv = netdev_priv(dev);
59	struct l2tp_eth_sess *spriv;
60
61	spriv = l2tp_session_priv(priv->session);
62	RCU_INIT_POINTER(spriv->dev, NULL);
63	/* No need for synchronize_net() here. We're called by
64	 * unregister_netdev*(), which does the synchronisation for us.
65	 */
66}
67
68static netdev_tx_t l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
69{
70	struct l2tp_eth *priv = netdev_priv(dev);
71	struct l2tp_session *session = priv->session;
72	unsigned int len = skb->len;
73	int ret = l2tp_xmit_skb(session, skb);
74
75	if (likely(ret == NET_XMIT_SUCCESS)) {
76		DEV_STATS_ADD(dev, tx_bytes, len);
77		DEV_STATS_INC(dev, tx_packets);
78	} else {
79		DEV_STATS_INC(dev, tx_dropped);
80	}
81	return NETDEV_TX_OK;
82}
83
84static void l2tp_eth_get_stats64(struct net_device *dev,
85				 struct rtnl_link_stats64 *stats)
86{
87	stats->tx_bytes   = DEV_STATS_READ(dev, tx_bytes);
88	stats->tx_packets = DEV_STATS_READ(dev, tx_packets);
89	stats->tx_dropped = DEV_STATS_READ(dev, tx_dropped);
90	stats->rx_bytes   = DEV_STATS_READ(dev, rx_bytes);
91	stats->rx_packets = DEV_STATS_READ(dev, rx_packets);
92	stats->rx_errors  = DEV_STATS_READ(dev, rx_errors);
93}
94
95static const struct net_device_ops l2tp_eth_netdev_ops = {
96	.ndo_init		= l2tp_eth_dev_init,
97	.ndo_uninit		= l2tp_eth_dev_uninit,
98	.ndo_start_xmit		= l2tp_eth_dev_xmit,
99	.ndo_get_stats64	= l2tp_eth_get_stats64,
100	.ndo_set_mac_address	= eth_mac_addr,
101};
102
103static const struct device_type l2tpeth_type = {
104	.name = "l2tpeth",
105};
106
107static void l2tp_eth_dev_setup(struct net_device *dev)
108{
109	SET_NETDEV_DEVTYPE(dev, &l2tpeth_type);
110	ether_setup(dev);
111	dev->priv_flags		&= ~IFF_TX_SKB_SHARING;
112	dev->features		|= NETIF_F_LLTX;
113	dev->netdev_ops		= &l2tp_eth_netdev_ops;
114	dev->needs_free_netdev	= true;
115}
116
117static void l2tp_eth_dev_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
118{
119	struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
120	struct net_device *dev;
121
122	if (!pskb_may_pull(skb, ETH_HLEN))
123		goto error;
124
125	secpath_reset(skb);
126
127	/* checksums verified by L2TP */
128	skb->ip_summed = CHECKSUM_NONE;
129
130	skb_dst_drop(skb);
131	nf_reset_ct(skb);
132
133	rcu_read_lock();
134	dev = rcu_dereference(spriv->dev);
135	if (!dev)
136		goto error_rcu;
137
138	if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS) {
139		DEV_STATS_INC(dev, rx_packets);
140		DEV_STATS_ADD(dev, rx_bytes, data_len);
141	} else {
142		DEV_STATS_INC(dev, rx_errors);
143	}
144	rcu_read_unlock();
145
146	return;
147
148error_rcu:
149	rcu_read_unlock();
150error:
151	kfree_skb(skb);
152}
153
154static void l2tp_eth_delete(struct l2tp_session *session)
155{
156	struct l2tp_eth_sess *spriv;
157	struct net_device *dev;
158
159	if (session) {
160		spriv = l2tp_session_priv(session);
161
162		rtnl_lock();
163		dev = rtnl_dereference(spriv->dev);
164		if (dev) {
165			unregister_netdevice(dev);
166			rtnl_unlock();
167			module_put(THIS_MODULE);
168		} else {
169			rtnl_unlock();
170		}
171	}
172}
173
174static void l2tp_eth_show(struct seq_file *m, void *arg)
175{
176	struct l2tp_session *session = arg;
177	struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
178	struct net_device *dev;
179
180	rcu_read_lock();
181	dev = rcu_dereference(spriv->dev);
182	if (!dev) {
183		rcu_read_unlock();
184		return;
185	}
186	dev_hold(dev);
187	rcu_read_unlock();
188
189	seq_printf(m, "   interface %s\n", dev->name);
190
191	dev_put(dev);
192}
193
194static void l2tp_eth_adjust_mtu(struct l2tp_tunnel *tunnel,
195				struct l2tp_session *session,
196				struct net_device *dev)
197{
198	unsigned int overhead = 0;
199	u32 l3_overhead = 0;
200	u32 mtu;
201
202	/* if the encap is UDP, account for UDP header size */
203	if (tunnel->encap == L2TP_ENCAPTYPE_UDP) {
204		overhead += sizeof(struct udphdr);
205		dev->needed_headroom += sizeof(struct udphdr);
206	}
207
208	lock_sock(tunnel->sock);
209	l3_overhead = kernel_sock_ip_overhead(tunnel->sock);
210	release_sock(tunnel->sock);
211
212	if (l3_overhead == 0) {
213		/* L3 Overhead couldn't be identified, this could be
214		 * because tunnel->sock was NULL or the socket's
215		 * address family was not IPv4 or IPv6,
216		 * dev mtu stays at 1500.
217		 */
218		return;
219	}
220	/* Adjust MTU, factor overhead - underlay L3, overlay L2 hdr
221	 * UDP overhead, if any, was already factored in above.
222	 */
223	overhead += session->hdr_len + ETH_HLEN + l3_overhead;
224
225	mtu = l2tp_tunnel_dst_mtu(tunnel) - overhead;
226	if (mtu < dev->min_mtu || mtu > dev->max_mtu)
227		dev->mtu = ETH_DATA_LEN - overhead;
228	else
229		dev->mtu = mtu;
230
231	dev->needed_headroom += session->hdr_len;
232}
233
234static int l2tp_eth_create(struct net *net, struct l2tp_tunnel *tunnel,
235			   u32 session_id, u32 peer_session_id,
236			   struct l2tp_session_cfg *cfg)
237{
238	unsigned char name_assign_type;
239	struct net_device *dev;
240	char name[IFNAMSIZ];
241	struct l2tp_session *session;
242	struct l2tp_eth *priv;
243	struct l2tp_eth_sess *spriv;
244	int rc;
245
246	if (cfg->ifname) {
247		strscpy(name, cfg->ifname, IFNAMSIZ);
248		name_assign_type = NET_NAME_USER;
249	} else {
250		strcpy(name, L2TP_ETH_DEV_NAME);
251		name_assign_type = NET_NAME_ENUM;
252	}
253
254	session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
255				      peer_session_id, cfg);
256	if (IS_ERR(session)) {
257		rc = PTR_ERR(session);
258		goto err;
259	}
260
261	dev = alloc_netdev(sizeof(*priv), name, name_assign_type,
262			   l2tp_eth_dev_setup);
263	if (!dev) {
264		rc = -ENOMEM;
265		goto err_sess;
266	}
267
268	dev_net_set(dev, net);
269	dev->min_mtu = 0;
270	dev->max_mtu = ETH_MAX_MTU;
271	l2tp_eth_adjust_mtu(tunnel, session, dev);
272
273	priv = netdev_priv(dev);
274	priv->session = session;
275
276	session->recv_skb = l2tp_eth_dev_recv;
277	session->session_close = l2tp_eth_delete;
278	if (IS_ENABLED(CONFIG_L2TP_DEBUGFS))
279		session->show = l2tp_eth_show;
280
281	spriv = l2tp_session_priv(session);
282
283	l2tp_session_inc_refcount(session);
284
285	rtnl_lock();
286
287	/* Register both device and session while holding the rtnl lock. This
288	 * ensures that l2tp_eth_delete() will see that there's a device to
289	 * unregister, even if it happened to run before we assign spriv->dev.
290	 */
291	rc = l2tp_session_register(session, tunnel);
292	if (rc < 0) {
293		rtnl_unlock();
294		goto err_sess_dev;
295	}
296
297	rc = register_netdevice(dev);
298	if (rc < 0) {
299		rtnl_unlock();
300		l2tp_session_delete(session);
301		l2tp_session_dec_refcount(session);
302		free_netdev(dev);
303
304		return rc;
305	}
306
307	strscpy(session->ifname, dev->name, IFNAMSIZ);
308	rcu_assign_pointer(spriv->dev, dev);
309
310	rtnl_unlock();
311
312	l2tp_session_dec_refcount(session);
313
314	__module_get(THIS_MODULE);
315
316	return 0;
317
318err_sess_dev:
319	l2tp_session_dec_refcount(session);
320	free_netdev(dev);
321err_sess:
322	kfree(session);
323err:
324	return rc;
325}
326
327static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
328	.session_create	= l2tp_eth_create,
329	.session_delete	= l2tp_session_delete,
330};
331
332static int __init l2tp_eth_init(void)
333{
334	int err = 0;
335
336	err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
337	if (err)
338		goto err;
339
340	pr_info("L2TP ethernet pseudowire support (L2TPv3)\n");
341
342	return 0;
343
344err:
345	return err;
346}
347
348static void __exit l2tp_eth_exit(void)
349{
350	l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
351}
352
353module_init(l2tp_eth_init);
354module_exit(l2tp_eth_exit);
355
356MODULE_LICENSE("GPL");
357MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
358MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
359MODULE_VERSION("1.0");
360MODULE_ALIAS_L2TP_PWTYPE(5);
361