blob: 852d0e7c4e62abbfb13421664293dd70182c4126 [file] [log] [blame]
Pavel Emelyanove314dbd2007-09-25 16:14:46 -07001/*
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
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070011#include <linux/netdevice.h>
12#include <linux/ethtool.h>
13#include <linux/etherdevice.h>
14
15#include <net/dst.h>
16#include <net/xfrm.h>
Stephen Hemmingerecef9692007-12-25 17:23:59 -080017#include <linux/veth.h>
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070018
19#define DRV_NAME "veth"
20#define DRV_VERSION "1.0"
21
22struct veth_net_stats {
23 unsigned long rx_packets;
24 unsigned long tx_packets;
25 unsigned long rx_bytes;
26 unsigned long tx_bytes;
27 unsigned long tx_dropped;
28};
29
30struct veth_priv {
31 struct net_device *peer;
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070032 struct veth_net_stats *stats;
33 unsigned ip_summed;
34};
35
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070036/*
37 * ethtool interface
38 */
39
40static struct {
41 const char string[ETH_GSTRING_LEN];
42} ethtool_stats_keys[] = {
43 { "peer_ifindex" },
44};
45
46static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
47{
48 cmd->supported = 0;
49 cmd->advertising = 0;
50 cmd->speed = SPEED_10000;
51 cmd->duplex = DUPLEX_FULL;
52 cmd->port = PORT_TP;
53 cmd->phy_address = 0;
54 cmd->transceiver = XCVR_INTERNAL;
55 cmd->autoneg = AUTONEG_DISABLE;
56 cmd->maxtxpkt = 0;
57 cmd->maxrxpkt = 0;
58 return 0;
59}
60
61static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
62{
63 strcpy(info->driver, DRV_NAME);
64 strcpy(info->version, DRV_VERSION);
65 strcpy(info->fw_version, "N/A");
66}
67
68static void veth_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
69{
70 switch(stringset) {
71 case ETH_SS_STATS:
72 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
73 break;
74 }
75}
76
Jeff Garzikb9f2c042007-10-03 18:07:32 -070077static int veth_get_sset_count(struct net_device *dev, int sset)
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070078{
Jeff Garzikb9f2c042007-10-03 18:07:32 -070079 switch (sset) {
80 case ETH_SS_STATS:
81 return ARRAY_SIZE(ethtool_stats_keys);
82 default:
83 return -EOPNOTSUPP;
84 }
Pavel Emelyanove314dbd2007-09-25 16:14:46 -070085}
86
87static void veth_get_ethtool_stats(struct net_device *dev,
88 struct ethtool_stats *stats, u64 *data)
89{
90 struct veth_priv *priv;
91
92 priv = netdev_priv(dev);
93 data[0] = priv->peer->ifindex;
94}
95
96static u32 veth_get_rx_csum(struct net_device *dev)
97{
98 struct veth_priv *priv;
99
100 priv = netdev_priv(dev);
101 return priv->ip_summed == CHECKSUM_UNNECESSARY;
102}
103
104static int veth_set_rx_csum(struct net_device *dev, u32 data)
105{
106 struct veth_priv *priv;
107
108 priv = netdev_priv(dev);
109 priv->ip_summed = data ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE;
110 return 0;
111}
112
113static u32 veth_get_tx_csum(struct net_device *dev)
114{
115 return (dev->features & NETIF_F_NO_CSUM) != 0;
116}
117
118static int veth_set_tx_csum(struct net_device *dev, u32 data)
119{
120 if (data)
121 dev->features |= NETIF_F_NO_CSUM;
122 else
123 dev->features &= ~NETIF_F_NO_CSUM;
124 return 0;
125}
126
127static struct ethtool_ops veth_ethtool_ops = {
128 .get_settings = veth_get_settings,
129 .get_drvinfo = veth_get_drvinfo,
130 .get_link = ethtool_op_get_link,
131 .get_rx_csum = veth_get_rx_csum,
132 .set_rx_csum = veth_set_rx_csum,
133 .get_tx_csum = veth_get_tx_csum,
134 .set_tx_csum = veth_set_tx_csum,
135 .get_sg = ethtool_op_get_sg,
136 .set_sg = ethtool_op_set_sg,
137 .get_strings = veth_get_strings,
Jeff Garzikb9f2c042007-10-03 18:07:32 -0700138 .get_sset_count = veth_get_sset_count,
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700139 .get_ethtool_stats = veth_get_ethtool_stats,
140};
141
142/*
143 * xmit
144 */
145
146static int veth_xmit(struct sk_buff *skb, struct net_device *dev)
147{
148 struct net_device *rcv = NULL;
149 struct veth_priv *priv, *rcv_priv;
150 struct veth_net_stats *stats;
151 int length, cpu;
152
153 skb_orphan(skb);
154
155 priv = netdev_priv(dev);
156 rcv = priv->peer;
157 rcv_priv = netdev_priv(rcv);
158
159 cpu = smp_processor_id();
160 stats = per_cpu_ptr(priv->stats, cpu);
161
162 if (!(rcv->flags & IFF_UP))
163 goto outf;
164
165 skb->pkt_type = PACKET_HOST;
166 skb->protocol = eth_type_trans(skb, rcv);
167 if (dev->features & NETIF_F_NO_CSUM)
168 skb->ip_summed = rcv_priv->ip_summed;
169
170 dst_release(skb->dst);
171 skb->dst = NULL;
172 skb->mark = 0;
173 secpath_reset(skb);
174 nf_reset(skb);
175
176 length = skb->len;
177
178 stats->tx_bytes += length;
179 stats->tx_packets++;
180
181 stats = per_cpu_ptr(rcv_priv->stats, cpu);
182 stats->rx_bytes += length;
183 stats->rx_packets++;
184
185 netif_rx(skb);
186 return 0;
187
188outf:
189 kfree_skb(skb);
190 stats->tx_dropped++;
191 return 0;
192}
193
194/*
195 * general routines
196 */
197
198static struct net_device_stats *veth_get_stats(struct net_device *dev)
199{
200 struct veth_priv *priv;
201 struct net_device_stats *dev_stats;
202 int cpu;
203 struct veth_net_stats *stats;
204
205 priv = netdev_priv(dev);
206 dev_stats = &dev->stats;
207
208 dev_stats->rx_packets = 0;
209 dev_stats->tx_packets = 0;
210 dev_stats->rx_bytes = 0;
211 dev_stats->tx_bytes = 0;
212 dev_stats->tx_dropped = 0;
213
214 for_each_online_cpu(cpu) {
215 stats = per_cpu_ptr(priv->stats, cpu);
216
217 dev_stats->rx_packets += stats->rx_packets;
218 dev_stats->tx_packets += stats->tx_packets;
219 dev_stats->rx_bytes += stats->rx_bytes;
220 dev_stats->tx_bytes += stats->tx_bytes;
221 dev_stats->tx_dropped += stats->tx_dropped;
222 }
223
224 return dev_stats;
225}
226
227static int veth_open(struct net_device *dev)
228{
229 struct veth_priv *priv;
230
231 priv = netdev_priv(dev);
232 if (priv->peer == NULL)
233 return -ENOTCONN;
234
235 if (priv->peer->flags & IFF_UP) {
236 netif_carrier_on(dev);
237 netif_carrier_on(priv->peer);
238 }
239 return 0;
240}
241
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700242static int veth_dev_init(struct net_device *dev)
243{
244 struct veth_net_stats *stats;
245 struct veth_priv *priv;
246
247 stats = alloc_percpu(struct veth_net_stats);
248 if (stats == NULL)
249 return -ENOMEM;
250
251 priv = netdev_priv(dev);
252 priv->stats = stats;
253 return 0;
254}
255
256static void veth_dev_free(struct net_device *dev)
257{
258 struct veth_priv *priv;
259
260 priv = netdev_priv(dev);
261 free_percpu(priv->stats);
262 free_netdev(dev);
263}
264
Stephen Hemminger4456e7b2008-11-19 21:50:10 -0800265static const struct net_device_ops veth_netdev_ops = {
266 .ndo_init = veth_dev_init,
267 .ndo_open = veth_open,
Stephen Hemminger00829822008-11-20 20:14:53 -0800268 .ndo_start_xmit = veth_xmit,
Stephen Hemminger4456e7b2008-11-19 21:50:10 -0800269 .ndo_get_stats = veth_get_stats,
270};
271
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700272static void veth_setup(struct net_device *dev)
273{
274 ether_setup(dev);
275
Stephen Hemminger4456e7b2008-11-19 21:50:10 -0800276 dev->netdev_ops = &veth_netdev_ops;
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700277 dev->ethtool_ops = &veth_ethtool_ops;
278 dev->features |= NETIF_F_LLTX;
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700279 dev->destructor = veth_dev_free;
280}
281
Daniel Lezcanoc15853f2008-02-20 00:21:47 -0800282static void veth_change_state(struct net_device *dev)
283{
284 struct net_device *peer;
285 struct veth_priv *priv;
286
287 priv = netdev_priv(dev);
288 peer = priv->peer;
289
290 if (netif_carrier_ok(peer)) {
291 if (!netif_carrier_ok(dev))
292 netif_carrier_on(dev);
293 } else {
294 if (netif_carrier_ok(dev))
295 netif_carrier_off(dev);
296 }
297}
298
299static int veth_device_event(struct notifier_block *unused,
300 unsigned long event, void *ptr)
301{
302 struct net_device *dev = ptr;
303
Stephen Hemminger4456e7b2008-11-19 21:50:10 -0800304 if (dev->netdev_ops->ndo_open != veth_open)
Daniel Lezcanoc15853f2008-02-20 00:21:47 -0800305 goto out;
306
307 switch (event) {
308 case NETDEV_CHANGE:
309 veth_change_state(dev);
310 break;
311 }
312out:
313 return NOTIFY_DONE;
314}
315
316static struct notifier_block veth_notifier_block __read_mostly = {
317 .notifier_call = veth_device_event,
318};
319
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700320/*
321 * netlink interface
322 */
323
324static int veth_validate(struct nlattr *tb[], struct nlattr *data[])
325{
326 if (tb[IFLA_ADDRESS]) {
327 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
328 return -EINVAL;
329 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
330 return -EADDRNOTAVAIL;
331 }
332 return 0;
333}
334
335static struct rtnl_link_ops veth_link_ops;
336
337static int veth_newlink(struct net_device *dev,
338 struct nlattr *tb[], struct nlattr *data[])
339{
340 int err;
341 struct net_device *peer;
342 struct veth_priv *priv;
343 char ifname[IFNAMSIZ];
344 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp;
345
346 /*
347 * create and register peer first
348 *
349 * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
350 * skip it since no info from it is useful yet
351 */
352
353 if (data != NULL && data[VETH_INFO_PEER] != NULL) {
354 struct nlattr *nla_peer;
355
356 nla_peer = data[VETH_INFO_PEER];
357 err = nla_parse(peer_tb, IFLA_MAX,
358 nla_data(nla_peer) + sizeof(struct ifinfomsg),
359 nla_len(nla_peer) - sizeof(struct ifinfomsg),
360 ifla_policy);
361 if (err < 0)
362 return err;
363
364 err = veth_validate(peer_tb, NULL);
365 if (err < 0)
366 return err;
367
368 tbp = peer_tb;
369 } else
370 tbp = tb;
371
372 if (tbp[IFLA_IFNAME])
373 nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ);
374 else
375 snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d");
376
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900377 peer = rtnl_create_link(dev_net(dev), ifname, &veth_link_ops, tbp);
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700378 if (IS_ERR(peer))
379 return PTR_ERR(peer);
380
381 if (tbp[IFLA_ADDRESS] == NULL)
382 random_ether_addr(peer->dev_addr);
383
384 err = register_netdevice(peer);
385 if (err < 0)
386 goto err_register_peer;
387
388 netif_carrier_off(peer);
389
390 /*
391 * register dev last
392 *
393 * note, that since we've registered new device the dev's name
394 * should be re-allocated
395 */
396
397 if (tb[IFLA_ADDRESS] == NULL)
398 random_ether_addr(dev->dev_addr);
399
400 if (tb[IFLA_IFNAME])
401 nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
402 else
403 snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d");
404
405 if (strchr(dev->name, '%')) {
406 err = dev_alloc_name(dev, dev->name);
407 if (err < 0)
408 goto err_alloc_name;
409 }
410
411 err = register_netdevice(dev);
412 if (err < 0)
413 goto err_register_dev;
414
415 netif_carrier_off(dev);
416
417 /*
418 * tie the deviced together
419 */
420
421 priv = netdev_priv(dev);
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700422 priv->peer = peer;
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700423
424 priv = netdev_priv(peer);
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700425 priv->peer = dev;
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700426 return 0;
427
428err_register_dev:
429 /* nothing to do */
430err_alloc_name:
431 unregister_netdevice(peer);
432 return err;
433
434err_register_peer:
435 free_netdev(peer);
436 return err;
437}
438
439static void veth_dellink(struct net_device *dev)
440{
441 struct veth_priv *priv;
442 struct net_device *peer;
443
444 priv = netdev_priv(dev);
445 peer = priv->peer;
446
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700447 unregister_netdevice(dev);
448 unregister_netdevice(peer);
449}
450
451static const struct nla_policy veth_policy[VETH_INFO_MAX + 1];
452
453static struct rtnl_link_ops veth_link_ops = {
454 .kind = DRV_NAME,
455 .priv_size = sizeof(struct veth_priv),
456 .setup = veth_setup,
457 .validate = veth_validate,
458 .newlink = veth_newlink,
459 .dellink = veth_dellink,
460 .policy = veth_policy,
461 .maxtype = VETH_INFO_MAX,
462};
463
464/*
465 * init/fini
466 */
467
468static __init int veth_init(void)
469{
Daniel Lezcanoc15853f2008-02-20 00:21:47 -0800470 register_netdevice_notifier(&veth_notifier_block);
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700471 return rtnl_link_register(&veth_link_ops);
472}
473
474static __exit void veth_exit(void)
475{
Patrick McHardy68365452008-01-20 17:25:14 -0800476 rtnl_link_unregister(&veth_link_ops);
Daniel Lezcanoc15853f2008-02-20 00:21:47 -0800477 unregister_netdevice_notifier(&veth_notifier_block);
Pavel Emelyanove314dbd2007-09-25 16:14:46 -0700478}
479
480module_init(veth_init);
481module_exit(veth_exit);
482
483MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
484MODULE_LICENSE("GPL v2");
485MODULE_ALIAS_RTNL_LINK(DRV_NAME);