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 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 int 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
;
160 priv
= netdev_priv(dev
);
162 rcv_priv
= netdev_priv(rcv
);
164 cpu
= smp_processor_id();
165 stats
= per_cpu_ptr(priv
->stats
, cpu
);
166 rcv_stats
= per_cpu_ptr(rcv_priv
->stats
, cpu
);
168 if (!(rcv
->flags
& IFF_UP
))
171 if (skb
->len
> (rcv
->mtu
+ MTU_PAD
))
174 skb
->pkt_type
= PACKET_HOST
;
175 skb
->protocol
= eth_type_trans(skb
, rcv
);
176 if (dev
->features
& NETIF_F_NO_CSUM
)
177 skb
->ip_summed
= rcv_priv
->ip_summed
;
185 stats
->tx_bytes
+= length
;
188 rcv_stats
->rx_bytes
+= length
;
189 rcv_stats
->rx_packets
++;
201 rcv_stats
->rx_dropped
++;
209 static struct net_device_stats
*veth_get_stats(struct net_device
*dev
)
211 struct veth_priv
*priv
= netdev_priv(dev
);
212 struct net_device_stats
*dev_stats
= &dev
->stats
;
214 struct veth_net_stats
*stats
;
216 dev_stats
->rx_packets
= 0;
217 dev_stats
->tx_packets
= 0;
218 dev_stats
->rx_bytes
= 0;
219 dev_stats
->tx_bytes
= 0;
220 dev_stats
->tx_dropped
= 0;
221 dev_stats
->rx_dropped
= 0;
224 for_each_online_cpu(cpu
) {
225 stats
= per_cpu_ptr(priv
->stats
, cpu
);
227 dev_stats
->rx_packets
+= stats
->rx_packets
;
228 dev_stats
->tx_packets
+= stats
->tx_packets
;
229 dev_stats
->rx_bytes
+= stats
->rx_bytes
;
230 dev_stats
->tx_bytes
+= stats
->tx_bytes
;
231 dev_stats
->tx_dropped
+= stats
->tx_dropped
;
232 dev_stats
->rx_dropped
+= stats
->rx_dropped
;
238 static int veth_open(struct net_device
*dev
)
240 struct veth_priv
*priv
;
242 priv
= netdev_priv(dev
);
243 if (priv
->peer
== NULL
)
246 if (priv
->peer
->flags
& IFF_UP
) {
247 netif_carrier_on(dev
);
248 netif_carrier_on(priv
->peer
);
253 static int veth_close(struct net_device
*dev
)
255 struct veth_priv
*priv
= netdev_priv(dev
);
257 netif_carrier_off(dev
);
258 netif_carrier_off(priv
->peer
);
260 free_percpu(priv
->stats
);
265 static int is_valid_veth_mtu(int new_mtu
)
267 return (new_mtu
>= MIN_MTU
&& new_mtu
<= MAX_MTU
);
270 static int veth_change_mtu(struct net_device
*dev
, int new_mtu
)
272 if (!is_valid_veth_mtu(new_mtu
))
278 static int veth_dev_init(struct net_device
*dev
)
280 struct veth_net_stats
*stats
;
281 struct veth_priv
*priv
;
283 stats
= alloc_percpu(struct veth_net_stats
);
287 priv
= netdev_priv(dev
);
292 static const struct net_device_ops veth_netdev_ops
= {
293 .ndo_init
= veth_dev_init
,
294 .ndo_open
= veth_open
,
295 .ndo_stop
= veth_close
,
296 .ndo_start_xmit
= veth_xmit
,
297 .ndo_change_mtu
= veth_change_mtu
,
298 .ndo_get_stats
= veth_get_stats
,
299 .ndo_set_mac_address
= eth_mac_addr
,
302 static void veth_setup(struct net_device
*dev
)
306 dev
->netdev_ops
= &veth_netdev_ops
;
307 dev
->ethtool_ops
= &veth_ethtool_ops
;
308 dev
->features
|= NETIF_F_LLTX
;
309 dev
->destructor
= free_netdev
;
316 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
318 if (tb
[IFLA_ADDRESS
]) {
319 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
321 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
322 return -EADDRNOTAVAIL
;
325 if (!is_valid_veth_mtu(nla_get_u32(tb
[IFLA_MTU
])))
331 static struct rtnl_link_ops veth_link_ops
;
333 static int veth_newlink(struct net_device
*dev
,
334 struct nlattr
*tb
[], struct nlattr
*data
[])
337 struct net_device
*peer
;
338 struct veth_priv
*priv
;
339 char ifname
[IFNAMSIZ
];
340 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
343 * create and register peer first
345 * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
346 * skip it since no info from it is useful yet
349 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
350 struct nlattr
*nla_peer
;
352 nla_peer
= data
[VETH_INFO_PEER
];
353 err
= nla_parse(peer_tb
, IFLA_MAX
,
354 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
355 nla_len(nla_peer
) - sizeof(struct ifinfomsg
),
360 err
= veth_validate(peer_tb
, NULL
);
368 if (tbp
[IFLA_IFNAME
])
369 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
371 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
373 peer
= rtnl_create_link(dev_net(dev
), ifname
, &veth_link_ops
, tbp
);
375 return PTR_ERR(peer
);
377 if (tbp
[IFLA_ADDRESS
] == NULL
)
378 random_ether_addr(peer
->dev_addr
);
380 err
= register_netdevice(peer
);
382 goto err_register_peer
;
384 netif_carrier_off(peer
);
389 * note, that since we've registered new device the dev's name
390 * should be re-allocated
393 if (tb
[IFLA_ADDRESS
] == NULL
)
394 random_ether_addr(dev
->dev_addr
);
397 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
399 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
401 if (strchr(dev
->name
, '%')) {
402 err
= dev_alloc_name(dev
, dev
->name
);
407 err
= register_netdevice(dev
);
409 goto err_register_dev
;
411 netif_carrier_off(dev
);
414 * tie the deviced together
417 priv
= netdev_priv(dev
);
420 priv
= netdev_priv(peer
);
427 unregister_netdevice(peer
);
435 static void veth_dellink(struct net_device
*dev
)
437 struct veth_priv
*priv
;
438 struct net_device
*peer
;
440 priv
= netdev_priv(dev
);
443 unregister_netdevice(dev
);
444 unregister_netdevice(peer
);
447 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1];
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
);