Root/net/bridge/br_if.c

1/*
2 * Userspace interface
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14#include <linux/kernel.h>
15#include <linux/netdevice.h>
16#include <linux/netpoll.h>
17#include <linux/ethtool.h>
18#include <linux/if_arp.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/rtnetlink.h>
22#include <linux/if_ether.h>
23#include <linux/slab.h>
24#include <net/sock.h>
25
26#include "br_private.h"
27
28/*
29 * Determine initial path cost based on speed.
30 * using recommendations from 802.1d standard
31 *
32 * Since driver might sleep need to not be holding any locks.
33 */
34static int port_cost(struct net_device *dev)
35{
36    if (dev->ethtool_ops && dev->ethtool_ops->get_settings) {
37        struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET, };
38
39        if (!dev->ethtool_ops->get_settings(dev, &ecmd)) {
40            switch(ecmd.speed) {
41            case SPEED_10000:
42                return 2;
43            case SPEED_1000:
44                return 4;
45            case SPEED_100:
46                return 19;
47            case SPEED_10:
48                return 100;
49            }
50        }
51    }
52
53    /* Old silly heuristics based on name */
54    if (!strncmp(dev->name, "lec", 3))
55        return 7;
56
57    if (!strncmp(dev->name, "plip", 4))
58        return 2500;
59
60    return 100; /* assume old 10Mbps */
61}
62
63
64/* Check for port carrier transistions. */
65void br_port_carrier_check(struct net_bridge_port *p)
66{
67    struct net_device *dev = p->dev;
68    struct net_bridge *br = p->br;
69
70    if (netif_running(dev) && netif_carrier_ok(dev))
71        p->path_cost = port_cost(dev);
72
73    if (!netif_running(br->dev))
74        return;
75
76    spin_lock_bh(&br->lock);
77    if (netif_running(dev) && netif_carrier_ok(dev)) {
78        if (p->state == BR_STATE_DISABLED)
79            br_stp_enable_port(p);
80    } else {
81        if (p->state != BR_STATE_DISABLED)
82            br_stp_disable_port(p);
83    }
84    spin_unlock_bh(&br->lock);
85}
86
87static void release_nbp(struct kobject *kobj)
88{
89    struct net_bridge_port *p
90        = container_of(kobj, struct net_bridge_port, kobj);
91    kfree(p);
92}
93
94static struct kobj_type brport_ktype = {
95#ifdef CONFIG_SYSFS
96    .sysfs_ops = &brport_sysfs_ops,
97#endif
98    .release = release_nbp,
99};
100
101static void destroy_nbp(struct net_bridge_port *p)
102{
103    struct net_device *dev = p->dev;
104
105    p->br = NULL;
106    p->dev = NULL;
107    dev_put(dev);
108
109    kobject_put(&p->kobj);
110}
111
112static void destroy_nbp_rcu(struct rcu_head *head)
113{
114    struct net_bridge_port *p =
115            container_of(head, struct net_bridge_port, rcu);
116    destroy_nbp(p);
117}
118
119/* Delete port(interface) from bridge is done in two steps.
120 * via RCU. First step, marks device as down. That deletes
121 * all the timers and stops new packets from flowing through.
122 *
123 * Final cleanup doesn't occur until after all CPU's finished
124 * processing packets.
125 *
126 * Protected from multiple admin operations by RTNL mutex
127 */
128static void del_nbp(struct net_bridge_port *p)
129{
130    struct net_bridge *br = p->br;
131    struct net_device *dev = p->dev;
132
133    sysfs_remove_link(br->ifobj, p->dev->name);
134
135    dev_set_promiscuity(dev, -1);
136
137    spin_lock_bh(&br->lock);
138    br_stp_disable_port(p);
139    spin_unlock_bh(&br->lock);
140
141    br_ifinfo_notify(RTM_DELLINK, p);
142
143    br_fdb_delete_by_port(br, p, 1);
144
145    list_del_rcu(&p->list);
146
147    dev->priv_flags &= ~IFF_BRIDGE_PORT;
148
149    netdev_rx_handler_unregister(dev);
150
151    netdev_set_master(dev, NULL);
152
153    br_multicast_del_port(p);
154
155    kobject_uevent(&p->kobj, KOBJ_REMOVE);
156    kobject_del(&p->kobj);
157
158    br_netpoll_disable(p);
159
160    call_rcu(&p->rcu, destroy_nbp_rcu);
161}
162
163/* called with RTNL */
164static void del_br(struct net_bridge *br, struct list_head *head)
165{
166    struct net_bridge_port *p, *n;
167
168    list_for_each_entry_safe(p, n, &br->port_list, list) {
169        del_nbp(p);
170    }
171
172    del_timer_sync(&br->gc_timer);
173
174    br_sysfs_delbr(br->dev);
175    unregister_netdevice_queue(br->dev, head);
176}
177
178static struct net_device *new_bridge_dev(struct net *net, const char *name)
179{
180    struct net_bridge *br;
181    struct net_device *dev;
182
183    dev = alloc_netdev(sizeof(struct net_bridge), name,
184               br_dev_setup);
185
186    if (!dev)
187        return NULL;
188    dev_net_set(dev, net);
189
190    br = netdev_priv(dev);
191    br->dev = dev;
192
193    br->stats = alloc_percpu(struct br_cpu_netstats);
194    if (!br->stats) {
195        free_netdev(dev);
196        return NULL;
197    }
198
199    spin_lock_init(&br->lock);
200    INIT_LIST_HEAD(&br->port_list);
201    spin_lock_init(&br->hash_lock);
202
203    br->bridge_id.prio[0] = 0x80;
204    br->bridge_id.prio[1] = 0x00;
205
206    memcpy(br->group_addr, br_group_address, ETH_ALEN);
207
208    br->feature_mask = dev->features;
209    br->stp_enabled = BR_NO_STP;
210    br->designated_root = br->bridge_id;
211    br->root_path_cost = 0;
212    br->root_port = 0;
213    br->bridge_max_age = br->max_age = 20 * HZ;
214    br->bridge_hello_time = br->hello_time = 2 * HZ;
215    br->bridge_forward_delay = br->forward_delay = 15 * HZ;
216    br->topology_change = 0;
217    br->topology_change_detected = 0;
218    br->ageing_time = 300 * HZ;
219
220    br_netfilter_rtable_init(br);
221
222    br_stp_timer_init(br);
223    br_multicast_init(br);
224
225    return dev;
226}
227
228/* find an available port number */
229static int find_portno(struct net_bridge *br)
230{
231    int index;
232    struct net_bridge_port *p;
233    unsigned long *inuse;
234
235    inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
236            GFP_KERNEL);
237    if (!inuse)
238        return -ENOMEM;
239
240    set_bit(0, inuse); /* zero is reserved */
241    list_for_each_entry(p, &br->port_list, list) {
242        set_bit(p->port_no, inuse);
243    }
244    index = find_first_zero_bit(inuse, BR_MAX_PORTS);
245    kfree(inuse);
246
247    return (index >= BR_MAX_PORTS) ? -EXFULL : index;
248}
249
250/* called with RTNL but without bridge lock */
251static struct net_bridge_port *new_nbp(struct net_bridge *br,
252                       struct net_device *dev)
253{
254    int index;
255    struct net_bridge_port *p;
256
257    index = find_portno(br);
258    if (index < 0)
259        return ERR_PTR(index);
260
261    p = kzalloc(sizeof(*p), GFP_KERNEL);
262    if (p == NULL)
263        return ERR_PTR(-ENOMEM);
264
265    p->br = br;
266    dev_hold(dev);
267    p->dev = dev;
268    p->path_cost = port_cost(dev);
269    p->priority = 0x8000 >> BR_PORT_BITS;
270    p->port_no = index;
271    p->flags = 0;
272    br_init_port(p);
273    p->state = BR_STATE_DISABLED;
274    br_stp_port_timer_init(p);
275    br_multicast_add_port(p);
276
277    return p;
278}
279
280static struct device_type br_type = {
281    .name = "bridge",
282};
283
284int br_add_bridge(struct net *net, const char *name)
285{
286    struct net_device *dev;
287    int ret;
288
289    dev = new_bridge_dev(net, name);
290    if (!dev)
291        return -ENOMEM;
292
293    rtnl_lock();
294    if (strchr(dev->name, '%')) {
295        ret = dev_alloc_name(dev, dev->name);
296        if (ret < 0)
297            goto out_free;
298    }
299
300    SET_NETDEV_DEVTYPE(dev, &br_type);
301
302    ret = register_netdevice(dev);
303    if (ret)
304        goto out_free;
305
306    ret = br_sysfs_addbr(dev);
307    if (ret)
308        unregister_netdevice(dev);
309 out:
310    rtnl_unlock();
311    return ret;
312
313out_free:
314    free_netdev(dev);
315    goto out;
316}
317
318int br_del_bridge(struct net *net, const char *name)
319{
320    struct net_device *dev;
321    int ret = 0;
322
323    rtnl_lock();
324    dev = __dev_get_by_name(net, name);
325    if (dev == NULL)
326        ret = -ENXIO; /* Could not find device */
327
328    else if (!(dev->priv_flags & IFF_EBRIDGE)) {
329        /* Attempt to delete non bridge device! */
330        ret = -EPERM;
331    }
332
333    else if (dev->flags & IFF_UP) {
334        /* Not shutdown yet. */
335        ret = -EBUSY;
336    }
337
338    else
339        del_br(netdev_priv(dev), NULL);
340
341    rtnl_unlock();
342    return ret;
343}
344
345/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
346int br_min_mtu(const struct net_bridge *br)
347{
348    const struct net_bridge_port *p;
349    int mtu = 0;
350
351    ASSERT_RTNL();
352
353    if (list_empty(&br->port_list))
354        mtu = ETH_DATA_LEN;
355    else {
356        list_for_each_entry(p, &br->port_list, list) {
357            if (!mtu || p->dev->mtu < mtu)
358                mtu = p->dev->mtu;
359        }
360    }
361    return mtu;
362}
363
364/*
365 * Recomputes features using slave's features
366 */
367void br_features_recompute(struct net_bridge *br)
368{
369    struct net_bridge_port *p;
370    u32 features, mask;
371
372    features = mask = br->feature_mask;
373    if (list_empty(&br->port_list))
374        goto done;
375
376    features &= ~NETIF_F_ONE_FOR_ALL;
377
378    list_for_each_entry(p, &br->port_list, list) {
379        features = netdev_increment_features(features,
380                             p->dev->features, mask);
381    }
382
383done:
384    br->dev->features = netdev_fix_features(br->dev, features);
385}
386
387/* called with RTNL */
388int br_add_if(struct net_bridge *br, struct net_device *dev)
389{
390    struct net_bridge_port *p;
391    int err = 0;
392    bool changed_addr;
393
394    /* Don't allow bridging non-ethernet like devices */
395    if ((dev->flags & IFF_LOOPBACK) ||
396        dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN)
397        return -EINVAL;
398
399    /* No bridging of bridges */
400    if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
401        return -ELOOP;
402
403    /* Device is already being bridged */
404    if (br_port_exists(dev))
405        return -EBUSY;
406
407    /* No bridging devices that dislike that (e.g. wireless) */
408    if (dev->priv_flags & IFF_DONT_BRIDGE)
409        return -EOPNOTSUPP;
410
411    p = new_nbp(br, dev);
412    if (IS_ERR(p))
413        return PTR_ERR(p);
414
415    err = dev_set_promiscuity(dev, 1);
416    if (err)
417        goto put_back;
418
419    err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
420                   SYSFS_BRIDGE_PORT_ATTR);
421    if (err)
422        goto err0;
423
424    err = br_fdb_insert(br, p, dev->dev_addr);
425    if (err)
426        goto err1;
427
428    err = br_sysfs_addif(p);
429    if (err)
430        goto err2;
431
432    if (br_netpoll_info(br) && ((err = br_netpoll_enable(p))))
433        goto err3;
434
435    err = netdev_set_master(dev, br->dev);
436    if (err)
437        goto err3;
438
439    err = netdev_rx_handler_register(dev, br_handle_frame, p);
440    if (err)
441        goto err4;
442
443    dev->priv_flags |= IFF_BRIDGE_PORT;
444
445    dev_disable_lro(dev);
446
447    list_add_rcu(&p->list, &br->port_list);
448
449    spin_lock_bh(&br->lock);
450    changed_addr = br_stp_recalculate_bridge_id(br);
451    br_features_recompute(br);
452
453    if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
454        (br->dev->flags & IFF_UP))
455        br_stp_enable_port(p);
456    spin_unlock_bh(&br->lock);
457
458    br_ifinfo_notify(RTM_NEWLINK, p);
459
460    if (changed_addr)
461        call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
462
463    dev_set_mtu(br->dev, br_min_mtu(br));
464
465    kobject_uevent(&p->kobj, KOBJ_ADD);
466
467    return 0;
468
469err4:
470    netdev_set_master(dev, NULL);
471err3:
472    sysfs_remove_link(br->ifobj, p->dev->name);
473err2:
474    br_fdb_delete_by_port(br, p, 1);
475err1:
476    kobject_put(&p->kobj);
477    p = NULL; /* kobject_put frees */
478err0:
479    dev_set_promiscuity(dev, -1);
480put_back:
481    dev_put(dev);
482    kfree(p);
483    return err;
484}
485
486/* called with RTNL */
487int br_del_if(struct net_bridge *br, struct net_device *dev)
488{
489    struct net_bridge_port *p;
490
491    p = br_port_get_rtnl(dev);
492    if (!p || p->br != br)
493        return -EINVAL;
494
495    del_nbp(p);
496
497    spin_lock_bh(&br->lock);
498    br_stp_recalculate_bridge_id(br);
499    br_features_recompute(br);
500    spin_unlock_bh(&br->lock);
501
502    return 0;
503}
504
505void __net_exit br_net_exit(struct net *net)
506{
507    struct net_device *dev;
508    LIST_HEAD(list);
509
510    rtnl_lock();
511    for_each_netdev(net, dev)
512        if (dev->priv_flags & IFF_EBRIDGE)
513            del_br(netdev_priv(dev), &list);
514
515    unregister_netdevice_many(&list);
516    rtnl_unlock();
517
518}
519

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.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

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



interactive