Root/drivers/net/macvlan.c

1/*
2 * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of
7 * the License, or (at your option) any later version.
8 *
9 * The code this is based on carried the following copyright notice:
10 * ---
11 * (C) Copyright 2001-2006
12 * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com
13 * Re-worked by Ben Greear <greearb@candelatech.com>
14 * ---
15 */
16#include <linux/kernel.h>
17#include <linux/types.h>
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/errno.h>
21#include <linux/slab.h>
22#include <linux/string.h>
23#include <linux/rculist.h>
24#include <linux/notifier.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/ethtool.h>
28#include <linux/if_arp.h>
29#include <linux/if_link.h>
30#include <linux/if_macvlan.h>
31#include <net/rtnetlink.h>
32
33#define MACVLAN_HASH_SIZE (1 << BITS_PER_BYTE)
34
35struct macvlan_port {
36    struct net_device *dev;
37    struct hlist_head vlan_hash[MACVLAN_HASH_SIZE];
38    struct list_head vlans;
39};
40
41struct macvlan_dev {
42    struct net_device *dev;
43    struct list_head list;
44    struct hlist_node hlist;
45    struct macvlan_port *port;
46    struct net_device *lowerdev;
47};
48
49
50static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
51                           const unsigned char *addr)
52{
53    struct macvlan_dev *vlan;
54    struct hlist_node *n;
55
56    hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[addr[5]], hlist) {
57        if (!compare_ether_addr(vlan->dev->dev_addr, addr))
58            return vlan;
59    }
60    return NULL;
61}
62
63static void macvlan_hash_add(struct macvlan_dev *vlan)
64{
65    struct macvlan_port *port = vlan->port;
66    const unsigned char *addr = vlan->dev->dev_addr;
67
68    hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[addr[5]]);
69}
70
71static void macvlan_hash_del(struct macvlan_dev *vlan)
72{
73    hlist_del_rcu(&vlan->hlist);
74    synchronize_rcu();
75}
76
77static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
78                    const unsigned char *addr)
79{
80    macvlan_hash_del(vlan);
81    /* Now that we are unhashed it is safe to change the device
82     * address without confusing packet delivery.
83     */
84    memcpy(vlan->dev->dev_addr, addr, ETH_ALEN);
85    macvlan_hash_add(vlan);
86}
87
88static int macvlan_addr_busy(const struct macvlan_port *port,
89                const unsigned char *addr)
90{
91    /* Test to see if the specified multicast address is
92     * currently in use by the underlying device or
93     * another macvlan.
94     */
95    if (memcmp(port->dev->dev_addr, addr, ETH_ALEN) == 0)
96        return 1;
97
98    if (macvlan_hash_lookup(port, addr))
99        return 1;
100
101    return 0;
102}
103
104static void macvlan_broadcast(struct sk_buff *skb,
105                  const struct macvlan_port *port)
106{
107    const struct ethhdr *eth = eth_hdr(skb);
108    const struct macvlan_dev *vlan;
109    struct hlist_node *n;
110    struct net_device *dev;
111    struct sk_buff *nskb;
112    unsigned int i;
113
114    if (skb->protocol == htons(ETH_P_PAUSE))
115        return;
116
117    for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
118        hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[i], hlist) {
119            dev = vlan->dev;
120
121            nskb = skb_clone(skb, GFP_ATOMIC);
122            if (nskb == NULL) {
123                dev->stats.rx_errors++;
124                dev->stats.rx_dropped++;
125                continue;
126            }
127
128            dev->stats.rx_bytes += skb->len + ETH_HLEN;
129            dev->stats.rx_packets++;
130            dev->stats.multicast++;
131
132            nskb->dev = dev;
133            if (!compare_ether_addr(eth->h_dest, dev->broadcast))
134                nskb->pkt_type = PACKET_BROADCAST;
135            else
136                nskb->pkt_type = PACKET_MULTICAST;
137
138            netif_rx(nskb);
139        }
140    }
141}
142
143/* called under rcu_read_lock() from netif_receive_skb */
144static struct sk_buff *macvlan_handle_frame(struct sk_buff *skb)
145{
146    const struct ethhdr *eth = eth_hdr(skb);
147    const struct macvlan_port *port;
148    const struct macvlan_dev *vlan;
149    struct net_device *dev;
150
151    port = rcu_dereference(skb->dev->macvlan_port);
152    if (port == NULL)
153        return skb;
154
155    if (is_multicast_ether_addr(eth->h_dest)) {
156        macvlan_broadcast(skb, port);
157        return skb;
158    }
159
160    vlan = macvlan_hash_lookup(port, eth->h_dest);
161    if (vlan == NULL)
162        return skb;
163
164    dev = vlan->dev;
165    if (unlikely(!(dev->flags & IFF_UP))) {
166        kfree_skb(skb);
167        return NULL;
168    }
169
170    skb = skb_share_check(skb, GFP_ATOMIC);
171    if (skb == NULL) {
172        dev->stats.rx_errors++;
173        dev->stats.rx_dropped++;
174        return NULL;
175    }
176
177    dev->stats.rx_bytes += skb->len + ETH_HLEN;
178    dev->stats.rx_packets++;
179
180    skb->dev = dev;
181    skb->pkt_type = PACKET_HOST;
182
183    netif_rx(skb);
184    return NULL;
185}
186
187static int macvlan_start_xmit(struct sk_buff *skb, struct net_device *dev)
188{
189    const struct macvlan_dev *vlan = netdev_priv(dev);
190    unsigned int len = skb->len;
191    int ret;
192
193    skb->dev = vlan->lowerdev;
194    ret = dev_queue_xmit(skb);
195
196    if (likely(ret == NET_XMIT_SUCCESS)) {
197        dev->stats.tx_packets++;
198        dev->stats.tx_bytes += len;
199    } else {
200        dev->stats.tx_errors++;
201        dev->stats.tx_aborted_errors++;
202    }
203    return NETDEV_TX_OK;
204}
205
206static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
207                   unsigned short type, const void *daddr,
208                   const void *saddr, unsigned len)
209{
210    const struct macvlan_dev *vlan = netdev_priv(dev);
211    struct net_device *lowerdev = vlan->lowerdev;
212
213    return dev_hard_header(skb, lowerdev, type, daddr,
214                   saddr ? : dev->dev_addr, len);
215}
216
217static const struct header_ops macvlan_hard_header_ops = {
218    .create = macvlan_hard_header,
219    .rebuild = eth_rebuild_header,
220    .parse = eth_header_parse,
221    .cache = eth_header_cache,
222    .cache_update = eth_header_cache_update,
223};
224
225static int macvlan_open(struct net_device *dev)
226{
227    struct macvlan_dev *vlan = netdev_priv(dev);
228    struct net_device *lowerdev = vlan->lowerdev;
229    int err;
230
231    err = -EBUSY;
232    if (macvlan_addr_busy(vlan->port, dev->dev_addr))
233        goto out;
234
235    err = dev_unicast_add(lowerdev, dev->dev_addr);
236    if (err < 0)
237        goto out;
238    if (dev->flags & IFF_ALLMULTI) {
239        err = dev_set_allmulti(lowerdev, 1);
240        if (err < 0)
241            goto del_unicast;
242    }
243    macvlan_hash_add(vlan);
244    return 0;
245
246del_unicast:
247    dev_unicast_delete(lowerdev, dev->dev_addr);
248out:
249    return err;
250}
251
252static int macvlan_stop(struct net_device *dev)
253{
254    struct macvlan_dev *vlan = netdev_priv(dev);
255    struct net_device *lowerdev = vlan->lowerdev;
256
257    dev_mc_unsync(lowerdev, dev);
258    if (dev->flags & IFF_ALLMULTI)
259        dev_set_allmulti(lowerdev, -1);
260
261    dev_unicast_delete(lowerdev, dev->dev_addr);
262
263    macvlan_hash_del(vlan);
264    return 0;
265}
266
267static int macvlan_set_mac_address(struct net_device *dev, void *p)
268{
269    struct macvlan_dev *vlan = netdev_priv(dev);
270    struct net_device *lowerdev = vlan->lowerdev;
271    struct sockaddr *addr = p;
272    int err;
273
274    if (!is_valid_ether_addr(addr->sa_data))
275        return -EADDRNOTAVAIL;
276
277    if (!(dev->flags & IFF_UP)) {
278        /* Just copy in the new address */
279        memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
280    } else {
281        /* Rehash and update the device filters */
282        if (macvlan_addr_busy(vlan->port, addr->sa_data))
283            return -EBUSY;
284
285        err = dev_unicast_add(lowerdev, addr->sa_data);
286        if (err)
287            return err;
288
289        dev_unicast_delete(lowerdev, dev->dev_addr);
290
291        macvlan_hash_change_addr(vlan, addr->sa_data);
292    }
293    return 0;
294}
295
296static void macvlan_change_rx_flags(struct net_device *dev, int change)
297{
298    struct macvlan_dev *vlan = netdev_priv(dev);
299    struct net_device *lowerdev = vlan->lowerdev;
300
301    if (change & IFF_ALLMULTI)
302        dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
303}
304
305static void macvlan_set_multicast_list(struct net_device *dev)
306{
307    struct macvlan_dev *vlan = netdev_priv(dev);
308
309    dev_mc_sync(vlan->lowerdev, dev);
310}
311
312static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
313{
314    struct macvlan_dev *vlan = netdev_priv(dev);
315
316    if (new_mtu < 68 || vlan->lowerdev->mtu < new_mtu)
317        return -EINVAL;
318    dev->mtu = new_mtu;
319    return 0;
320}
321
322/*
323 * macvlan network devices have devices nesting below it and are a special
324 * "super class" of normal network devices; split their locks off into a
325 * separate class since they always nest.
326 */
327static struct lock_class_key macvlan_netdev_xmit_lock_key;
328static struct lock_class_key macvlan_netdev_addr_lock_key;
329
330#define MACVLAN_FEATURES \
331    (NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
332     NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \
333     NETIF_F_TSO_ECN | NETIF_F_TSO6)
334
335#define MACVLAN_STATE_MASK \
336    ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
337
338static void macvlan_set_lockdep_class_one(struct net_device *dev,
339                      struct netdev_queue *txq,
340                      void *_unused)
341{
342    lockdep_set_class(&txq->_xmit_lock,
343              &macvlan_netdev_xmit_lock_key);
344}
345
346static void macvlan_set_lockdep_class(struct net_device *dev)
347{
348    lockdep_set_class(&dev->addr_list_lock,
349              &macvlan_netdev_addr_lock_key);
350    netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL);
351}
352
353static int macvlan_init(struct net_device *dev)
354{
355    struct macvlan_dev *vlan = netdev_priv(dev);
356    const struct net_device *lowerdev = vlan->lowerdev;
357
358    dev->state = (dev->state & ~MACVLAN_STATE_MASK) |
359                  (lowerdev->state & MACVLAN_STATE_MASK);
360    dev->features = lowerdev->features & MACVLAN_FEATURES;
361    dev->iflink = lowerdev->ifindex;
362    dev->hard_header_len = lowerdev->hard_header_len;
363
364    macvlan_set_lockdep_class(dev);
365
366    return 0;
367}
368
369static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
370                    struct ethtool_drvinfo *drvinfo)
371{
372    snprintf(drvinfo->driver, 32, "macvlan");
373    snprintf(drvinfo->version, 32, "0.1");
374}
375
376static u32 macvlan_ethtool_get_rx_csum(struct net_device *dev)
377{
378    const struct macvlan_dev *vlan = netdev_priv(dev);
379    return dev_ethtool_get_rx_csum(vlan->lowerdev);
380}
381
382static int macvlan_ethtool_get_settings(struct net_device *dev,
383                    struct ethtool_cmd *cmd)
384{
385    const struct macvlan_dev *vlan = netdev_priv(dev);
386    return dev_ethtool_get_settings(vlan->lowerdev, cmd);
387}
388
389static u32 macvlan_ethtool_get_flags(struct net_device *dev)
390{
391    const struct macvlan_dev *vlan = netdev_priv(dev);
392    return dev_ethtool_get_flags(vlan->lowerdev);
393}
394
395static const struct ethtool_ops macvlan_ethtool_ops = {
396    .get_link = ethtool_op_get_link,
397    .get_settings = macvlan_ethtool_get_settings,
398    .get_rx_csum = macvlan_ethtool_get_rx_csum,
399    .get_drvinfo = macvlan_ethtool_get_drvinfo,
400    .get_flags = macvlan_ethtool_get_flags,
401};
402
403static const struct net_device_ops macvlan_netdev_ops = {
404    .ndo_init = macvlan_init,
405    .ndo_open = macvlan_open,
406    .ndo_stop = macvlan_stop,
407    .ndo_start_xmit = macvlan_start_xmit,
408    .ndo_change_mtu = macvlan_change_mtu,
409    .ndo_change_rx_flags = macvlan_change_rx_flags,
410    .ndo_set_mac_address = macvlan_set_mac_address,
411    .ndo_set_multicast_list = macvlan_set_multicast_list,
412    .ndo_validate_addr = eth_validate_addr,
413};
414
415static void macvlan_setup(struct net_device *dev)
416{
417    ether_setup(dev);
418
419    dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
420    dev->netdev_ops = &macvlan_netdev_ops;
421    dev->destructor = free_netdev;
422    dev->header_ops = &macvlan_hard_header_ops,
423    dev->ethtool_ops = &macvlan_ethtool_ops;
424    dev->tx_queue_len = 0;
425}
426
427static int macvlan_port_create(struct net_device *dev)
428{
429    struct macvlan_port *port;
430    unsigned int i;
431
432    if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
433        return -EINVAL;
434
435    port = kzalloc(sizeof(*port), GFP_KERNEL);
436    if (port == NULL)
437        return -ENOMEM;
438
439    port->dev = dev;
440    INIT_LIST_HEAD(&port->vlans);
441    for (i = 0; i < MACVLAN_HASH_SIZE; i++)
442        INIT_HLIST_HEAD(&port->vlan_hash[i]);
443    rcu_assign_pointer(dev->macvlan_port, port);
444    return 0;
445}
446
447static void macvlan_port_destroy(struct net_device *dev)
448{
449    struct macvlan_port *port = dev->macvlan_port;
450
451    rcu_assign_pointer(dev->macvlan_port, NULL);
452    synchronize_rcu();
453    kfree(port);
454}
455
456static void macvlan_transfer_operstate(struct net_device *dev)
457{
458    struct macvlan_dev *vlan = netdev_priv(dev);
459    const struct net_device *lowerdev = vlan->lowerdev;
460
461    if (lowerdev->operstate == IF_OPER_DORMANT)
462        netif_dormant_on(dev);
463    else
464        netif_dormant_off(dev);
465
466    if (netif_carrier_ok(lowerdev)) {
467        if (!netif_carrier_ok(dev))
468            netif_carrier_on(dev);
469    } else {
470        if (netif_carrier_ok(dev))
471            netif_carrier_off(dev);
472    }
473}
474
475static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[])
476{
477    if (tb[IFLA_ADDRESS]) {
478        if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
479            return -EINVAL;
480        if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
481            return -EADDRNOTAVAIL;
482    }
483    return 0;
484}
485
486static int macvlan_newlink(struct net_device *dev,
487               struct nlattr *tb[], struct nlattr *data[])
488{
489    struct macvlan_dev *vlan = netdev_priv(dev);
490    struct macvlan_port *port;
491    struct net_device *lowerdev;
492    int err;
493
494    if (!tb[IFLA_LINK])
495        return -EINVAL;
496
497    lowerdev = __dev_get_by_index(dev_net(dev), nla_get_u32(tb[IFLA_LINK]));
498    if (lowerdev == NULL)
499        return -ENODEV;
500
501    /* When creating macvlans on top of other macvlans - use
502     * the real device as the lowerdev.
503     */
504    if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops) {
505        struct macvlan_dev *lowervlan = netdev_priv(lowerdev);
506        lowerdev = lowervlan->lowerdev;
507    }
508
509    if (!tb[IFLA_MTU])
510        dev->mtu = lowerdev->mtu;
511    else if (dev->mtu > lowerdev->mtu)
512        return -EINVAL;
513
514    if (!tb[IFLA_ADDRESS])
515        random_ether_addr(dev->dev_addr);
516
517    if (lowerdev->macvlan_port == NULL) {
518        err = macvlan_port_create(lowerdev);
519        if (err < 0)
520            return err;
521    }
522    port = lowerdev->macvlan_port;
523
524    vlan->lowerdev = lowerdev;
525    vlan->dev = dev;
526    vlan->port = port;
527
528    err = register_netdevice(dev);
529    if (err < 0)
530        return err;
531
532    list_add_tail(&vlan->list, &port->vlans);
533    macvlan_transfer_operstate(dev);
534    return 0;
535}
536
537static void macvlan_dellink(struct net_device *dev)
538{
539    struct macvlan_dev *vlan = netdev_priv(dev);
540    struct macvlan_port *port = vlan->port;
541
542    list_del(&vlan->list);
543    unregister_netdevice(dev);
544
545    if (list_empty(&port->vlans))
546        macvlan_port_destroy(port->dev);
547}
548
549static struct rtnl_link_ops macvlan_link_ops __read_mostly = {
550    .kind = "macvlan",
551    .priv_size = sizeof(struct macvlan_dev),
552    .setup = macvlan_setup,
553    .validate = macvlan_validate,
554    .newlink = macvlan_newlink,
555    .dellink = macvlan_dellink,
556};
557
558static int macvlan_device_event(struct notifier_block *unused,
559                unsigned long event, void *ptr)
560{
561    struct net_device *dev = ptr;
562    struct macvlan_dev *vlan, *next;
563    struct macvlan_port *port;
564
565    port = dev->macvlan_port;
566    if (port == NULL)
567        return NOTIFY_DONE;
568
569    switch (event) {
570    case NETDEV_CHANGE:
571        list_for_each_entry(vlan, &port->vlans, list)
572            macvlan_transfer_operstate(vlan->dev);
573        break;
574    case NETDEV_FEAT_CHANGE:
575        list_for_each_entry(vlan, &port->vlans, list) {
576            vlan->dev->features = dev->features & MACVLAN_FEATURES;
577            netdev_features_change(vlan->dev);
578        }
579        break;
580    case NETDEV_UNREGISTER:
581        list_for_each_entry_safe(vlan, next, &port->vlans, list)
582            macvlan_dellink(vlan->dev);
583        break;
584    }
585    return NOTIFY_DONE;
586}
587
588static struct notifier_block macvlan_notifier_block __read_mostly = {
589    .notifier_call = macvlan_device_event,
590};
591
592static int __init macvlan_init_module(void)
593{
594    int err;
595
596    register_netdevice_notifier(&macvlan_notifier_block);
597    macvlan_handle_frame_hook = macvlan_handle_frame;
598
599    err = rtnl_link_register(&macvlan_link_ops);
600    if (err < 0)
601        goto err1;
602    return 0;
603err1:
604    macvlan_handle_frame_hook = NULL;
605    unregister_netdevice_notifier(&macvlan_notifier_block);
606    return err;
607}
608
609static void __exit macvlan_cleanup_module(void)
610{
611    rtnl_link_unregister(&macvlan_link_ops);
612    macvlan_handle_frame_hook = NULL;
613    unregister_netdevice_notifier(&macvlan_notifier_block);
614}
615
616module_init(macvlan_init_module);
617module_exit(macvlan_cleanup_module);
618
619MODULE_LICENSE("GPL");
620MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
621MODULE_DESCRIPTION("Driver for MAC address based VLANs");
622MODULE_ALIAS_RTNL_LINK("macvlan");
623

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