4 * Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc
6 * Author: Pavel Emelianov <xemul@openvz.org>
7 * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com>
11 #include <linux/netdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/etherdevice.h>
17 #include <linux/veth.h>
19 #define DRV_NAME "veth"
20 #define DRV_VERSION "1.0"
22 struct 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
;
31 struct net_device
*peer
;
32 struct veth_net_stats
*stats
;
41 const char string
[ETH_GSTRING_LEN
];
42 } ethtool_stats_keys
[] = {
46 static int veth_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
50 cmd
->speed
= SPEED_10000
;
51 cmd
->duplex
= DUPLEX_FULL
;
54 cmd
->transceiver
= XCVR_INTERNAL
;
55 cmd
->autoneg
= AUTONEG_DISABLE
;
61 static void veth_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
63 strcpy(info
->driver
, DRV_NAME
);
64 strcpy(info
->version
, DRV_VERSION
);
65 strcpy(info
->fw_version
, "N/A");
68 static void veth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*buf
)
72 memcpy(buf
, ðtool_stats_keys
, sizeof(ethtool_stats_keys
));
77 static int veth_get_sset_count(struct net_device
*dev
, int sset
)
81 return ARRAY_SIZE(ethtool_stats_keys
);
87 static void veth_get_ethtool_stats(struct net_device
*dev
,
88 struct ethtool_stats
*stats
, u64
*data
)
90 struct veth_priv
*priv
;
92 priv
= netdev_priv(dev
);
93 data
[0] = priv
->peer
->ifindex
;
96 static u32
veth_get_rx_csum(struct net_device
*dev
)
98 struct veth_priv
*priv
;
100 priv
= netdev_priv(dev
);
101 return priv
->ip_summed
== CHECKSUM_UNNECESSARY
;
104 static int veth_set_rx_csum(struct net_device
*dev
, u32 data
)
106 struct veth_priv
*priv
;
108 priv
= netdev_priv(dev
);
109 priv
->ip_summed
= data
? CHECKSUM_UNNECESSARY
: CHECKSUM_NONE
;
113 static u32
veth_get_tx_csum(struct net_device
*dev
)
115 return (dev
->features
& NETIF_F_NO_CSUM
) != 0;
118 static int veth_set_tx_csum(struct net_device
*dev
, u32 data
)
121 dev
->features
|= NETIF_F_NO_CSUM
;
123 dev
->features
&= ~NETIF_F_NO_CSUM
;
127 static 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
,
138 .get_sset_count
= veth_get_sset_count
,
139 .get_ethtool_stats
= veth_get_ethtool_stats
,
146 static int veth_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
148 struct net_device
*rcv
= NULL
;
149 struct veth_priv
*priv
, *rcv_priv
;
150 struct veth_net_stats
*stats
;
155 priv
= netdev_priv(dev
);
157 rcv_priv
= netdev_priv(rcv
);
159 cpu
= smp_processor_id();
160 stats
= per_cpu_ptr(priv
->stats
, cpu
);
162 if (!(rcv
->flags
& IFF_UP
))
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
;
170 dst_release(skb
->dst
);
178 stats
->tx_bytes
+= length
;
181 stats
= per_cpu_ptr(rcv_priv
->stats
, cpu
);
182 stats
->rx_bytes
+= length
;
198 static struct net_device_stats
*veth_get_stats(struct net_device
*dev
)
200 struct veth_priv
*priv
;
201 struct net_device_stats
*dev_stats
;
203 struct veth_net_stats
*stats
;
205 priv
= netdev_priv(dev
);
206 dev_stats
= &dev
->stats
;
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;
214 for_each_online_cpu(cpu
) {
215 stats
= per_cpu_ptr(priv
->stats
, cpu
);
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
;
227 static int veth_open(struct net_device
*dev
)
229 struct veth_priv
*priv
;
231 priv
= netdev_priv(dev
);
232 if (priv
->peer
== NULL
)
235 if (priv
->peer
->flags
& IFF_UP
) {
236 netif_carrier_on(dev
);
237 netif_carrier_on(priv
->peer
);
242 static int veth_dev_init(struct net_device
*dev
)
244 struct veth_net_stats
*stats
;
245 struct veth_priv
*priv
;
247 stats
= alloc_percpu(struct veth_net_stats
);
251 priv
= netdev_priv(dev
);
256 static void veth_dev_free(struct net_device
*dev
)
258 struct veth_priv
*priv
;
260 priv
= netdev_priv(dev
);
261 free_percpu(priv
->stats
);
265 static const struct net_device_ops veth_netdev_ops
= {
266 .ndo_init
= veth_dev_init
,
267 .ndo_open
= veth_open
,
268 .ndo_start_xmit
= veth_xmit
,
269 .ndo_get_stats
= veth_get_stats
,
270 .ndo_set_mac_address
= eth_mac_addr
,
273 static void veth_setup(struct net_device
*dev
)
277 dev
->netdev_ops
= &veth_netdev_ops
;
278 dev
->ethtool_ops
= &veth_ethtool_ops
;
279 dev
->features
|= NETIF_F_LLTX
;
280 dev
->destructor
= veth_dev_free
;
283 static void veth_change_state(struct net_device
*dev
)
285 struct net_device
*peer
;
286 struct veth_priv
*priv
;
288 priv
= netdev_priv(dev
);
291 if (netif_carrier_ok(peer
)) {
292 if (!netif_carrier_ok(dev
))
293 netif_carrier_on(dev
);
295 if (netif_carrier_ok(dev
))
296 netif_carrier_off(dev
);
300 static int veth_device_event(struct notifier_block
*unused
,
301 unsigned long event
, void *ptr
)
303 struct net_device
*dev
= ptr
;
305 if (dev
->netdev_ops
->ndo_open
!= veth_open
)
310 veth_change_state(dev
);
317 static struct notifier_block veth_notifier_block __read_mostly
= {
318 .notifier_call
= veth_device_event
,
325 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
327 if (tb
[IFLA_ADDRESS
]) {
328 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
330 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
331 return -EADDRNOTAVAIL
;
336 static struct rtnl_link_ops veth_link_ops
;
338 static int veth_newlink(struct net_device
*dev
,
339 struct nlattr
*tb
[], struct nlattr
*data
[])
342 struct net_device
*peer
;
343 struct veth_priv
*priv
;
344 char ifname
[IFNAMSIZ
];
345 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
348 * create and register peer first
350 * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
351 * skip it since no info from it is useful yet
354 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
355 struct nlattr
*nla_peer
;
357 nla_peer
= data
[VETH_INFO_PEER
];
358 err
= nla_parse(peer_tb
, IFLA_MAX
,
359 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
360 nla_len(nla_peer
) - sizeof(struct ifinfomsg
),
365 err
= veth_validate(peer_tb
, NULL
);
373 if (tbp
[IFLA_IFNAME
])
374 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
376 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
378 peer
= rtnl_create_link(dev_net(dev
), ifname
, &veth_link_ops
, tbp
);
380 return PTR_ERR(peer
);
382 if (tbp
[IFLA_ADDRESS
] == NULL
)
383 random_ether_addr(peer
->dev_addr
);
385 err
= register_netdevice(peer
);
387 goto err_register_peer
;
389 netif_carrier_off(peer
);
394 * note, that since we've registered new device the dev's name
395 * should be re-allocated
398 if (tb
[IFLA_ADDRESS
] == NULL
)
399 random_ether_addr(dev
->dev_addr
);
402 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
404 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
406 if (strchr(dev
->name
, '%')) {
407 err
= dev_alloc_name(dev
, dev
->name
);
412 err
= register_netdevice(dev
);
414 goto err_register_dev
;
416 netif_carrier_off(dev
);
419 * tie the deviced together
422 priv
= netdev_priv(dev
);
425 priv
= netdev_priv(peer
);
432 unregister_netdevice(peer
);
440 static void veth_dellink(struct net_device
*dev
)
442 struct veth_priv
*priv
;
443 struct net_device
*peer
;
445 priv
= netdev_priv(dev
);
448 unregister_netdevice(dev
);
449 unregister_netdevice(peer
);
452 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1];
454 static struct rtnl_link_ops veth_link_ops
= {
456 .priv_size
= sizeof(struct veth_priv
),
458 .validate
= veth_validate
,
459 .newlink
= veth_newlink
,
460 .dellink
= veth_dellink
,
461 .policy
= veth_policy
,
462 .maxtype
= VETH_INFO_MAX
,
469 static __init
int veth_init(void)
471 register_netdevice_notifier(&veth_notifier_block
);
472 return rtnl_link_register(&veth_link_ops
);
475 static __exit
void veth_exit(void)
477 rtnl_link_unregister(&veth_link_ops
);
478 unregister_netdevice_notifier(&veth_notifier_block
);
481 module_init(veth_init
);
482 module_exit(veth_exit
);
484 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
485 MODULE_LICENSE("GPL v2");
486 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);