1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/netdevice.h>
16#include <linux/etherdevice.h>
17#include <linux/netpoll.h>
18#include <linux/ethtool.h>
19#include <linux/if_arp.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/rtnetlink.h>
23#include <linux/if_ether.h>
24#include <linux/slab.h>
25#include <net/sock.h>
26#include <linux/if_vlan.h>
27
28#include "br_private.h"
29
30
31
32
33
34
35
36static int port_cost(struct net_device *dev)
37{
38 struct ethtool_cmd ecmd;
39
40 if (!__ethtool_get_settings(dev, &ecmd)) {
41 switch (ethtool_cmd_speed(&ecmd)) {
42 case SPEED_10000:
43 return 2;
44 case SPEED_1000:
45 return 4;
46 case SPEED_100:
47 return 19;
48 case SPEED_10:
49 return 100;
50 }
51 }
52
53
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;
61}
62
63
64
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 (!(p->flags & BR_ADMIN_COST) &&
71 netif_running(dev) && netif_oper_up(dev))
72 p->path_cost = port_cost(dev);
73
74 if (!netif_running(br->dev))
75 return;
76
77 spin_lock_bh(&br->lock);
78 if (netif_running(dev) && netif_oper_up(dev)) {
79 if (p->state == BR_STATE_DISABLED)
80 br_stp_enable_port(p);
81 } else {
82 if (p->state != BR_STATE_DISABLED)
83 br_stp_disable_port(p);
84 }
85 spin_unlock_bh(&br->lock);
86}
87
88static 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
95static struct kobj_type brport_ktype = {
96#ifdef CONFIG_SYSFS
97 .sysfs_ops = &brport_sysfs_ops,
98#endif
99 .release = release_nbp,
100};
101
102static 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
113static 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
121
122
123
124
125
126
127
128
129static 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, p->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 nbp_vlan_flush(p);
145 br_fdb_delete_by_port(br, p, 1);
146
147 list_del_rcu(&p->list);
148
149 dev->priv_flags &= ~IFF_BRIDGE_PORT;
150
151 netdev_rx_handler_unregister(dev);
152
153 netdev_upper_dev_unlink(dev, br->dev);
154
155 br_multicast_del_port(p);
156
157 kobject_uevent(&p->kobj, KOBJ_REMOVE);
158 kobject_del(&p->kobj);
159
160 br_netpoll_disable(p);
161
162 call_rcu(&p->rcu, destroy_nbp_rcu);
163}
164
165
166void br_dev_delete(struct net_device *dev, struct list_head *head)
167{
168 struct net_bridge *br = netdev_priv(dev);
169 struct net_bridge_port *p, *n;
170
171 list_for_each_entry_safe(p, n, &br->port_list, list) {
172 del_nbp(p);
173 }
174
175 del_timer_sync(&br->gc_timer);
176
177 br_sysfs_delbr(br->dev);
178 unregister_netdevice_queue(br->dev, head);
179}
180
181
182static int find_portno(struct net_bridge *br)
183{
184 int index;
185 struct net_bridge_port *p;
186 unsigned long *inuse;
187
188 inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
189 GFP_KERNEL);
190 if (!inuse)
191 return -ENOMEM;
192
193 set_bit(0, inuse);
194 list_for_each_entry(p, &br->port_list, list) {
195 set_bit(p->port_no, inuse);
196 }
197 index = find_first_zero_bit(inuse, BR_MAX_PORTS);
198 kfree(inuse);
199
200 return (index >= BR_MAX_PORTS) ? -EXFULL : index;
201}
202
203
204static struct net_bridge_port *new_nbp(struct net_bridge *br,
205 struct net_device *dev)
206{
207 int index;
208 struct net_bridge_port *p;
209
210 index = find_portno(br);
211 if (index < 0)
212 return ERR_PTR(index);
213
214 p = kzalloc(sizeof(*p), GFP_KERNEL);
215 if (p == NULL)
216 return ERR_PTR(-ENOMEM);
217
218 p->br = br;
219 dev_hold(dev);
220 p->dev = dev;
221 p->path_cost = port_cost(dev);
222 p->priority = 0x8000 >> BR_PORT_BITS;
223 p->port_no = index;
224 p->flags = 0;
225 br_init_port(p);
226 p->state = BR_STATE_DISABLED;
227 br_stp_port_timer_init(p);
228 br_multicast_add_port(p);
229
230 return p;
231}
232
233int br_add_bridge(struct net *net, const char *name)
234{
235 struct net_device *dev;
236 int res;
237
238 dev = alloc_netdev(sizeof(struct net_bridge), name,
239 br_dev_setup);
240
241 if (!dev)
242 return -ENOMEM;
243
244 dev_net_set(dev, net);
245 dev->rtnl_link_ops = &br_link_ops;
246
247 res = register_netdev(dev);
248 if (res)
249 free_netdev(dev);
250 return res;
251}
252
253int br_del_bridge(struct net *net, const char *name)
254{
255 struct net_device *dev;
256 int ret = 0;
257
258 rtnl_lock();
259 dev = __dev_get_by_name(net, name);
260 if (dev == NULL)
261 ret = -ENXIO;
262
263 else if (!(dev->priv_flags & IFF_EBRIDGE)) {
264
265 ret = -EPERM;
266 }
267
268 else if (dev->flags & IFF_UP) {
269
270 ret = -EBUSY;
271 }
272
273 else
274 br_dev_delete(dev, NULL);
275
276 rtnl_unlock();
277 return ret;
278}
279
280
281int br_min_mtu(const struct net_bridge *br)
282{
283 const struct net_bridge_port *p;
284 int mtu = 0;
285
286 ASSERT_RTNL();
287
288 if (list_empty(&br->port_list))
289 mtu = ETH_DATA_LEN;
290 else {
291 list_for_each_entry(p, &br->port_list, list) {
292 if (!mtu || p->dev->mtu < mtu)
293 mtu = p->dev->mtu;
294 }
295 }
296 return mtu;
297}
298
299
300
301
302netdev_features_t br_features_recompute(struct net_bridge *br,
303 netdev_features_t features)
304{
305 struct net_bridge_port *p;
306 netdev_features_t mask;
307
308 if (list_empty(&br->port_list))
309 return features;
310
311 mask = features;
312 features &= ~NETIF_F_ONE_FOR_ALL;
313
314 list_for_each_entry(p, &br->port_list, list) {
315 features = netdev_increment_features(features,
316 p->dev->features, mask);
317 }
318
319 return features;
320}
321
322
323int br_add_if(struct net_bridge *br, struct net_device *dev)
324{
325 struct net_bridge_port *p;
326 int err = 0;
327 bool changed_addr;
328
329
330 if ((dev->flags & IFF_LOOPBACK) ||
331 dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
332 !is_valid_ether_addr(dev->dev_addr))
333 return -EINVAL;
334
335
336 if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
337 return -ELOOP;
338
339
340 if (br_port_exists(dev))
341 return -EBUSY;
342
343
344 if (dev->priv_flags & IFF_DONT_BRIDGE)
345 return -EOPNOTSUPP;
346
347 p = new_nbp(br, dev);
348 if (IS_ERR(p))
349 return PTR_ERR(p);
350
351 call_netdevice_notifiers(NETDEV_JOIN, dev);
352
353 err = dev_set_promiscuity(dev, 1);
354 if (err)
355 goto put_back;
356
357 err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
358 SYSFS_BRIDGE_PORT_ATTR);
359 if (err)
360 goto err1;
361
362 err = br_sysfs_addif(p);
363 if (err)
364 goto err2;
365
366 if (br_netpoll_info(br) && ((err = br_netpoll_enable(p, GFP_KERNEL))))
367 goto err3;
368
369 err = netdev_master_upper_dev_link(dev, br->dev);
370 if (err)
371 goto err4;
372
373 err = netdev_rx_handler_register(dev, br_handle_frame, p);
374 if (err)
375 goto err5;
376
377 dev->priv_flags |= IFF_BRIDGE_PORT;
378
379 dev_disable_lro(dev);
380
381 list_add_rcu(&p->list, &br->port_list);
382
383 netdev_update_features(br->dev);
384
385 spin_lock_bh(&br->lock);
386 changed_addr = br_stp_recalculate_bridge_id(br);
387
388 if (netif_running(dev) && netif_oper_up(dev) &&
389 (br->dev->flags & IFF_UP))
390 br_stp_enable_port(p);
391 spin_unlock_bh(&br->lock);
392
393 br_ifinfo_notify(RTM_NEWLINK, p);
394
395 if (changed_addr)
396 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
397
398 dev_set_mtu(br->dev, br_min_mtu(br));
399
400 if (br_fdb_insert(br, p, dev->dev_addr, 0))
401 netdev_err(dev, "failed insert local address bridge forwarding table\n");
402
403 kobject_uevent(&p->kobj, KOBJ_ADD);
404
405 return 0;
406
407err5:
408 netdev_upper_dev_unlink(dev, br->dev);
409err4:
410 br_netpoll_disable(p);
411err3:
412 sysfs_remove_link(br->ifobj, p->dev->name);
413err2:
414 kobject_put(&p->kobj);
415 p = NULL;
416err1:
417 dev_set_promiscuity(dev, -1);
418put_back:
419 dev_put(dev);
420 kfree(p);
421 return err;
422}
423
424
425int br_del_if(struct net_bridge *br, struct net_device *dev)
426{
427 struct net_bridge_port *p;
428 bool changed_addr;
429
430 p = br_port_get_rtnl(dev);
431 if (!p || p->br != br)
432 return -EINVAL;
433
434
435
436
437
438 del_nbp(p);
439
440 spin_lock_bh(&br->lock);
441 changed_addr = br_stp_recalculate_bridge_id(br);
442 spin_unlock_bh(&br->lock);
443
444 if (changed_addr)
445 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
446
447 netdev_update_features(br->dev);
448
449 return 0;
450}
451
452void __net_exit br_net_exit(struct net *net)
453{
454 struct net_device *dev;
455 LIST_HEAD(list);
456
457 rtnl_lock();
458 for_each_netdev(net, dev)
459 if (dev->priv_flags & IFF_EBRIDGE)
460 br_dev_delete(dev, &list);
461
462 unregister_netdevice_many(&list);
463 rtnl_unlock();
464
465}
466