blob: 70d3ef4a2c5fdef238619959de7787c49cd833d7 [file] [log] [blame]
Patrick McHardyb863ceb2007-07-14 18:55:06 -07001/*
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>
Franck Bui-Huu82524742008-05-12 21:21:05 +020023#include <linux/rculist.h>
Patrick McHardyb863ceb2007-07-14 18:55:06 -070024#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
Eric Biedermanf9ac30f2009-03-13 13:16:13 -070063static 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
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700104static 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
Patrick McHardyefbbced2008-11-26 15:30:48 -0800114 if (skb->protocol == htons(ETH_P_PAUSE))
115 return;
116
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700117 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;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700120
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++;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700131
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++;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700179
180 skb->dev = dev;
181 skb->pkt_type = PACKET_HOST;
182
183 netif_rx(skb);
184 return NULL;
185}
186
Stephen Hemminger00829822008-11-20 20:14:53 -0800187static int macvlan_start_xmit(struct sk_buff *skb, struct net_device *dev)
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700188{
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,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700207 unsigned short type, const void *daddr,
208 const void *saddr, unsigned len)
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700209{
210 const struct macvlan_dev *vlan = netdev_priv(dev);
211 struct net_device *lowerdev = vlan->lowerdev;
212
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700213 return dev_hard_header(skb, lowerdev, type, daddr,
214 saddr ? : dev->dev_addr, len);
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700215}
216
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700217static const struct header_ops macvlan_hard_header_ops = {
218 .create = macvlan_hard_header,
219 .rebuild = eth_rebuild_header,
220 .parse = eth_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700221 .cache = eth_header_cache,
222 .cache_update = eth_header_cache_update,
223};
224
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700225static int macvlan_open(struct net_device *dev)
226{
227 struct macvlan_dev *vlan = netdev_priv(dev);
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700228 struct net_device *lowerdev = vlan->lowerdev;
229 int err;
230
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700231 err = -EBUSY;
232 if (macvlan_addr_busy(vlan->port, dev->dev_addr))
233 goto out;
234
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700235 err = dev_unicast_add(lowerdev, dev->dev_addr, ETH_ALEN);
236 if (err < 0)
Wang Chenb89fb7d2008-07-14 20:57:07 -0700237 goto out;
238 if (dev->flags & IFF_ALLMULTI) {
239 err = dev_set_allmulti(lowerdev, 1);
240 if (err < 0)
241 goto del_unicast;
242 }
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700243 macvlan_hash_add(vlan);
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700244 return 0;
Wang Chenb89fb7d2008-07-14 20:57:07 -0700245
246del_unicast:
247 dev_unicast_delete(lowerdev, dev->dev_addr, ETH_ALEN);
248out:
249 return err;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700250}
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, ETH_ALEN);
262
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700263 macvlan_hash_del(vlan);
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700264 return 0;
265}
266
Patrick McHardyad5d20a2007-11-19 22:00:42 -0800267static 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
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700277 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;
Patrick McHardyad5d20a2007-11-19 22:00:42 -0800284
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700285 if ((err = dev_unicast_add(lowerdev, addr->sa_data, ETH_ALEN)))
286 return err;
Patrick McHardyad5d20a2007-11-19 22:00:42 -0800287
Eric Biedermanf9ac30f2009-03-13 13:16:13 -0700288 dev_unicast_delete(lowerdev, dev->dev_addr, ETH_ALEN);
289
290 macvlan_hash_change_addr(vlan, addr->sa_data);
291 }
Patrick McHardyad5d20a2007-11-19 22:00:42 -0800292 return 0;
293}
294
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700295static void macvlan_change_rx_flags(struct net_device *dev, int change)
296{
297 struct macvlan_dev *vlan = netdev_priv(dev);
298 struct net_device *lowerdev = vlan->lowerdev;
299
300 if (change & IFF_ALLMULTI)
301 dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
302}
303
304static void macvlan_set_multicast_list(struct net_device *dev)
305{
306 struct macvlan_dev *vlan = netdev_priv(dev);
307
308 dev_mc_sync(vlan->lowerdev, dev);
309}
310
311static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
312{
313 struct macvlan_dev *vlan = netdev_priv(dev);
314
315 if (new_mtu < 68 || vlan->lowerdev->mtu < new_mtu)
316 return -EINVAL;
317 dev->mtu = new_mtu;
318 return 0;
319}
320
321/*
322 * macvlan network devices have devices nesting below it and are a special
323 * "super class" of normal network devices; split their locks off into a
324 * separate class since they always nest.
325 */
326static struct lock_class_key macvlan_netdev_xmit_lock_key;
David S. Millercf508b12008-07-22 14:16:42 -0700327static struct lock_class_key macvlan_netdev_addr_lock_key;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700328
329#define MACVLAN_FEATURES \
330 (NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
331 NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \
332 NETIF_F_TSO_ECN | NETIF_F_TSO6)
333
334#define MACVLAN_STATE_MASK \
335 ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
336
David S. Millere8a04642008-07-17 00:34:19 -0700337static void macvlan_set_lockdep_class_one(struct net_device *dev,
338 struct netdev_queue *txq,
339 void *_unused)
David S. Millerc773e842008-07-08 23:13:53 -0700340{
341 lockdep_set_class(&txq->_xmit_lock,
342 &macvlan_netdev_xmit_lock_key);
343}
344
345static void macvlan_set_lockdep_class(struct net_device *dev)
346{
David S. Millercf508b12008-07-22 14:16:42 -0700347 lockdep_set_class(&dev->addr_list_lock,
348 &macvlan_netdev_addr_lock_key);
David S. Millere8a04642008-07-17 00:34:19 -0700349 netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL);
David S. Millerc773e842008-07-08 23:13:53 -0700350}
351
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700352static int macvlan_init(struct net_device *dev)
353{
354 struct macvlan_dev *vlan = netdev_priv(dev);
355 const struct net_device *lowerdev = vlan->lowerdev;
356
357 dev->state = (dev->state & ~MACVLAN_STATE_MASK) |
358 (lowerdev->state & MACVLAN_STATE_MASK);
359 dev->features = lowerdev->features & MACVLAN_FEATURES;
360 dev->iflink = lowerdev->ifindex;
361
David S. Millerc773e842008-07-08 23:13:53 -0700362 macvlan_set_lockdep_class(dev);
363
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700364 return 0;
365}
366
367static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
368 struct ethtool_drvinfo *drvinfo)
369{
370 snprintf(drvinfo->driver, 32, "macvlan");
371 snprintf(drvinfo->version, 32, "0.1");
372}
373
374static u32 macvlan_ethtool_get_rx_csum(struct net_device *dev)
375{
376 const struct macvlan_dev *vlan = netdev_priv(dev);
377 struct net_device *lowerdev = vlan->lowerdev;
378
379 if (lowerdev->ethtool_ops->get_rx_csum == NULL)
380 return 0;
381 return lowerdev->ethtool_ops->get_rx_csum(lowerdev);
382}
383
Stephen Hemminger9edb8bb2008-10-29 15:31:53 -0700384static int macvlan_ethtool_get_settings(struct net_device *dev,
385 struct ethtool_cmd *cmd)
386{
387 const struct macvlan_dev *vlan = netdev_priv(dev);
388 struct net_device *lowerdev = vlan->lowerdev;
389
390 if (!lowerdev->ethtool_ops->get_settings)
391 return -EOPNOTSUPP;
392
393 return lowerdev->ethtool_ops->get_settings(lowerdev, cmd);
394}
395
396static u32 macvlan_ethtool_get_flags(struct net_device *dev)
397{
398 const struct macvlan_dev *vlan = netdev_priv(dev);
399 struct net_device *lowerdev = vlan->lowerdev;
400
401 if (!lowerdev->ethtool_ops->get_flags)
402 return 0;
403 return lowerdev->ethtool_ops->get_flags(lowerdev);
404}
405
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700406static const struct ethtool_ops macvlan_ethtool_ops = {
407 .get_link = ethtool_op_get_link,
Stephen Hemminger9edb8bb2008-10-29 15:31:53 -0700408 .get_settings = macvlan_ethtool_get_settings,
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700409 .get_rx_csum = macvlan_ethtool_get_rx_csum,
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700410 .get_drvinfo = macvlan_ethtool_get_drvinfo,
Stephen Hemminger9edb8bb2008-10-29 15:31:53 -0700411 .get_flags = macvlan_ethtool_get_flags,
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700412};
413
Stephen Hemminger54a30c92008-11-19 21:51:06 -0800414static const struct net_device_ops macvlan_netdev_ops = {
415 .ndo_init = macvlan_init,
416 .ndo_open = macvlan_open,
417 .ndo_stop = macvlan_stop,
Stephen Hemminger00829822008-11-20 20:14:53 -0800418 .ndo_start_xmit = macvlan_start_xmit,
Stephen Hemminger54a30c92008-11-19 21:51:06 -0800419 .ndo_change_mtu = macvlan_change_mtu,
420 .ndo_change_rx_flags = macvlan_change_rx_flags,
421 .ndo_set_mac_address = macvlan_set_mac_address,
422 .ndo_set_multicast_list = macvlan_set_multicast_list,
423 .ndo_validate_addr = eth_validate_addr,
424};
425
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700426static void macvlan_setup(struct net_device *dev)
427{
428 ether_setup(dev);
429
Stephen Hemminger54a30c92008-11-19 21:51:06 -0800430 dev->netdev_ops = &macvlan_netdev_ops;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700431 dev->destructor = free_netdev;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700432 dev->header_ops = &macvlan_hard_header_ops,
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700433 dev->ethtool_ops = &macvlan_ethtool_ops;
434 dev->tx_queue_len = 0;
435}
436
437static int macvlan_port_create(struct net_device *dev)
438{
439 struct macvlan_port *port;
440 unsigned int i;
441
442 if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
443 return -EINVAL;
444
445 port = kzalloc(sizeof(*port), GFP_KERNEL);
446 if (port == NULL)
447 return -ENOMEM;
448
449 port->dev = dev;
450 INIT_LIST_HEAD(&port->vlans);
451 for (i = 0; i < MACVLAN_HASH_SIZE; i++)
452 INIT_HLIST_HEAD(&port->vlan_hash[i]);
453 rcu_assign_pointer(dev->macvlan_port, port);
454 return 0;
455}
456
457static void macvlan_port_destroy(struct net_device *dev)
458{
459 struct macvlan_port *port = dev->macvlan_port;
460
461 rcu_assign_pointer(dev->macvlan_port, NULL);
462 synchronize_rcu();
463 kfree(port);
464}
465
466static void macvlan_transfer_operstate(struct net_device *dev)
467{
468 struct macvlan_dev *vlan = netdev_priv(dev);
469 const struct net_device *lowerdev = vlan->lowerdev;
470
471 if (lowerdev->operstate == IF_OPER_DORMANT)
472 netif_dormant_on(dev);
473 else
474 netif_dormant_off(dev);
475
476 if (netif_carrier_ok(lowerdev)) {
477 if (!netif_carrier_ok(dev))
478 netif_carrier_on(dev);
479 } else {
Patrick McHardyf12ca5f2008-01-21 00:47:08 -0800480 if (netif_carrier_ok(dev))
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700481 netif_carrier_off(dev);
482 }
483}
484
485static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[])
486{
487 if (tb[IFLA_ADDRESS]) {
488 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
489 return -EINVAL;
490 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
491 return -EADDRNOTAVAIL;
492 }
493 return 0;
494}
495
496static int macvlan_newlink(struct net_device *dev,
497 struct nlattr *tb[], struct nlattr *data[])
498{
499 struct macvlan_dev *vlan = netdev_priv(dev);
500 struct macvlan_port *port;
501 struct net_device *lowerdev;
502 int err;
503
504 if (!tb[IFLA_LINK])
505 return -EINVAL;
506
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900507 lowerdev = __dev_get_by_index(dev_net(dev), nla_get_u32(tb[IFLA_LINK]));
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700508 if (lowerdev == NULL)
509 return -ENODEV;
510
Eric Biedermanb0832a22009-03-13 13:15:37 -0700511 /* When creating macvlans on top of other macvlans - use
512 * the real device as the lowerdev.
Patrick McHardya6ca5f12008-01-10 22:39:28 -0800513 */
Eric Biedermanb0832a22009-03-13 13:15:37 -0700514 if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops) {
515 struct macvlan_dev *lowervlan = netdev_priv(lowerdev);
516 lowerdev = lowervlan->lowerdev;
517 }
Patrick McHardya6ca5f12008-01-10 22:39:28 -0800518
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700519 if (!tb[IFLA_MTU])
520 dev->mtu = lowerdev->mtu;
521 else if (dev->mtu > lowerdev->mtu)
522 return -EINVAL;
523
524 if (!tb[IFLA_ADDRESS])
525 random_ether_addr(dev->dev_addr);
526
527 if (lowerdev->macvlan_port == NULL) {
528 err = macvlan_port_create(lowerdev);
529 if (err < 0)
530 return err;
531 }
532 port = lowerdev->macvlan_port;
533
534 vlan->lowerdev = lowerdev;
535 vlan->dev = dev;
536 vlan->port = port;
537
538 err = register_netdevice(dev);
539 if (err < 0)
540 return err;
541
542 list_add_tail(&vlan->list, &port->vlans);
543 macvlan_transfer_operstate(dev);
544 return 0;
545}
546
547static void macvlan_dellink(struct net_device *dev)
548{
549 struct macvlan_dev *vlan = netdev_priv(dev);
550 struct macvlan_port *port = vlan->port;
551
552 list_del(&vlan->list);
553 unregister_netdevice(dev);
554
555 if (list_empty(&port->vlans))
Patrick McHardy73120962008-05-08 01:13:31 -0700556 macvlan_port_destroy(port->dev);
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700557}
558
559static struct rtnl_link_ops macvlan_link_ops __read_mostly = {
560 .kind = "macvlan",
561 .priv_size = sizeof(struct macvlan_dev),
562 .setup = macvlan_setup,
563 .validate = macvlan_validate,
564 .newlink = macvlan_newlink,
565 .dellink = macvlan_dellink,
566};
567
568static int macvlan_device_event(struct notifier_block *unused,
569 unsigned long event, void *ptr)
570{
571 struct net_device *dev = ptr;
572 struct macvlan_dev *vlan, *next;
573 struct macvlan_port *port;
574
575 port = dev->macvlan_port;
576 if (port == NULL)
577 return NOTIFY_DONE;
578
579 switch (event) {
580 case NETDEV_CHANGE:
581 list_for_each_entry(vlan, &port->vlans, list)
582 macvlan_transfer_operstate(vlan->dev);
583 break;
584 case NETDEV_FEAT_CHANGE:
585 list_for_each_entry(vlan, &port->vlans, list) {
586 vlan->dev->features = dev->features & MACVLAN_FEATURES;
587 netdev_features_change(vlan->dev);
588 }
589 break;
590 case NETDEV_UNREGISTER:
591 list_for_each_entry_safe(vlan, next, &port->vlans, list)
592 macvlan_dellink(vlan->dev);
593 break;
594 }
595 return NOTIFY_DONE;
596}
597
598static struct notifier_block macvlan_notifier_block __read_mostly = {
599 .notifier_call = macvlan_device_event,
600};
601
602static int __init macvlan_init_module(void)
603{
604 int err;
605
606 register_netdevice_notifier(&macvlan_notifier_block);
607 macvlan_handle_frame_hook = macvlan_handle_frame;
608
609 err = rtnl_link_register(&macvlan_link_ops);
610 if (err < 0)
611 goto err1;
612 return 0;
613err1:
Rami Rosen52913242008-01-31 16:56:03 -0800614 macvlan_handle_frame_hook = NULL;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700615 unregister_netdevice_notifier(&macvlan_notifier_block);
616 return err;
617}
618
619static void __exit macvlan_cleanup_module(void)
620{
621 rtnl_link_unregister(&macvlan_link_ops);
622 macvlan_handle_frame_hook = NULL;
623 unregister_netdevice_notifier(&macvlan_notifier_block);
624}
625
626module_init(macvlan_init_module);
627module_exit(macvlan_cleanup_module);
628
629MODULE_LICENSE("GPL");
630MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
631MODULE_DESCRIPTION("Driver for MAC address based VLANs");
632MODULE_ALIAS_RTNL_LINK("macvlan");