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/slab.h>
13 #include <linux/ethtool.h>
14 #include <linux/etherdevice.h>
15 #include <linux/u64_stats_sync.h>
19 #include <linux/veth.h>
20 #include <linux/module.h>
22 #define DRV_NAME "veth"
23 #define DRV_VERSION "1.0"
25 #define MIN_MTU 68 /* Min L3 MTU */
26 #define MAX_MTU 65535 /* Max L3 MTU (arbitrary) */
31 struct u64_stats_sync syncp
;
35 struct net_device __rcu
*peer
;
44 const char string
[ETH_GSTRING_LEN
];
45 } ethtool_stats_keys
[] = {
49 static int veth_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
53 ethtool_cmd_speed_set(cmd
, SPEED_10000
);
54 cmd
->duplex
= DUPLEX_FULL
;
57 cmd
->transceiver
= XCVR_INTERNAL
;
58 cmd
->autoneg
= AUTONEG_DISABLE
;
64 static void veth_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
66 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
67 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
70 static void veth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*buf
)
74 memcpy(buf
, ðtool_stats_keys
, sizeof(ethtool_stats_keys
));
79 static int veth_get_sset_count(struct net_device
*dev
, int sset
)
83 return ARRAY_SIZE(ethtool_stats_keys
);
89 static void veth_get_ethtool_stats(struct net_device
*dev
,
90 struct ethtool_stats
*stats
, u64
*data
)
92 struct veth_priv
*priv
= netdev_priv(dev
);
93 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
95 data
[0] = peer
? peer
->ifindex
: 0;
98 static const struct ethtool_ops veth_ethtool_ops
= {
99 .get_settings
= veth_get_settings
,
100 .get_drvinfo
= veth_get_drvinfo
,
101 .get_link
= ethtool_op_get_link
,
102 .get_strings
= veth_get_strings
,
103 .get_sset_count
= veth_get_sset_count
,
104 .get_ethtool_stats
= veth_get_ethtool_stats
,
107 static netdev_tx_t
veth_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
109 struct veth_priv
*priv
= netdev_priv(dev
);
110 struct net_device
*rcv
;
111 int length
= skb
->len
;
114 rcv
= rcu_dereference(priv
->peer
);
115 if (unlikely(!rcv
)) {
119 /* don't change ip_summed == CHECKSUM_PARTIAL, as that
120 * will cause bad checksum on forwarded packets
122 if (skb
->ip_summed
== CHECKSUM_NONE
&&
123 rcv
->features
& NETIF_F_RXCSUM
)
124 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
126 if (likely(dev_forward_skb(rcv
, skb
) == NET_RX_SUCCESS
)) {
127 struct pcpu_vstats
*stats
= this_cpu_ptr(dev
->vstats
);
129 u64_stats_update_begin(&stats
->syncp
);
130 stats
->bytes
+= length
;
132 u64_stats_update_end(&stats
->syncp
);
135 atomic64_inc(&priv
->dropped
);
145 static u64
veth_stats_one(struct pcpu_vstats
*result
, struct net_device
*dev
)
147 struct veth_priv
*priv
= netdev_priv(dev
);
152 for_each_possible_cpu(cpu
) {
153 struct pcpu_vstats
*stats
= per_cpu_ptr(dev
->vstats
, cpu
);
158 start
= u64_stats_fetch_begin_bh(&stats
->syncp
);
159 packets
= stats
->packets
;
160 bytes
= stats
->bytes
;
161 } while (u64_stats_fetch_retry_bh(&stats
->syncp
, start
));
162 result
->packets
+= packets
;
163 result
->bytes
+= bytes
;
165 return atomic64_read(&priv
->dropped
);
168 static struct rtnl_link_stats64
*veth_get_stats64(struct net_device
*dev
,
169 struct rtnl_link_stats64
*tot
)
171 struct veth_priv
*priv
= netdev_priv(dev
);
172 struct net_device
*peer
;
173 struct pcpu_vstats one
;
175 tot
->tx_dropped
= veth_stats_one(&one
, dev
);
176 tot
->tx_bytes
= one
.bytes
;
177 tot
->tx_packets
= one
.packets
;
180 peer
= rcu_dereference(priv
->peer
);
182 tot
->rx_dropped
= veth_stats_one(&one
, peer
);
183 tot
->rx_bytes
= one
.bytes
;
184 tot
->rx_packets
= one
.packets
;
191 static int veth_open(struct net_device
*dev
)
193 struct veth_priv
*priv
= netdev_priv(dev
);
194 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
199 if (peer
->flags
& IFF_UP
) {
200 netif_carrier_on(dev
);
201 netif_carrier_on(peer
);
206 static int veth_close(struct net_device
*dev
)
208 struct veth_priv
*priv
= netdev_priv(dev
);
209 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
211 netif_carrier_off(dev
);
213 netif_carrier_off(peer
);
218 static int is_valid_veth_mtu(int new_mtu
)
220 return new_mtu
>= MIN_MTU
&& new_mtu
<= MAX_MTU
;
223 static int veth_change_mtu(struct net_device
*dev
, int new_mtu
)
225 if (!is_valid_veth_mtu(new_mtu
))
231 static int veth_dev_init(struct net_device
*dev
)
235 dev
->vstats
= alloc_percpu(struct pcpu_vstats
);
239 for_each_possible_cpu(i
) {
240 struct pcpu_vstats
*veth_stats
;
241 veth_stats
= per_cpu_ptr(dev
->vstats
, i
);
242 u64_stats_init(&veth_stats
->syncp
);
248 static void veth_dev_free(struct net_device
*dev
)
250 free_percpu(dev
->vstats
);
254 static const struct net_device_ops veth_netdev_ops
= {
255 .ndo_init
= veth_dev_init
,
256 .ndo_open
= veth_open
,
257 .ndo_stop
= veth_close
,
258 .ndo_start_xmit
= veth_xmit
,
259 .ndo_change_mtu
= veth_change_mtu
,
260 .ndo_get_stats64
= veth_get_stats64
,
261 .ndo_set_mac_address
= eth_mac_addr
,
264 #define VETH_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
265 NETIF_F_HW_CSUM | NETIF_F_RXCSUM | NETIF_F_HIGHDMA | \
266 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX | \
267 NETIF_F_HW_VLAN_STAG_TX | NETIF_F_HW_VLAN_STAG_RX )
269 static void veth_setup(struct net_device
*dev
)
273 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
274 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
276 dev
->netdev_ops
= &veth_netdev_ops
;
277 dev
->ethtool_ops
= &veth_ethtool_ops
;
278 dev
->features
|= NETIF_F_LLTX
;
279 dev
->features
|= VETH_FEATURES
;
280 dev
->vlan_features
= dev
->features
;
281 dev
->destructor
= veth_dev_free
;
283 dev
->hw_features
= VETH_FEATURES
;
290 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
292 if (tb
[IFLA_ADDRESS
]) {
293 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
295 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
296 return -EADDRNOTAVAIL
;
299 if (!is_valid_veth_mtu(nla_get_u32(tb
[IFLA_MTU
])))
305 static struct rtnl_link_ops veth_link_ops
;
307 static int veth_newlink(struct net
*src_net
, struct net_device
*dev
,
308 struct nlattr
*tb
[], struct nlattr
*data
[])
311 struct net_device
*peer
;
312 struct veth_priv
*priv
;
313 char ifname
[IFNAMSIZ
];
314 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
315 struct ifinfomsg
*ifmp
;
319 * create and register peer first
321 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
322 struct nlattr
*nla_peer
;
324 nla_peer
= data
[VETH_INFO_PEER
];
325 ifmp
= nla_data(nla_peer
);
326 err
= nla_parse(peer_tb
, IFLA_MAX
,
327 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
328 nla_len(nla_peer
) - sizeof(struct ifinfomsg
),
333 err
= veth_validate(peer_tb
, NULL
);
343 if (tbp
[IFLA_IFNAME
])
344 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
346 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
348 net
= rtnl_link_get_net(src_net
, tbp
);
352 peer
= rtnl_create_link(net
, ifname
, &veth_link_ops
, tbp
);
355 return PTR_ERR(peer
);
358 if (tbp
[IFLA_ADDRESS
] == NULL
)
359 eth_hw_addr_random(peer
);
361 if (ifmp
&& (dev
->ifindex
!= 0))
362 peer
->ifindex
= ifmp
->ifi_index
;
364 err
= register_netdevice(peer
);
368 goto err_register_peer
;
370 netif_carrier_off(peer
);
372 err
= rtnl_configure_link(peer
, ifmp
);
374 goto err_configure_peer
;
379 * note, that since we've registered new device the dev's name
380 * should be re-allocated
383 if (tb
[IFLA_ADDRESS
] == NULL
)
384 eth_hw_addr_random(dev
);
387 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
389 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
391 err
= register_netdevice(dev
);
393 goto err_register_dev
;
395 netif_carrier_off(dev
);
398 * tie the deviced together
401 priv
= netdev_priv(dev
);
402 rcu_assign_pointer(priv
->peer
, peer
);
404 priv
= netdev_priv(peer
);
405 rcu_assign_pointer(priv
->peer
, dev
);
411 unregister_netdevice(peer
);
419 static void veth_dellink(struct net_device
*dev
, struct list_head
*head
)
421 struct veth_priv
*priv
;
422 struct net_device
*peer
;
424 priv
= netdev_priv(dev
);
425 peer
= rtnl_dereference(priv
->peer
);
427 /* Note : dellink() is called from default_device_exit_batch(),
428 * before a rcu_synchronize() point. The devices are guaranteed
429 * not being freed before one RCU grace period.
431 RCU_INIT_POINTER(priv
->peer
, NULL
);
432 unregister_netdevice_queue(dev
, head
);
435 priv
= netdev_priv(peer
);
436 RCU_INIT_POINTER(priv
->peer
, NULL
);
437 unregister_netdevice_queue(peer
, head
);
441 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1] = {
442 [VETH_INFO_PEER
] = { .len
= sizeof(struct ifinfomsg
) },
445 static struct rtnl_link_ops veth_link_ops
= {
447 .priv_size
= sizeof(struct veth_priv
),
449 .validate
= veth_validate
,
450 .newlink
= veth_newlink
,
451 .dellink
= veth_dellink
,
452 .policy
= veth_policy
,
453 .maxtype
= VETH_INFO_MAX
,
460 static __init
int veth_init(void)
462 return rtnl_link_register(&veth_link_ops
);
465 static __exit
void veth_exit(void)
467 rtnl_link_unregister(&veth_link_ops
);
470 module_init(veth_init
);
471 module_exit(veth_exit
);
473 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
474 MODULE_LICENSE("GPL v2");
475 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);