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