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 #define MIN_MTU 68 /* Min L3 MTU */
23 #define MAX_MTU 65535 /* Max L3 MTU (arbitrary) */
24 #define MTU_PAD (ETH_HLEN + 4) /* Max difference between L2 and L3 size MTU */
26 struct veth_net_stats
{
27 unsigned long rx_packets
;
28 unsigned long tx_packets
;
29 unsigned long rx_bytes
;
30 unsigned long tx_bytes
;
31 unsigned long tx_dropped
;
32 unsigned long rx_dropped
;
36 struct net_device
*peer
;
37 struct veth_net_stats
*stats
;
46 const char string
[ETH_GSTRING_LEN
];
47 } ethtool_stats_keys
[] = {
51 static int veth_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
55 cmd
->speed
= SPEED_10000
;
56 cmd
->duplex
= DUPLEX_FULL
;
59 cmd
->transceiver
= XCVR_INTERNAL
;
60 cmd
->autoneg
= AUTONEG_DISABLE
;
66 static void veth_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
68 strcpy(info
->driver
, DRV_NAME
);
69 strcpy(info
->version
, DRV_VERSION
);
70 strcpy(info
->fw_version
, "N/A");
73 static void veth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*buf
)
77 memcpy(buf
, ðtool_stats_keys
, sizeof(ethtool_stats_keys
));
82 static int veth_get_sset_count(struct net_device
*dev
, int sset
)
86 return ARRAY_SIZE(ethtool_stats_keys
);
92 static void veth_get_ethtool_stats(struct net_device
*dev
,
93 struct ethtool_stats
*stats
, u64
*data
)
95 struct veth_priv
*priv
;
97 priv
= netdev_priv(dev
);
98 data
[0] = priv
->peer
->ifindex
;
101 static u32
veth_get_rx_csum(struct net_device
*dev
)
103 struct veth_priv
*priv
;
105 priv
= netdev_priv(dev
);
106 return priv
->ip_summed
== CHECKSUM_UNNECESSARY
;
109 static int veth_set_rx_csum(struct net_device
*dev
, u32 data
)
111 struct veth_priv
*priv
;
113 priv
= netdev_priv(dev
);
114 priv
->ip_summed
= data
? CHECKSUM_UNNECESSARY
: CHECKSUM_NONE
;
118 static u32
veth_get_tx_csum(struct net_device
*dev
)
120 return (dev
->features
& NETIF_F_NO_CSUM
) != 0;
123 static int veth_set_tx_csum(struct net_device
*dev
, u32 data
)
126 dev
->features
|= NETIF_F_NO_CSUM
;
128 dev
->features
&= ~NETIF_F_NO_CSUM
;
132 static const struct ethtool_ops veth_ethtool_ops
= {
133 .get_settings
= veth_get_settings
,
134 .get_drvinfo
= veth_get_drvinfo
,
135 .get_link
= ethtool_op_get_link
,
136 .get_rx_csum
= veth_get_rx_csum
,
137 .set_rx_csum
= veth_set_rx_csum
,
138 .get_tx_csum
= veth_get_tx_csum
,
139 .set_tx_csum
= veth_set_tx_csum
,
140 .get_sg
= ethtool_op_get_sg
,
141 .set_sg
= ethtool_op_set_sg
,
142 .get_strings
= veth_get_strings
,
143 .get_sset_count
= veth_get_sset_count
,
144 .get_ethtool_stats
= veth_get_ethtool_stats
,
151 static netdev_tx_t
veth_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
153 struct net_device
*rcv
= NULL
;
154 struct veth_priv
*priv
, *rcv_priv
;
155 struct veth_net_stats
*stats
, *rcv_stats
;
158 priv
= netdev_priv(dev
);
160 rcv_priv
= netdev_priv(rcv
);
162 stats
= this_cpu_ptr(priv
->stats
);
163 rcv_stats
= this_cpu_ptr(rcv_priv
->stats
);
165 if (!(rcv
->flags
& IFF_UP
))
168 if (dev
->features
& NETIF_F_NO_CSUM
)
169 skb
->ip_summed
= rcv_priv
->ip_summed
;
171 length
= skb
->len
+ ETH_HLEN
;
172 if (dev_forward_skb(rcv
, skb
) != NET_RX_SUCCESS
)
175 stats
->tx_bytes
+= length
;
178 rcv_stats
->rx_bytes
+= length
;
179 rcv_stats
->rx_packets
++;
189 rcv_stats
->rx_dropped
++;
197 static struct net_device_stats
*veth_get_stats(struct net_device
*dev
)
199 struct veth_priv
*priv
;
201 struct veth_net_stats
*stats
, total
= {0};
203 priv
= netdev_priv(dev
);
205 for_each_possible_cpu(cpu
) {
206 stats
= per_cpu_ptr(priv
->stats
, cpu
);
208 total
.rx_packets
+= stats
->rx_packets
;
209 total
.tx_packets
+= stats
->tx_packets
;
210 total
.rx_bytes
+= stats
->rx_bytes
;
211 total
.tx_bytes
+= stats
->tx_bytes
;
212 total
.tx_dropped
+= stats
->tx_dropped
;
213 total
.rx_dropped
+= stats
->rx_dropped
;
215 dev
->stats
.rx_packets
= total
.rx_packets
;
216 dev
->stats
.tx_packets
= total
.tx_packets
;
217 dev
->stats
.rx_bytes
= total
.rx_bytes
;
218 dev
->stats
.tx_bytes
= total
.tx_bytes
;
219 dev
->stats
.tx_dropped
= total
.tx_dropped
;
220 dev
->stats
.rx_dropped
= total
.rx_dropped
;
225 static int veth_open(struct net_device
*dev
)
227 struct veth_priv
*priv
;
229 priv
= netdev_priv(dev
);
230 if (priv
->peer
== NULL
)
233 if (priv
->peer
->flags
& IFF_UP
) {
234 netif_carrier_on(dev
);
235 netif_carrier_on(priv
->peer
);
240 static int veth_close(struct net_device
*dev
)
242 struct veth_priv
*priv
= netdev_priv(dev
);
244 netif_carrier_off(dev
);
245 netif_carrier_off(priv
->peer
);
250 static int is_valid_veth_mtu(int new_mtu
)
252 return (new_mtu
>= MIN_MTU
&& new_mtu
<= MAX_MTU
);
255 static int veth_change_mtu(struct net_device
*dev
, int new_mtu
)
257 if (!is_valid_veth_mtu(new_mtu
))
263 static int veth_dev_init(struct net_device
*dev
)
265 struct veth_net_stats
*stats
;
266 struct veth_priv
*priv
;
268 stats
= alloc_percpu(struct veth_net_stats
);
272 priv
= netdev_priv(dev
);
277 static void veth_dev_free(struct net_device
*dev
)
279 struct veth_priv
*priv
;
281 priv
= netdev_priv(dev
);
282 free_percpu(priv
->stats
);
286 static const struct net_device_ops veth_netdev_ops
= {
287 .ndo_init
= veth_dev_init
,
288 .ndo_open
= veth_open
,
289 .ndo_stop
= veth_close
,
290 .ndo_start_xmit
= veth_xmit
,
291 .ndo_change_mtu
= veth_change_mtu
,
292 .ndo_get_stats
= veth_get_stats
,
293 .ndo_set_mac_address
= eth_mac_addr
,
296 static void veth_setup(struct net_device
*dev
)
300 dev
->netdev_ops
= &veth_netdev_ops
;
301 dev
->ethtool_ops
= &veth_ethtool_ops
;
302 dev
->features
|= NETIF_F_LLTX
;
303 dev
->destructor
= veth_dev_free
;
310 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
312 if (tb
[IFLA_ADDRESS
]) {
313 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
315 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
316 return -EADDRNOTAVAIL
;
319 if (!is_valid_veth_mtu(nla_get_u32(tb
[IFLA_MTU
])))
325 static struct rtnl_link_ops veth_link_ops
;
327 static int veth_newlink(struct net
*src_net
, struct net_device
*dev
,
328 struct nlattr
*tb
[], struct nlattr
*data
[])
331 struct net_device
*peer
;
332 struct veth_priv
*priv
;
333 char ifname
[IFNAMSIZ
];
334 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
338 * create and register peer first
340 * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
341 * skip it since no info from it is useful yet
344 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
345 struct nlattr
*nla_peer
;
347 nla_peer
= data
[VETH_INFO_PEER
];
348 err
= nla_parse(peer_tb
, IFLA_MAX
,
349 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
350 nla_len(nla_peer
) - sizeof(struct ifinfomsg
),
355 err
= veth_validate(peer_tb
, NULL
);
363 if (tbp
[IFLA_IFNAME
])
364 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
366 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
368 net
= rtnl_link_get_net(src_net
, tbp
);
372 peer
= rtnl_create_link(src_net
, net
, ifname
, &veth_link_ops
, tbp
);
375 return PTR_ERR(peer
);
378 if (tbp
[IFLA_ADDRESS
] == NULL
)
379 random_ether_addr(peer
->dev_addr
);
381 err
= register_netdevice(peer
);
385 goto err_register_peer
;
387 netif_carrier_off(peer
);
392 * note, that since we've registered new device the dev's name
393 * should be re-allocated
396 if (tb
[IFLA_ADDRESS
] == NULL
)
397 random_ether_addr(dev
->dev_addr
);
400 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
402 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
404 if (strchr(dev
->name
, '%')) {
405 err
= dev_alloc_name(dev
, dev
->name
);
410 err
= register_netdevice(dev
);
412 goto err_register_dev
;
414 netif_carrier_off(dev
);
417 * tie the deviced together
420 priv
= netdev_priv(dev
);
423 priv
= netdev_priv(peer
);
430 unregister_netdevice(peer
);
438 static void veth_dellink(struct net_device
*dev
, struct list_head
*head
)
440 struct veth_priv
*priv
;
441 struct net_device
*peer
;
443 priv
= netdev_priv(dev
);
446 unregister_netdevice_queue(dev
, head
);
447 unregister_netdevice_queue(peer
, head
);
450 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1];
452 static struct rtnl_link_ops veth_link_ops
= {
454 .priv_size
= sizeof(struct veth_priv
),
456 .validate
= veth_validate
,
457 .newlink
= veth_newlink
,
458 .dellink
= veth_dellink
,
459 .policy
= veth_policy
,
460 .maxtype
= VETH_INFO_MAX
,
467 static __init
int veth_init(void)
469 return rtnl_link_register(&veth_link_ops
);
472 static __exit
void veth_exit(void)
474 rtnl_link_unregister(&veth_link_ops
);
477 module_init(veth_init
);
478 module_exit(veth_exit
);
480 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
481 MODULE_LICENSE("GPL v2");
482 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);