Root/drivers/net/veth.c

1/*
2 * drivers/net/veth.c
3 *
4 * Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc
5 *
6 * Author: Pavel Emelianov <xemul@openvz.org>
7 * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com>
8 *
9 */
10
11#include <linux/netdevice.h>
12#include <linux/ethtool.h>
13#include <linux/etherdevice.h>
14
15#include <net/dst.h>
16#include <net/xfrm.h>
17#include <linux/veth.h>
18
19#define DRV_NAME "veth"
20#define DRV_VERSION "1.0"
21
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 */
25
26struct 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;
33};
34
35struct veth_priv {
36    struct net_device *peer;
37    struct veth_net_stats *stats;
38    unsigned ip_summed;
39};
40
41/*
42 * ethtool interface
43 */
44
45static struct {
46    const char string[ETH_GSTRING_LEN];
47} ethtool_stats_keys[] = {
48    { "peer_ifindex" },
49};
50
51static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
52{
53    cmd->supported = 0;
54    cmd->advertising = 0;
55    cmd->speed = SPEED_10000;
56    cmd->duplex = DUPLEX_FULL;
57    cmd->port = PORT_TP;
58    cmd->phy_address = 0;
59    cmd->transceiver = XCVR_INTERNAL;
60    cmd->autoneg = AUTONEG_DISABLE;
61    cmd->maxtxpkt = 0;
62    cmd->maxrxpkt = 0;
63    return 0;
64}
65
66static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
67{
68    strcpy(info->driver, DRV_NAME);
69    strcpy(info->version, DRV_VERSION);
70    strcpy(info->fw_version, "N/A");
71}
72
73static void veth_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
74{
75    switch(stringset) {
76    case ETH_SS_STATS:
77        memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
78        break;
79    }
80}
81
82static int veth_get_sset_count(struct net_device *dev, int sset)
83{
84    switch (sset) {
85    case ETH_SS_STATS:
86        return ARRAY_SIZE(ethtool_stats_keys);
87    default:
88        return -EOPNOTSUPP;
89    }
90}
91
92static void veth_get_ethtool_stats(struct net_device *dev,
93        struct ethtool_stats *stats, u64 *data)
94{
95    struct veth_priv *priv;
96
97    priv = netdev_priv(dev);
98    data[0] = priv->peer->ifindex;
99}
100
101static u32 veth_get_rx_csum(struct net_device *dev)
102{
103    struct veth_priv *priv;
104
105    priv = netdev_priv(dev);
106    return priv->ip_summed == CHECKSUM_UNNECESSARY;
107}
108
109static int veth_set_rx_csum(struct net_device *dev, u32 data)
110{
111    struct veth_priv *priv;
112
113    priv = netdev_priv(dev);
114    priv->ip_summed = data ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE;
115    return 0;
116}
117
118static u32 veth_get_tx_csum(struct net_device *dev)
119{
120    return (dev->features & NETIF_F_NO_CSUM) != 0;
121}
122
123static int veth_set_tx_csum(struct net_device *dev, u32 data)
124{
125    if (data)
126        dev->features |= NETIF_F_NO_CSUM;
127    else
128        dev->features &= ~NETIF_F_NO_CSUM;
129    return 0;
130}
131
132static 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,
145};
146
147/*
148 * xmit
149 */
150
151static int veth_xmit(struct sk_buff *skb, struct net_device *dev)
152{
153    struct net_device *rcv = NULL;
154    struct veth_priv *priv, *rcv_priv;
155    struct veth_net_stats *stats, *rcv_stats;
156    int length, cpu;
157
158    skb_orphan(skb);
159
160    priv = netdev_priv(dev);
161    rcv = priv->peer;
162    rcv_priv = netdev_priv(rcv);
163
164    cpu = smp_processor_id();
165    stats = per_cpu_ptr(priv->stats, cpu);
166    rcv_stats = per_cpu_ptr(rcv_priv->stats, cpu);
167
168    if (!(rcv->flags & IFF_UP))
169        goto tx_drop;
170
171    if (skb->len > (rcv->mtu + MTU_PAD))
172        goto rx_drop;
173
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;
178
179    skb->mark = 0;
180    secpath_reset(skb);
181    nf_reset(skb);
182
183    length = skb->len;
184
185    stats->tx_bytes += length;
186    stats->tx_packets++;
187
188    rcv_stats->rx_bytes += length;
189    rcv_stats->rx_packets++;
190
191    netif_rx(skb);
192    return 0;
193
194tx_drop:
195    kfree_skb(skb);
196    stats->tx_dropped++;
197    return 0;
198
199rx_drop:
200    kfree_skb(skb);
201    rcv_stats->rx_dropped++;
202    return 0;
203}
204
205/*
206 * general routines
207 */
208
209static struct net_device_stats *veth_get_stats(struct net_device *dev)
210{
211    struct veth_priv *priv;
212    struct net_device_stats *dev_stats;
213    int cpu;
214    struct veth_net_stats *stats;
215
216    priv = netdev_priv(dev);
217    dev_stats = &dev->stats;
218
219    dev_stats->rx_packets = 0;
220    dev_stats->tx_packets = 0;
221    dev_stats->rx_bytes = 0;
222    dev_stats->tx_bytes = 0;
223    dev_stats->tx_dropped = 0;
224    dev_stats->rx_dropped = 0;
225
226    for_each_online_cpu(cpu) {
227        stats = per_cpu_ptr(priv->stats, cpu);
228
229        dev_stats->rx_packets += stats->rx_packets;
230        dev_stats->tx_packets += stats->tx_packets;
231        dev_stats->rx_bytes += stats->rx_bytes;
232        dev_stats->tx_bytes += stats->tx_bytes;
233        dev_stats->tx_dropped += stats->tx_dropped;
234        dev_stats->rx_dropped += stats->rx_dropped;
235    }
236
237    return dev_stats;
238}
239
240static int veth_open(struct net_device *dev)
241{
242    struct veth_priv *priv;
243
244    priv = netdev_priv(dev);
245    if (priv->peer == NULL)
246        return -ENOTCONN;
247
248    if (priv->peer->flags & IFF_UP) {
249        netif_carrier_on(dev);
250        netif_carrier_on(priv->peer);
251    }
252    return 0;
253}
254
255static int veth_close(struct net_device *dev)
256{
257    struct veth_priv *priv = netdev_priv(dev);
258
259    netif_carrier_off(dev);
260    netif_carrier_off(priv->peer);
261
262    return 0;
263}
264
265static int is_valid_veth_mtu(int new_mtu)
266{
267    return (new_mtu >= MIN_MTU && new_mtu <= MAX_MTU);
268}
269
270static int veth_change_mtu(struct net_device *dev, int new_mtu)
271{
272    if (!is_valid_veth_mtu(new_mtu))
273        return -EINVAL;
274    dev->mtu = new_mtu;
275    return 0;
276}
277
278static int veth_dev_init(struct net_device *dev)
279{
280    struct veth_net_stats *stats;
281    struct veth_priv *priv;
282
283    stats = alloc_percpu(struct veth_net_stats);
284    if (stats == NULL)
285        return -ENOMEM;
286
287    priv = netdev_priv(dev);
288    priv->stats = stats;
289    return 0;
290}
291
292static void veth_dev_free(struct net_device *dev)
293{
294    struct veth_priv *priv;
295
296    priv = netdev_priv(dev);
297    free_percpu(priv->stats);
298    free_netdev(dev);
299}
300
301static const struct net_device_ops veth_netdev_ops = {
302    .ndo_init = veth_dev_init,
303    .ndo_open = veth_open,
304    .ndo_stop = veth_close,
305    .ndo_start_xmit = veth_xmit,
306    .ndo_change_mtu = veth_change_mtu,
307    .ndo_get_stats = veth_get_stats,
308    .ndo_set_mac_address = eth_mac_addr,
309};
310
311static void veth_setup(struct net_device *dev)
312{
313    ether_setup(dev);
314
315    dev->netdev_ops = &veth_netdev_ops;
316    dev->ethtool_ops = &veth_ethtool_ops;
317    dev->features |= NETIF_F_LLTX;
318    dev->destructor = veth_dev_free;
319}
320
321/*
322 * netlink interface
323 */
324
325static int veth_validate(struct nlattr *tb[], struct nlattr *data[])
326{
327    if (tb[IFLA_ADDRESS]) {
328        if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
329            return -EINVAL;
330        if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
331            return -EADDRNOTAVAIL;
332    }
333    if (tb[IFLA_MTU]) {
334        if (!is_valid_veth_mtu(nla_get_u32(tb[IFLA_MTU])))
335            return -EINVAL;
336    }
337    return 0;
338}
339
340static struct rtnl_link_ops veth_link_ops;
341
342static int veth_newlink(struct net_device *dev,
343             struct nlattr *tb[], struct nlattr *data[])
344{
345    int err;
346    struct net_device *peer;
347    struct veth_priv *priv;
348    char ifname[IFNAMSIZ];
349    struct nlattr *peer_tb[IFLA_MAX + 1], **tbp;
350
351    /*
352     * create and register peer first
353     *
354     * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
355     * skip it since no info from it is useful yet
356     */
357
358    if (data != NULL && data[VETH_INFO_PEER] != NULL) {
359        struct nlattr *nla_peer;
360
361        nla_peer = data[VETH_INFO_PEER];
362        err = nla_parse(peer_tb, IFLA_MAX,
363                nla_data(nla_peer) + sizeof(struct ifinfomsg),
364                nla_len(nla_peer) - sizeof(struct ifinfomsg),
365                ifla_policy);
366        if (err < 0)
367            return err;
368
369        err = veth_validate(peer_tb, NULL);
370        if (err < 0)
371            return err;
372
373        tbp = peer_tb;
374    } else
375        tbp = tb;
376
377    if (tbp[IFLA_IFNAME])
378        nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ);
379    else
380        snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d");
381
382    peer = rtnl_create_link(dev_net(dev), ifname, &veth_link_ops, tbp);
383    if (IS_ERR(peer))
384        return PTR_ERR(peer);
385
386    if (tbp[IFLA_ADDRESS] == NULL)
387        random_ether_addr(peer->dev_addr);
388
389    err = register_netdevice(peer);
390    if (err < 0)
391        goto err_register_peer;
392
393    netif_carrier_off(peer);
394
395    /*
396     * register dev last
397     *
398     * note, that since we've registered new device the dev's name
399     * should be re-allocated
400     */
401
402    if (tb[IFLA_ADDRESS] == NULL)
403        random_ether_addr(dev->dev_addr);
404
405    if (tb[IFLA_IFNAME])
406        nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
407    else
408        snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d");
409
410    if (strchr(dev->name, '%')) {
411        err = dev_alloc_name(dev, dev->name);
412        if (err < 0)
413            goto err_alloc_name;
414    }
415
416    err = register_netdevice(dev);
417    if (err < 0)
418        goto err_register_dev;
419
420    netif_carrier_off(dev);
421
422    /*
423     * tie the deviced together
424     */
425
426    priv = netdev_priv(dev);
427    priv->peer = peer;
428
429    priv = netdev_priv(peer);
430    priv->peer = dev;
431    return 0;
432
433err_register_dev:
434    /* nothing to do */
435err_alloc_name:
436    unregister_netdevice(peer);
437    return err;
438
439err_register_peer:
440    free_netdev(peer);
441    return err;
442}
443
444static void veth_dellink(struct net_device *dev)
445{
446    struct veth_priv *priv;
447    struct net_device *peer;
448
449    priv = netdev_priv(dev);
450    peer = priv->peer;
451
452    unregister_netdevice(dev);
453    unregister_netdevice(peer);
454}
455
456static const struct nla_policy veth_policy[VETH_INFO_MAX + 1];
457
458static struct rtnl_link_ops veth_link_ops = {
459    .kind = DRV_NAME,
460    .priv_size = sizeof(struct veth_priv),
461    .setup = veth_setup,
462    .validate = veth_validate,
463    .newlink = veth_newlink,
464    .dellink = veth_dellink,
465    .policy = veth_policy,
466    .maxtype = VETH_INFO_MAX,
467};
468
469/*
470 * init/fini
471 */
472
473static __init int veth_init(void)
474{
475    return rtnl_link_register(&veth_link_ops);
476}
477
478static __exit void veth_exit(void)
479{
480    rtnl_link_unregister(&veth_link_ops);
481}
482
483module_init(veth_init);
484module_exit(veth_exit);
485
486MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
487MODULE_LICENSE("GPL v2");
488MODULE_ALIAS_RTNL_LINK(DRV_NAME);
489

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive