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>
17 #include <net/rtnetlink.h>
20 #include <linux/veth.h>
21 #include <linux/module.h>
23 #define DRV_NAME "veth"
24 #define DRV_VERSION "1.0"
26 #define MIN_MTU 68 /* Min L3 MTU */
27 #define MAX_MTU 65535 /* Max L3 MTU (arbitrary) */
32 struct u64_stats_sync syncp
;
36 struct net_device __rcu
*peer
;
45 const char string
[ETH_GSTRING_LEN
];
46 } ethtool_stats_keys
[] = {
50 static int veth_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
54 ethtool_cmd_speed_set(cmd
, SPEED_10000
);
55 cmd
->duplex
= DUPLEX_FULL
;
58 cmd
->transceiver
= XCVR_INTERNAL
;
59 cmd
->autoneg
= AUTONEG_DISABLE
;
65 static void veth_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
67 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
68 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
71 static void veth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*buf
)
75 memcpy(buf
, ðtool_stats_keys
, sizeof(ethtool_stats_keys
));
80 static int veth_get_sset_count(struct net_device
*dev
, int sset
)
84 return ARRAY_SIZE(ethtool_stats_keys
);
90 static void veth_get_ethtool_stats(struct net_device
*dev
,
91 struct ethtool_stats
*stats
, u64
*data
)
93 struct veth_priv
*priv
= netdev_priv(dev
);
94 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
96 data
[0] = peer
? peer
->ifindex
: 0;
99 static const struct ethtool_ops veth_ethtool_ops
= {
100 .get_settings
= veth_get_settings
,
101 .get_drvinfo
= veth_get_drvinfo
,
102 .get_link
= ethtool_op_get_link
,
103 .get_strings
= veth_get_strings
,
104 .get_sset_count
= veth_get_sset_count
,
105 .get_ethtool_stats
= veth_get_ethtool_stats
,
108 static netdev_tx_t
veth_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
110 struct veth_priv
*priv
= netdev_priv(dev
);
111 struct net_device
*rcv
;
112 int length
= skb
->len
;
115 rcv
= rcu_dereference(priv
->peer
);
116 if (unlikely(!rcv
)) {
120 /* don't change ip_summed == CHECKSUM_PARTIAL, as that
121 * will cause bad checksum on forwarded packets
123 if (skb
->ip_summed
== CHECKSUM_NONE
&&
124 rcv
->features
& NETIF_F_RXCSUM
)
125 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
127 if (likely(dev_forward_skb(rcv
, skb
) == NET_RX_SUCCESS
)) {
128 struct pcpu_vstats
*stats
= this_cpu_ptr(dev
->vstats
);
130 u64_stats_update_begin(&stats
->syncp
);
131 stats
->bytes
+= length
;
133 u64_stats_update_end(&stats
->syncp
);
136 atomic64_inc(&priv
->dropped
);
146 static u64
veth_stats_one(struct pcpu_vstats
*result
, struct net_device
*dev
)
148 struct veth_priv
*priv
= netdev_priv(dev
);
153 for_each_possible_cpu(cpu
) {
154 struct pcpu_vstats
*stats
= per_cpu_ptr(dev
->vstats
, cpu
);
159 start
= u64_stats_fetch_begin_irq(&stats
->syncp
);
160 packets
= stats
->packets
;
161 bytes
= stats
->bytes
;
162 } while (u64_stats_fetch_retry_irq(&stats
->syncp
, start
));
163 result
->packets
+= packets
;
164 result
->bytes
+= bytes
;
166 return atomic64_read(&priv
->dropped
);
169 static struct rtnl_link_stats64
*veth_get_stats64(struct net_device
*dev
,
170 struct rtnl_link_stats64
*tot
)
172 struct veth_priv
*priv
= netdev_priv(dev
);
173 struct net_device
*peer
;
174 struct pcpu_vstats one
;
176 tot
->tx_dropped
= veth_stats_one(&one
, dev
);
177 tot
->tx_bytes
= one
.bytes
;
178 tot
->tx_packets
= one
.packets
;
181 peer
= rcu_dereference(priv
->peer
);
183 tot
->rx_dropped
= veth_stats_one(&one
, peer
);
184 tot
->rx_bytes
= one
.bytes
;
185 tot
->rx_packets
= one
.packets
;
192 /* fake multicast ability */
193 static void veth_set_multicast_list(struct net_device
*dev
)
197 static int veth_open(struct net_device
*dev
)
199 struct veth_priv
*priv
= netdev_priv(dev
);
200 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
205 if (peer
->flags
& IFF_UP
) {
206 netif_carrier_on(dev
);
207 netif_carrier_on(peer
);
212 static int veth_close(struct net_device
*dev
)
214 struct veth_priv
*priv
= netdev_priv(dev
);
215 struct net_device
*peer
= rtnl_dereference(priv
->peer
);
217 netif_carrier_off(dev
);
219 netif_carrier_off(peer
);
224 static int is_valid_veth_mtu(int new_mtu
)
226 return new_mtu
>= MIN_MTU
&& new_mtu
<= MAX_MTU
;
229 static int veth_change_mtu(struct net_device
*dev
, int new_mtu
)
231 if (!is_valid_veth_mtu(new_mtu
))
237 static int veth_dev_init(struct net_device
*dev
)
239 dev
->vstats
= netdev_alloc_pcpu_stats(struct pcpu_vstats
);
245 static void veth_dev_free(struct net_device
*dev
)
247 free_percpu(dev
->vstats
);
251 static const struct net_device_ops veth_netdev_ops
= {
252 .ndo_init
= veth_dev_init
,
253 .ndo_open
= veth_open
,
254 .ndo_stop
= veth_close
,
255 .ndo_start_xmit
= veth_xmit
,
256 .ndo_change_mtu
= veth_change_mtu
,
257 .ndo_get_stats64
= veth_get_stats64
,
258 .ndo_set_rx_mode
= veth_set_multicast_list
,
259 .ndo_set_mac_address
= eth_mac_addr
,
262 #define VETH_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
263 NETIF_F_HW_CSUM | NETIF_F_RXCSUM | NETIF_F_HIGHDMA | \
264 NETIF_F_GSO_GRE | NETIF_F_GSO_UDP_TUNNEL | \
265 NETIF_F_GSO_IPIP | NETIF_F_GSO_SIT | NETIF_F_UFO | \
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 ~(NETIF_F_HW_VLAN_CTAG_TX
|
282 NETIF_F_HW_VLAN_STAG_TX
|
283 NETIF_F_HW_VLAN_CTAG_RX
|
284 NETIF_F_HW_VLAN_STAG_RX
);
285 dev
->destructor
= veth_dev_free
;
287 dev
->hw_features
= VETH_FEATURES
;
288 dev
->hw_enc_features
= VETH_FEATURES
;
295 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
297 if (tb
[IFLA_ADDRESS
]) {
298 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
300 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
301 return -EADDRNOTAVAIL
;
304 if (!is_valid_veth_mtu(nla_get_u32(tb
[IFLA_MTU
])))
310 static struct rtnl_link_ops veth_link_ops
;
312 static int veth_newlink(struct net
*src_net
, struct net_device
*dev
,
313 struct nlattr
*tb
[], struct nlattr
*data
[])
316 struct net_device
*peer
;
317 struct veth_priv
*priv
;
318 char ifname
[IFNAMSIZ
];
319 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
320 struct ifinfomsg
*ifmp
;
324 * create and register peer first
326 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
327 struct nlattr
*nla_peer
;
329 nla_peer
= data
[VETH_INFO_PEER
];
330 ifmp
= nla_data(nla_peer
);
331 err
= rtnl_nla_parse_ifla(peer_tb
,
332 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
333 nla_len(nla_peer
) - sizeof(struct ifinfomsg
));
337 err
= veth_validate(peer_tb
, NULL
);
347 if (tbp
[IFLA_IFNAME
])
348 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
350 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
352 net
= rtnl_link_get_net(src_net
, tbp
);
356 peer
= rtnl_create_link(net
, ifname
, &veth_link_ops
, tbp
);
359 return PTR_ERR(peer
);
362 if (tbp
[IFLA_ADDRESS
] == NULL
)
363 eth_hw_addr_random(peer
);
365 if (ifmp
&& (dev
->ifindex
!= 0))
366 peer
->ifindex
= ifmp
->ifi_index
;
368 err
= register_netdevice(peer
);
372 goto err_register_peer
;
374 netif_carrier_off(peer
);
376 err
= rtnl_configure_link(peer
, ifmp
);
378 goto err_configure_peer
;
383 * note, that since we've registered new device the dev's name
384 * should be re-allocated
387 if (tb
[IFLA_ADDRESS
] == NULL
)
388 eth_hw_addr_random(dev
);
391 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
393 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
395 err
= register_netdevice(dev
);
397 goto err_register_dev
;
399 netif_carrier_off(dev
);
402 * tie the deviced together
405 priv
= netdev_priv(dev
);
406 rcu_assign_pointer(priv
->peer
, peer
);
408 priv
= netdev_priv(peer
);
409 rcu_assign_pointer(priv
->peer
, dev
);
415 unregister_netdevice(peer
);
423 static void veth_dellink(struct net_device
*dev
, struct list_head
*head
)
425 struct veth_priv
*priv
;
426 struct net_device
*peer
;
428 priv
= netdev_priv(dev
);
429 peer
= rtnl_dereference(priv
->peer
);
431 /* Note : dellink() is called from default_device_exit_batch(),
432 * before a rcu_synchronize() point. The devices are guaranteed
433 * not being freed before one RCU grace period.
435 RCU_INIT_POINTER(priv
->peer
, NULL
);
436 unregister_netdevice_queue(dev
, head
);
439 priv
= netdev_priv(peer
);
440 RCU_INIT_POINTER(priv
->peer
, NULL
);
441 unregister_netdevice_queue(peer
, head
);
445 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1] = {
446 [VETH_INFO_PEER
] = { .len
= sizeof(struct ifinfomsg
) },
449 static struct rtnl_link_ops veth_link_ops
= {
451 .priv_size
= sizeof(struct veth_priv
),
453 .validate
= veth_validate
,
454 .newlink
= veth_newlink
,
455 .dellink
= veth_dellink
,
456 .policy
= veth_policy
,
457 .maxtype
= VETH_INFO_MAX
,
464 static __init
int veth_init(void)
466 return rtnl_link_register(&veth_link_ops
);
469 static __exit
void veth_exit(void)
471 rtnl_link_unregister(&veth_link_ops
);
474 module_init(veth_init
);
475 module_exit(veth_exit
);
477 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
478 MODULE_LICENSE("GPL v2");
479 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);