xref: /linux/drivers/net/veth.c (revision 7c66e12136c2fa421ae75497e02728f252108a1b)
1 /*
2  *  drivers/net/veth.c
3  *
4  *  Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc
5  *
6  * Author: Pavel Emelianov <xemul@openvz.org>
7  * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com>
8  *
9  */
10 
11 #include <linux/netdevice.h>
12 #include <linux/slab.h>
13 #include <linux/ethtool.h>
14 #include <linux/etherdevice.h>
15 #include <linux/u64_stats_sync.h>
16 
17 #include <net/rtnetlink.h>
18 #include <net/dst.h>
19 #include <net/xfrm.h>
20 #include <linux/veth.h>
21 #include <linux/module.h>
22 
23 #define DRV_NAME	"veth"
24 #define DRV_VERSION	"1.0"
25 
26 #define MIN_MTU 68		/* Min L3 MTU */
27 #define MAX_MTU 65535		/* Max L3 MTU (arbitrary) */
28 
29 struct pcpu_vstats {
30 	u64			packets;
31 	u64			bytes;
32 	struct u64_stats_sync	syncp;
33 };
34 
35 struct veth_priv {
36 	struct net_device __rcu	*peer;
37 	atomic64_t		dropped;
38 	unsigned		requested_headroom;
39 };
40 
41 /*
42  * ethtool interface
43  */
44 
45 static struct {
46 	const char string[ETH_GSTRING_LEN];
47 } ethtool_stats_keys[] = {
48 	{ "peer_ifindex" },
49 };
50 
51 static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
52 {
53 	cmd->supported		= 0;
54 	cmd->advertising	= 0;
55 	ethtool_cmd_speed_set(cmd, SPEED_10000);
56 	cmd->duplex		= DUPLEX_FULL;
57 	cmd->port		= PORT_TP;
58 	cmd->phy_address	= 0;
59 	cmd->transceiver	= XCVR_INTERNAL;
60 	cmd->autoneg		= AUTONEG_DISABLE;
61 	cmd->maxtxpkt		= 0;
62 	cmd->maxrxpkt		= 0;
63 	return 0;
64 }
65 
66 static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
67 {
68 	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
69 	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
70 }
71 
72 static void veth_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
73 {
74 	switch(stringset) {
75 	case ETH_SS_STATS:
76 		memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
77 		break;
78 	}
79 }
80 
81 static int veth_get_sset_count(struct net_device *dev, int sset)
82 {
83 	switch (sset) {
84 	case ETH_SS_STATS:
85 		return ARRAY_SIZE(ethtool_stats_keys);
86 	default:
87 		return -EOPNOTSUPP;
88 	}
89 }
90 
91 static void veth_get_ethtool_stats(struct net_device *dev,
92 		struct ethtool_stats *stats, u64 *data)
93 {
94 	struct veth_priv *priv = netdev_priv(dev);
95 	struct net_device *peer = rtnl_dereference(priv->peer);
96 
97 	data[0] = peer ? peer->ifindex : 0;
98 }
99 
100 static const struct ethtool_ops veth_ethtool_ops = {
101 	.get_settings		= veth_get_settings,
102 	.get_drvinfo		= veth_get_drvinfo,
103 	.get_link		= ethtool_op_get_link,
104 	.get_strings		= veth_get_strings,
105 	.get_sset_count		= veth_get_sset_count,
106 	.get_ethtool_stats	= veth_get_ethtool_stats,
107 };
108 
109 static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
110 {
111 	struct veth_priv *priv = netdev_priv(dev);
112 	struct net_device *rcv;
113 	int length = skb->len;
114 
115 	rcu_read_lock();
116 	rcv = rcu_dereference(priv->peer);
117 	if (unlikely(!rcv)) {
118 		kfree_skb(skb);
119 		goto drop;
120 	}
121 
122 	if (likely(dev_forward_skb(rcv, skb) == NET_RX_SUCCESS)) {
123 		struct pcpu_vstats *stats = this_cpu_ptr(dev->vstats);
124 
125 		u64_stats_update_begin(&stats->syncp);
126 		stats->bytes += length;
127 		stats->packets++;
128 		u64_stats_update_end(&stats->syncp);
129 	} else {
130 drop:
131 		atomic64_inc(&priv->dropped);
132 	}
133 	rcu_read_unlock();
134 	return NETDEV_TX_OK;
135 }
136 
137 /*
138  * general routines
139  */
140 
141 static u64 veth_stats_one(struct pcpu_vstats *result, struct net_device *dev)
142 {
143 	struct veth_priv *priv = netdev_priv(dev);
144 	int cpu;
145 
146 	result->packets = 0;
147 	result->bytes = 0;
148 	for_each_possible_cpu(cpu) {
149 		struct pcpu_vstats *stats = per_cpu_ptr(dev->vstats, cpu);
150 		u64 packets, bytes;
151 		unsigned int start;
152 
153 		do {
154 			start = u64_stats_fetch_begin_irq(&stats->syncp);
155 			packets = stats->packets;
156 			bytes = stats->bytes;
157 		} while (u64_stats_fetch_retry_irq(&stats->syncp, start));
158 		result->packets += packets;
159 		result->bytes += bytes;
160 	}
161 	return atomic64_read(&priv->dropped);
162 }
163 
164 static struct rtnl_link_stats64 *veth_get_stats64(struct net_device *dev,
165 						  struct rtnl_link_stats64 *tot)
166 {
167 	struct veth_priv *priv = netdev_priv(dev);
168 	struct net_device *peer;
169 	struct pcpu_vstats one;
170 
171 	tot->tx_dropped = veth_stats_one(&one, dev);
172 	tot->tx_bytes = one.bytes;
173 	tot->tx_packets = one.packets;
174 
175 	rcu_read_lock();
176 	peer = rcu_dereference(priv->peer);
177 	if (peer) {
178 		tot->rx_dropped = veth_stats_one(&one, peer);
179 		tot->rx_bytes = one.bytes;
180 		tot->rx_packets = one.packets;
181 	}
182 	rcu_read_unlock();
183 
184 	return tot;
185 }
186 
187 /* fake multicast ability */
188 static void veth_set_multicast_list(struct net_device *dev)
189 {
190 }
191 
192 static int veth_open(struct net_device *dev)
193 {
194 	struct veth_priv *priv = netdev_priv(dev);
195 	struct net_device *peer = rtnl_dereference(priv->peer);
196 
197 	if (!peer)
198 		return -ENOTCONN;
199 
200 	if (peer->flags & IFF_UP) {
201 		netif_carrier_on(dev);
202 		netif_carrier_on(peer);
203 	}
204 	return 0;
205 }
206 
207 static int veth_close(struct net_device *dev)
208 {
209 	struct veth_priv *priv = netdev_priv(dev);
210 	struct net_device *peer = rtnl_dereference(priv->peer);
211 
212 	netif_carrier_off(dev);
213 	if (peer)
214 		netif_carrier_off(peer);
215 
216 	return 0;
217 }
218 
219 static int is_valid_veth_mtu(int new_mtu)
220 {
221 	return new_mtu >= MIN_MTU && new_mtu <= MAX_MTU;
222 }
223 
224 static int veth_change_mtu(struct net_device *dev, int new_mtu)
225 {
226 	if (!is_valid_veth_mtu(new_mtu))
227 		return -EINVAL;
228 	dev->mtu = new_mtu;
229 	return 0;
230 }
231 
232 static int veth_dev_init(struct net_device *dev)
233 {
234 	dev->vstats = netdev_alloc_pcpu_stats(struct pcpu_vstats);
235 	if (!dev->vstats)
236 		return -ENOMEM;
237 	return 0;
238 }
239 
240 static void veth_dev_free(struct net_device *dev)
241 {
242 	free_percpu(dev->vstats);
243 	free_netdev(dev);
244 }
245 
246 #ifdef CONFIG_NET_POLL_CONTROLLER
247 static void veth_poll_controller(struct net_device *dev)
248 {
249 	/* veth only receives frames when its peer sends one
250 	 * Since it's a synchronous operation, we are guaranteed
251 	 * never to have pending data when we poll for it so
252 	 * there is nothing to do here.
253 	 *
254 	 * We need this though so netpoll recognizes us as an interface that
255 	 * supports polling, which enables bridge devices in virt setups to
256 	 * still use netconsole
257 	 */
258 }
259 #endif	/* CONFIG_NET_POLL_CONTROLLER */
260 
261 static int veth_get_iflink(const struct net_device *dev)
262 {
263 	struct veth_priv *priv = netdev_priv(dev);
264 	struct net_device *peer;
265 	int iflink;
266 
267 	rcu_read_lock();
268 	peer = rcu_dereference(priv->peer);
269 	iflink = peer ? peer->ifindex : 0;
270 	rcu_read_unlock();
271 
272 	return iflink;
273 }
274 
275 static void veth_set_rx_headroom(struct net_device *dev, int new_hr)
276 {
277 	struct veth_priv *peer_priv, *priv = netdev_priv(dev);
278 	struct net_device *peer;
279 
280 	if (new_hr < 0)
281 		new_hr = 0;
282 
283 	rcu_read_lock();
284 	peer = rcu_dereference(priv->peer);
285 	if (unlikely(!peer))
286 		goto out;
287 
288 	peer_priv = netdev_priv(peer);
289 	priv->requested_headroom = new_hr;
290 	new_hr = max(priv->requested_headroom, peer_priv->requested_headroom);
291 	dev->needed_headroom = new_hr;
292 	peer->needed_headroom = new_hr;
293 
294 out:
295 	rcu_read_unlock();
296 }
297 
298 static const struct net_device_ops veth_netdev_ops = {
299 	.ndo_init            = veth_dev_init,
300 	.ndo_open            = veth_open,
301 	.ndo_stop            = veth_close,
302 	.ndo_start_xmit      = veth_xmit,
303 	.ndo_change_mtu      = veth_change_mtu,
304 	.ndo_get_stats64     = veth_get_stats64,
305 	.ndo_set_rx_mode     = veth_set_multicast_list,
306 	.ndo_set_mac_address = eth_mac_addr,
307 #ifdef CONFIG_NET_POLL_CONTROLLER
308 	.ndo_poll_controller	= veth_poll_controller,
309 #endif
310 	.ndo_get_iflink		= veth_get_iflink,
311 	.ndo_features_check	= passthru_features_check,
312 	.ndo_set_rx_headroom	= veth_set_rx_headroom,
313 };
314 
315 #define VETH_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HW_CSUM | \
316 		       NETIF_F_RXCSUM | NETIF_F_SCTP_CRC | NETIF_F_HIGHDMA | \
317 		       NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ENCAP_ALL | \
318 		       NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX | \
319 		       NETIF_F_HW_VLAN_STAG_TX | NETIF_F_HW_VLAN_STAG_RX )
320 
321 static void veth_setup(struct net_device *dev)
322 {
323 	ether_setup(dev);
324 
325 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
326 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
327 	dev->priv_flags |= IFF_NO_QUEUE;
328 	dev->priv_flags |= IFF_PHONY_HEADROOM;
329 
330 	dev->netdev_ops = &veth_netdev_ops;
331 	dev->ethtool_ops = &veth_ethtool_ops;
332 	dev->features |= NETIF_F_LLTX;
333 	dev->features |= VETH_FEATURES;
334 	dev->vlan_features = dev->features &
335 			     ~(NETIF_F_HW_VLAN_CTAG_TX |
336 			       NETIF_F_HW_VLAN_STAG_TX |
337 			       NETIF_F_HW_VLAN_CTAG_RX |
338 			       NETIF_F_HW_VLAN_STAG_RX);
339 	dev->destructor = veth_dev_free;
340 
341 	dev->hw_features = VETH_FEATURES;
342 	dev->hw_enc_features = VETH_FEATURES;
343 	dev->mpls_features = NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE;
344 }
345 
346 /*
347  * netlink interface
348  */
349 
350 static int veth_validate(struct nlattr *tb[], struct nlattr *data[])
351 {
352 	if (tb[IFLA_ADDRESS]) {
353 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
354 			return -EINVAL;
355 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
356 			return -EADDRNOTAVAIL;
357 	}
358 	if (tb[IFLA_MTU]) {
359 		if (!is_valid_veth_mtu(nla_get_u32(tb[IFLA_MTU])))
360 			return -EINVAL;
361 	}
362 	return 0;
363 }
364 
365 static struct rtnl_link_ops veth_link_ops;
366 
367 static int veth_newlink(struct net *src_net, struct net_device *dev,
368 			 struct nlattr *tb[], struct nlattr *data[])
369 {
370 	int err;
371 	struct net_device *peer;
372 	struct veth_priv *priv;
373 	char ifname[IFNAMSIZ];
374 	struct nlattr *peer_tb[IFLA_MAX + 1], **tbp;
375 	unsigned char name_assign_type;
376 	struct ifinfomsg *ifmp;
377 	struct net *net;
378 
379 	/*
380 	 * create and register peer first
381 	 */
382 	if (data != NULL && data[VETH_INFO_PEER] != NULL) {
383 		struct nlattr *nla_peer;
384 
385 		nla_peer = data[VETH_INFO_PEER];
386 		ifmp = nla_data(nla_peer);
387 		err = rtnl_nla_parse_ifla(peer_tb,
388 					  nla_data(nla_peer) + sizeof(struct ifinfomsg),
389 					  nla_len(nla_peer) - sizeof(struct ifinfomsg));
390 		if (err < 0)
391 			return err;
392 
393 		err = veth_validate(peer_tb, NULL);
394 		if (err < 0)
395 			return err;
396 
397 		tbp = peer_tb;
398 	} else {
399 		ifmp = NULL;
400 		tbp = tb;
401 	}
402 
403 	if (tbp[IFLA_IFNAME]) {
404 		nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ);
405 		name_assign_type = NET_NAME_USER;
406 	} else {
407 		snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d");
408 		name_assign_type = NET_NAME_ENUM;
409 	}
410 
411 	net = rtnl_link_get_net(src_net, tbp);
412 	if (IS_ERR(net))
413 		return PTR_ERR(net);
414 
415 	peer = rtnl_create_link(net, ifname, name_assign_type,
416 				&veth_link_ops, tbp);
417 	if (IS_ERR(peer)) {
418 		put_net(net);
419 		return PTR_ERR(peer);
420 	}
421 
422 	if (tbp[IFLA_ADDRESS] == NULL)
423 		eth_hw_addr_random(peer);
424 
425 	if (ifmp && (dev->ifindex != 0))
426 		peer->ifindex = ifmp->ifi_index;
427 
428 	err = register_netdevice(peer);
429 	put_net(net);
430 	net = NULL;
431 	if (err < 0)
432 		goto err_register_peer;
433 
434 	netif_carrier_off(peer);
435 
436 	err = rtnl_configure_link(peer, ifmp);
437 	if (err < 0)
438 		goto err_configure_peer;
439 
440 	/*
441 	 * register dev last
442 	 *
443 	 * note, that since we've registered new device the dev's name
444 	 * should be re-allocated
445 	 */
446 
447 	if (tb[IFLA_ADDRESS] == NULL)
448 		eth_hw_addr_random(dev);
449 
450 	if (tb[IFLA_IFNAME])
451 		nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
452 	else
453 		snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d");
454 
455 	err = register_netdevice(dev);
456 	if (err < 0)
457 		goto err_register_dev;
458 
459 	netif_carrier_off(dev);
460 
461 	/*
462 	 * tie the deviced together
463 	 */
464 
465 	priv = netdev_priv(dev);
466 	rcu_assign_pointer(priv->peer, peer);
467 
468 	priv = netdev_priv(peer);
469 	rcu_assign_pointer(priv->peer, dev);
470 	return 0;
471 
472 err_register_dev:
473 	/* nothing to do */
474 err_configure_peer:
475 	unregister_netdevice(peer);
476 	return err;
477 
478 err_register_peer:
479 	free_netdev(peer);
480 	return err;
481 }
482 
483 static void veth_dellink(struct net_device *dev, struct list_head *head)
484 {
485 	struct veth_priv *priv;
486 	struct net_device *peer;
487 
488 	priv = netdev_priv(dev);
489 	peer = rtnl_dereference(priv->peer);
490 
491 	/* Note : dellink() is called from default_device_exit_batch(),
492 	 * before a rcu_synchronize() point. The devices are guaranteed
493 	 * not being freed before one RCU grace period.
494 	 */
495 	RCU_INIT_POINTER(priv->peer, NULL);
496 	unregister_netdevice_queue(dev, head);
497 
498 	if (peer) {
499 		priv = netdev_priv(peer);
500 		RCU_INIT_POINTER(priv->peer, NULL);
501 		unregister_netdevice_queue(peer, head);
502 	}
503 }
504 
505 static const struct nla_policy veth_policy[VETH_INFO_MAX + 1] = {
506 	[VETH_INFO_PEER]	= { .len = sizeof(struct ifinfomsg) },
507 };
508 
509 static struct net *veth_get_link_net(const struct net_device *dev)
510 {
511 	struct veth_priv *priv = netdev_priv(dev);
512 	struct net_device *peer = rtnl_dereference(priv->peer);
513 
514 	return peer ? dev_net(peer) : dev_net(dev);
515 }
516 
517 static struct rtnl_link_ops veth_link_ops = {
518 	.kind		= DRV_NAME,
519 	.priv_size	= sizeof(struct veth_priv),
520 	.setup		= veth_setup,
521 	.validate	= veth_validate,
522 	.newlink	= veth_newlink,
523 	.dellink	= veth_dellink,
524 	.policy		= veth_policy,
525 	.maxtype	= VETH_INFO_MAX,
526 	.get_link_net	= veth_get_link_net,
527 };
528 
529 /*
530  * init/fini
531  */
532 
533 static __init int veth_init(void)
534 {
535 	return rtnl_link_register(&veth_link_ops);
536 }
537 
538 static __exit void veth_exit(void)
539 {
540 	rtnl_link_unregister(&veth_link_ops);
541 }
542 
543 module_init(veth_init);
544 module_exit(veth_exit);
545 
546 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
547 MODULE_LICENSE("GPL v2");
548 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
549