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>
21 #define DRV_NAME "veth"
22 #define DRV_VERSION "1.0"
24 #define MIN_MTU 68 /* Min L3 MTU */
25 #define MAX_MTU 65535 /* Max L3 MTU (arbitrary) */
27 struct veth_net_stats
{
34 struct u64_stats_sync syncp
;
38 struct net_device
*peer
;
39 struct veth_net_stats __percpu
*stats
;
47 const char string
[ETH_GSTRING_LEN
];
48 } ethtool_stats_keys
[] = {
52 static int veth_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
56 ethtool_cmd_speed_set(cmd
, SPEED_10000
);
57 cmd
->duplex
= DUPLEX_FULL
;
60 cmd
->transceiver
= XCVR_INTERNAL
;
61 cmd
->autoneg
= AUTONEG_DISABLE
;
67 static void veth_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
69 strcpy(info
->driver
, DRV_NAME
);
70 strcpy(info
->version
, DRV_VERSION
);
71 strcpy(info
->fw_version
, "N/A");
74 static void veth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*buf
)
78 memcpy(buf
, ðtool_stats_keys
, sizeof(ethtool_stats_keys
));
83 static int veth_get_sset_count(struct net_device
*dev
, int sset
)
87 return ARRAY_SIZE(ethtool_stats_keys
);
93 static void veth_get_ethtool_stats(struct net_device
*dev
,
94 struct ethtool_stats
*stats
, u64
*data
)
96 struct veth_priv
*priv
;
98 priv
= netdev_priv(dev
);
99 data
[0] = priv
->peer
->ifindex
;
102 static const struct ethtool_ops veth_ethtool_ops
= {
103 .get_settings
= veth_get_settings
,
104 .get_drvinfo
= veth_get_drvinfo
,
105 .get_link
= ethtool_op_get_link
,
106 .get_strings
= veth_get_strings
,
107 .get_sset_count
= veth_get_sset_count
,
108 .get_ethtool_stats
= veth_get_ethtool_stats
,
115 static netdev_tx_t
veth_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
117 struct net_device
*rcv
= NULL
;
118 struct veth_priv
*priv
, *rcv_priv
;
119 struct veth_net_stats
*stats
, *rcv_stats
;
122 priv
= netdev_priv(dev
);
124 rcv_priv
= netdev_priv(rcv
);
126 stats
= this_cpu_ptr(priv
->stats
);
127 rcv_stats
= this_cpu_ptr(rcv_priv
->stats
);
129 /* don't change ip_summed == CHECKSUM_PARTIAL, as that
130 will cause bad checksum on forwarded packets */
131 if (skb
->ip_summed
== CHECKSUM_NONE
&&
132 rcv
->features
& NETIF_F_RXCSUM
)
133 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
136 if (dev_forward_skb(rcv
, skb
) != NET_RX_SUCCESS
)
139 u64_stats_update_begin(&stats
->syncp
);
140 stats
->tx_bytes
+= length
;
142 u64_stats_update_end(&stats
->syncp
);
144 u64_stats_update_begin(&rcv_stats
->syncp
);
145 rcv_stats
->rx_bytes
+= length
;
146 rcv_stats
->rx_packets
++;
147 u64_stats_update_end(&rcv_stats
->syncp
);
153 u64_stats_update_begin(&stats
->syncp
);
155 u64_stats_update_end(&stats
->syncp
);
159 u64_stats_update_begin(&rcv_stats
->syncp
);
160 rcv_stats
->rx_dropped
++;
161 u64_stats_update_end(&rcv_stats
->syncp
);
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
);
175 for_each_possible_cpu(cpu
) {
176 struct veth_net_stats
*stats
= per_cpu_ptr(priv
->stats
, cpu
);
177 u64 rx_packets
, rx_bytes
, rx_dropped
;
178 u64 tx_packets
, tx_bytes
, tx_dropped
;
182 start
= u64_stats_fetch_begin_bh(&stats
->syncp
);
183 rx_packets
= stats
->rx_packets
;
184 tx_packets
= stats
->tx_packets
;
185 rx_bytes
= stats
->rx_bytes
;
186 tx_bytes
= stats
->tx_bytes
;
187 rx_dropped
= stats
->rx_dropped
;
188 tx_dropped
= stats
->tx_dropped
;
189 } while (u64_stats_fetch_retry_bh(&stats
->syncp
, start
));
190 tot
->rx_packets
+= rx_packets
;
191 tot
->tx_packets
+= tx_packets
;
192 tot
->rx_bytes
+= rx_bytes
;
193 tot
->tx_bytes
+= tx_bytes
;
194 tot
->rx_dropped
+= rx_dropped
;
195 tot
->tx_dropped
+= tx_dropped
;
201 static int veth_open(struct net_device
*dev
)
203 struct veth_priv
*priv
;
205 priv
= netdev_priv(dev
);
206 if (priv
->peer
== NULL
)
209 if (priv
->peer
->flags
& IFF_UP
) {
210 netif_carrier_on(dev
);
211 netif_carrier_on(priv
->peer
);
216 static int veth_close(struct net_device
*dev
)
218 struct veth_priv
*priv
= netdev_priv(dev
);
220 netif_carrier_off(dev
);
221 netif_carrier_off(priv
->peer
);
226 static int is_valid_veth_mtu(int new_mtu
)
228 return new_mtu
>= MIN_MTU
&& new_mtu
<= MAX_MTU
;
231 static int veth_change_mtu(struct net_device
*dev
, int new_mtu
)
233 if (!is_valid_veth_mtu(new_mtu
))
239 static int veth_dev_init(struct net_device
*dev
)
241 struct veth_net_stats __percpu
*stats
;
242 struct veth_priv
*priv
;
244 stats
= alloc_percpu(struct veth_net_stats
);
248 priv
= netdev_priv(dev
);
253 static void veth_dev_free(struct net_device
*dev
)
255 struct veth_priv
*priv
;
257 priv
= netdev_priv(dev
);
258 free_percpu(priv
->stats
);
262 static const struct net_device_ops veth_netdev_ops
= {
263 .ndo_init
= veth_dev_init
,
264 .ndo_open
= veth_open
,
265 .ndo_stop
= veth_close
,
266 .ndo_start_xmit
= veth_xmit
,
267 .ndo_change_mtu
= veth_change_mtu
,
268 .ndo_get_stats64
= veth_get_stats64
,
269 .ndo_set_mac_address
= eth_mac_addr
,
272 static void veth_setup(struct net_device
*dev
)
276 dev
->netdev_ops
= &veth_netdev_ops
;
277 dev
->ethtool_ops
= &veth_ethtool_ops
;
278 dev
->features
|= NETIF_F_LLTX
;
279 dev
->destructor
= veth_dev_free
;
281 dev
->hw_features
= NETIF_F_NO_CSUM
| NETIF_F_SG
| NETIF_F_RXCSUM
;
288 static int veth_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
290 if (tb
[IFLA_ADDRESS
]) {
291 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
293 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
294 return -EADDRNOTAVAIL
;
297 if (!is_valid_veth_mtu(nla_get_u32(tb
[IFLA_MTU
])))
303 static struct rtnl_link_ops veth_link_ops
;
305 static int veth_newlink(struct net
*src_net
, struct net_device
*dev
,
306 struct nlattr
*tb
[], struct nlattr
*data
[])
309 struct net_device
*peer
;
310 struct veth_priv
*priv
;
311 char ifname
[IFNAMSIZ
];
312 struct nlattr
*peer_tb
[IFLA_MAX
+ 1], **tbp
;
313 struct ifinfomsg
*ifmp
;
317 * create and register peer first
319 if (data
!= NULL
&& data
[VETH_INFO_PEER
] != NULL
) {
320 struct nlattr
*nla_peer
;
322 nla_peer
= data
[VETH_INFO_PEER
];
323 ifmp
= nla_data(nla_peer
);
324 err
= nla_parse(peer_tb
, IFLA_MAX
,
325 nla_data(nla_peer
) + sizeof(struct ifinfomsg
),
326 nla_len(nla_peer
) - sizeof(struct ifinfomsg
),
331 err
= veth_validate(peer_tb
, NULL
);
341 if (tbp
[IFLA_IFNAME
])
342 nla_strlcpy(ifname
, tbp
[IFLA_IFNAME
], IFNAMSIZ
);
344 snprintf(ifname
, IFNAMSIZ
, DRV_NAME
"%%d");
346 net
= rtnl_link_get_net(src_net
, tbp
);
350 peer
= rtnl_create_link(src_net
, net
, ifname
, &veth_link_ops
, tbp
);
353 return PTR_ERR(peer
);
356 if (tbp
[IFLA_ADDRESS
] == NULL
)
357 random_ether_addr(peer
->dev_addr
);
359 err
= register_netdevice(peer
);
363 goto err_register_peer
;
365 netif_carrier_off(peer
);
367 err
= rtnl_configure_link(peer
, ifmp
);
369 goto err_configure_peer
;
374 * note, that since we've registered new device the dev's name
375 * should be re-allocated
378 if (tb
[IFLA_ADDRESS
] == NULL
)
379 random_ether_addr(dev
->dev_addr
);
382 nla_strlcpy(dev
->name
, tb
[IFLA_IFNAME
], IFNAMSIZ
);
384 snprintf(dev
->name
, IFNAMSIZ
, DRV_NAME
"%%d");
386 if (strchr(dev
->name
, '%')) {
387 err
= dev_alloc_name(dev
, dev
->name
);
392 err
= register_netdevice(dev
);
394 goto err_register_dev
;
396 netif_carrier_off(dev
);
399 * tie the deviced together
402 priv
= netdev_priv(dev
);
405 priv
= netdev_priv(peer
);
413 unregister_netdevice(peer
);
421 static void veth_dellink(struct net_device
*dev
, struct list_head
*head
)
423 struct veth_priv
*priv
;
424 struct net_device
*peer
;
426 priv
= netdev_priv(dev
);
429 unregister_netdevice_queue(dev
, head
);
430 unregister_netdevice_queue(peer
, head
);
433 static const struct nla_policy veth_policy
[VETH_INFO_MAX
+ 1];
435 static struct rtnl_link_ops veth_link_ops
= {
437 .priv_size
= sizeof(struct veth_priv
),
439 .validate
= veth_validate
,
440 .newlink
= veth_newlink
,
441 .dellink
= veth_dellink
,
442 .policy
= veth_policy
,
443 .maxtype
= VETH_INFO_MAX
,
450 static __init
int veth_init(void)
452 return rtnl_link_register(&veth_link_ops
);
455 static __exit
void veth_exit(void)
457 rtnl_link_unregister(&veth_link_ops
);
460 module_init(veth_init
);
461 module_exit(veth_exit
);
463 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
464 MODULE_LICENSE("GPL v2");
465 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);