2 * L2TPv3 ethernet pseudowire driver
4 * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/module.h>
15 #include <linux/skbuff.h>
16 #include <linux/socket.h>
17 #include <linux/hash.h>
18 #include <linux/l2tp.h>
20 #include <linux/etherdevice.h>
21 #include <linux/spinlock.h>
26 #include <net/inet_common.h>
27 #include <net/inet_hashtables.h>
28 #include <net/tcp_states.h>
29 #include <net/protocol.h>
31 #include <net/net_namespace.h>
32 #include <net/netns/generic.h>
34 #include <linux/ipv6.h>
35 #include <linux/udp.h>
37 #include "l2tp_core.h"
39 /* Default device name. May be overridden by name specified by user */
40 #define L2TP_ETH_DEV_NAME "l2tpeth%d"
42 /* via netdev_priv() */
44 struct net_device
*dev
;
45 struct sock
*tunnel_sock
;
46 struct l2tp_session
*session
;
47 struct list_head list
;
48 atomic_long_t tx_bytes
;
49 atomic_long_t tx_packets
;
50 atomic_long_t tx_dropped
;
51 atomic_long_t rx_bytes
;
52 atomic_long_t rx_packets
;
53 atomic_long_t rx_errors
;
56 /* via l2tp_session_priv() */
57 struct l2tp_eth_sess
{
58 struct net_device
*dev
;
61 /* per-net private data for this module */
62 static unsigned int l2tp_eth_net_id
;
64 struct list_head l2tp_eth_dev_list
;
65 spinlock_t l2tp_eth_lock
;
68 static inline struct l2tp_eth_net
*l2tp_eth_pernet(struct net
*net
)
70 return net_generic(net
, l2tp_eth_net_id
);
73 static int l2tp_eth_dev_init(struct net_device
*dev
)
75 struct l2tp_eth
*priv
= netdev_priv(dev
);
78 eth_hw_addr_random(dev
);
79 eth_broadcast_addr(dev
->broadcast
);
80 netdev_lockdep_set_classes(dev
);
85 static void l2tp_eth_dev_uninit(struct net_device
*dev
)
87 struct l2tp_eth
*priv
= netdev_priv(dev
);
88 struct l2tp_eth_net
*pn
= l2tp_eth_pernet(dev_net(dev
));
90 spin_lock(&pn
->l2tp_eth_lock
);
91 list_del_init(&priv
->list
);
92 spin_unlock(&pn
->l2tp_eth_lock
);
96 static int l2tp_eth_dev_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
98 struct l2tp_eth
*priv
= netdev_priv(dev
);
99 struct l2tp_session
*session
= priv
->session
;
100 unsigned int len
= skb
->len
;
101 int ret
= l2tp_xmit_skb(session
, skb
, session
->hdr_len
);
103 if (likely(ret
== NET_XMIT_SUCCESS
)) {
104 atomic_long_add(len
, &priv
->tx_bytes
);
105 atomic_long_inc(&priv
->tx_packets
);
107 atomic_long_inc(&priv
->tx_dropped
);
112 static void l2tp_eth_get_stats64(struct net_device
*dev
,
113 struct rtnl_link_stats64
*stats
)
115 struct l2tp_eth
*priv
= netdev_priv(dev
);
117 stats
->tx_bytes
= atomic_long_read(&priv
->tx_bytes
);
118 stats
->tx_packets
= atomic_long_read(&priv
->tx_packets
);
119 stats
->tx_dropped
= atomic_long_read(&priv
->tx_dropped
);
120 stats
->rx_bytes
= atomic_long_read(&priv
->rx_bytes
);
121 stats
->rx_packets
= atomic_long_read(&priv
->rx_packets
);
122 stats
->rx_errors
= atomic_long_read(&priv
->rx_errors
);
125 static const struct net_device_ops l2tp_eth_netdev_ops
= {
126 .ndo_init
= l2tp_eth_dev_init
,
127 .ndo_uninit
= l2tp_eth_dev_uninit
,
128 .ndo_start_xmit
= l2tp_eth_dev_xmit
,
129 .ndo_get_stats64
= l2tp_eth_get_stats64
,
130 .ndo_set_mac_address
= eth_mac_addr
,
133 static struct device_type l2tpeth_type
= {
137 static void l2tp_eth_dev_setup(struct net_device
*dev
)
139 SET_NETDEV_DEVTYPE(dev
, &l2tpeth_type
);
141 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
142 dev
->features
|= NETIF_F_LLTX
;
143 dev
->netdev_ops
= &l2tp_eth_netdev_ops
;
144 dev
->destructor
= free_netdev
;
147 static void l2tp_eth_dev_recv(struct l2tp_session
*session
, struct sk_buff
*skb
, int data_len
)
149 struct l2tp_eth_sess
*spriv
= l2tp_session_priv(session
);
150 struct net_device
*dev
= spriv
->dev
;
151 struct l2tp_eth
*priv
= netdev_priv(dev
);
153 if (session
->debug
& L2TP_MSG_DATA
) {
156 length
= min(32u, skb
->len
);
157 if (!pskb_may_pull(skb
, length
))
160 pr_debug("%s: eth recv\n", session
->name
);
161 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET
, skb
->data
, length
);
164 if (!pskb_may_pull(skb
, ETH_HLEN
))
169 /* checksums verified by L2TP */
170 skb
->ip_summed
= CHECKSUM_NONE
;
175 if (dev_forward_skb(dev
, skb
) == NET_RX_SUCCESS
) {
176 atomic_long_inc(&priv
->rx_packets
);
177 atomic_long_add(data_len
, &priv
->rx_bytes
);
179 atomic_long_inc(&priv
->rx_errors
);
184 atomic_long_inc(&priv
->rx_errors
);
188 static void l2tp_eth_delete(struct l2tp_session
*session
)
190 struct l2tp_eth_sess
*spriv
;
191 struct net_device
*dev
;
194 spriv
= l2tp_session_priv(session
);
197 unregister_netdev(dev
);
199 module_put(THIS_MODULE
);
204 #if IS_ENABLED(CONFIG_L2TP_DEBUGFS)
205 static void l2tp_eth_show(struct seq_file
*m
, void *arg
)
207 struct l2tp_session
*session
= arg
;
208 struct l2tp_eth_sess
*spriv
= l2tp_session_priv(session
);
209 struct net_device
*dev
= spriv
->dev
;
211 seq_printf(m
, " interface %s\n", dev
->name
);
215 static void l2tp_eth_adjust_mtu(struct l2tp_tunnel
*tunnel
,
216 struct l2tp_session
*session
,
217 struct net_device
*dev
)
219 unsigned int overhead
= 0;
220 struct dst_entry
*dst
;
223 /* if the encap is UDP, account for UDP header size */
224 if (tunnel
->encap
== L2TP_ENCAPTYPE_UDP
) {
225 overhead
+= sizeof(struct udphdr
);
226 dev
->needed_headroom
+= sizeof(struct udphdr
);
228 if (session
->mtu
!= 0) {
229 dev
->mtu
= session
->mtu
;
230 dev
->needed_headroom
+= session
->hdr_len
;
233 lock_sock(tunnel
->sock
);
234 l3_overhead
= kernel_sock_ip_overhead(tunnel
->sock
);
235 release_sock(tunnel
->sock
);
236 if (l3_overhead
== 0) {
237 /* L3 Overhead couldn't be identified, this could be
238 * because tunnel->sock was NULL or the socket's
239 * address family was not IPv4 or IPv6,
240 * dev mtu stays at 1500.
244 /* Adjust MTU, factor overhead - underlay L3, overlay L2 hdr
245 * UDP overhead, if any, was already factored in above.
247 overhead
+= session
->hdr_len
+ ETH_HLEN
+ l3_overhead
;
249 /* If PMTU discovery was enabled, use discovered MTU on L2TP device */
250 dst
= sk_dst_get(tunnel
->sock
);
252 /* dst_mtu will use PMTU if found, else fallback to intf MTU */
253 u32 pmtu
= dst_mtu(dst
);
259 session
->mtu
= dev
->mtu
- overhead
;
260 dev
->mtu
= session
->mtu
;
261 dev
->needed_headroom
+= session
->hdr_len
;
264 static int l2tp_eth_create(struct net
*net
, u32 tunnel_id
, u32 session_id
, u32 peer_session_id
, struct l2tp_session_cfg
*cfg
)
266 unsigned char name_assign_type
;
267 struct net_device
*dev
;
269 struct l2tp_tunnel
*tunnel
;
270 struct l2tp_session
*session
;
271 struct l2tp_eth
*priv
;
272 struct l2tp_eth_sess
*spriv
;
274 struct l2tp_eth_net
*pn
;
276 tunnel
= l2tp_tunnel_find(net
, tunnel_id
);
283 strlcpy(name
, cfg
->ifname
, IFNAMSIZ
);
284 name_assign_type
= NET_NAME_USER
;
286 strcpy(name
, L2TP_ETH_DEV_NAME
);
287 name_assign_type
= NET_NAME_ENUM
;
290 session
= l2tp_session_create(sizeof(*spriv
), tunnel
, session_id
,
291 peer_session_id
, cfg
);
292 if (IS_ERR(session
)) {
293 rc
= PTR_ERR(session
);
297 dev
= alloc_netdev(sizeof(*priv
), name
, name_assign_type
,
301 goto out_del_session
;
304 dev_net_set(dev
, net
);
306 dev
->max_mtu
= ETH_MAX_MTU
;
307 l2tp_eth_adjust_mtu(tunnel
, session
, dev
);
309 priv
= netdev_priv(dev
);
311 priv
->session
= session
;
312 INIT_LIST_HEAD(&priv
->list
);
314 priv
->tunnel_sock
= tunnel
->sock
;
315 session
->recv_skb
= l2tp_eth_dev_recv
;
316 session
->session_close
= l2tp_eth_delete
;
317 #if IS_ENABLED(CONFIG_L2TP_DEBUGFS)
318 session
->show
= l2tp_eth_show
;
321 spriv
= l2tp_session_priv(session
);
324 rc
= register_netdev(dev
);
328 __module_get(THIS_MODULE
);
329 /* Must be done after register_netdev() */
330 strlcpy(session
->ifname
, dev
->name
, IFNAMSIZ
);
333 pn
= l2tp_eth_pernet(dev_net(dev
));
334 spin_lock(&pn
->l2tp_eth_lock
);
335 list_add(&priv
->list
, &pn
->l2tp_eth_dev_list
);
336 spin_unlock(&pn
->l2tp_eth_lock
);
344 l2tp_session_delete(session
);
349 static __net_init
int l2tp_eth_init_net(struct net
*net
)
351 struct l2tp_eth_net
*pn
= net_generic(net
, l2tp_eth_net_id
);
353 INIT_LIST_HEAD(&pn
->l2tp_eth_dev_list
);
354 spin_lock_init(&pn
->l2tp_eth_lock
);
359 static struct pernet_operations l2tp_eth_net_ops
= {
360 .init
= l2tp_eth_init_net
,
361 .id
= &l2tp_eth_net_id
,
362 .size
= sizeof(struct l2tp_eth_net
),
366 static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops
= {
367 .session_create
= l2tp_eth_create
,
368 .session_delete
= l2tp_session_delete
,
372 static int __init
l2tp_eth_init(void)
376 err
= l2tp_nl_register_ops(L2TP_PWTYPE_ETH
, &l2tp_eth_nl_cmd_ops
);
380 err
= register_pernet_device(&l2tp_eth_net_ops
);
384 pr_info("L2TP ethernet pseudowire support (L2TPv3)\n");
389 l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH
);
394 static void __exit
l2tp_eth_exit(void)
396 unregister_pernet_device(&l2tp_eth_net_ops
);
397 l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH
);
400 module_init(l2tp_eth_init
);
401 module_exit(l2tp_eth_exit
);
403 MODULE_LICENSE("GPL");
404 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
405 MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
406 MODULE_VERSION("1.0");
407 MODULE_ALIAS_L2TP_PWTYPE(5);