br_if.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. /*
  2. * Userspace interface
  3. * Linux ethernet bridge
  4. *
  5. * Authors:
  6. * Lennert Buytenhek <buytenh@gnu.org>
  7. *
  8. * $Id: br_if.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  9. *
  10. * This program is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU General Public License
  12. * as published by the Free Software Foundation; either version
  13. * 2 of the License, or (at your option) any later version.
  14. */
  15. #include <linux/kernel.h>
  16. #include <linux/netdevice.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 <net/sock.h>
  24. #include "br_private.h"
  25. /*
  26. * Determine initial path cost based on speed.
  27. * using recommendations from 802.1d standard
  28. *
  29. * Need to simulate user ioctl because not all device's that support
  30. * ethtool, use ethtool_ops. Also, since driver might sleep need to
  31. * not be holding any locks.
  32. */
  33. static int port_cost(struct net_device *dev)
  34. {
  35. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  36. struct ifreq ifr;
  37. mm_segment_t old_fs;
  38. int err;
  39. strncpy(ifr.ifr_name, dev->name, IFNAMSIZ);
  40. ifr.ifr_data = (void __user *) &ecmd;
  41. old_fs = get_fs();
  42. set_fs(KERNEL_DS);
  43. err = dev_ethtool(&ifr);
  44. set_fs(old_fs);
  45. if (!err) {
  46. switch(ecmd.speed) {
  47. case SPEED_100:
  48. return 19;
  49. case SPEED_1000:
  50. return 4;
  51. case SPEED_10000:
  52. return 2;
  53. case SPEED_10:
  54. return 100;
  55. }
  56. }
  57. /* Old silly heuristics based on name */
  58. if (!strncmp(dev->name, "lec", 3))
  59. return 7;
  60. if (!strncmp(dev->name, "plip", 4))
  61. return 2500;
  62. return 100; /* assume old 10Mbps */
  63. }
  64. /*
  65. * Check for port carrier transistions.
  66. * Called from work queue to allow for calling functions that
  67. * might sleep (such as speed check), and to debounce.
  68. */
  69. void br_port_carrier_check(struct net_bridge_port *p)
  70. {
  71. struct net_device *dev = p->dev;
  72. struct net_bridge *br = p->br;
  73. if (netif_carrier_ok(dev))
  74. p->path_cost = port_cost(dev);
  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. static 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. static struct kobj_type brport_ktype = {
  94. #ifdef CONFIG_SYSFS
  95. .sysfs_ops = &brport_sysfs_ops,
  96. #endif
  97. .release = release_nbp,
  98. };
  99. static void destroy_nbp(struct net_bridge_port *p)
  100. {
  101. struct net_device *dev = p->dev;
  102. p->br = NULL;
  103. p->dev = NULL;
  104. dev_put(dev);
  105. kobject_put(&p->kobj);
  106. }
  107. static void destroy_nbp_rcu(struct rcu_head *head)
  108. {
  109. struct net_bridge_port *p =
  110. container_of(head, struct net_bridge_port, rcu);
  111. destroy_nbp(p);
  112. }
  113. /* Delete port(interface) from bridge is done in two steps.
  114. * via RCU. First step, marks device as down. That deletes
  115. * all the timers and stops new packets from flowing through.
  116. *
  117. * Final cleanup doesn't occur until after all CPU's finished
  118. * processing packets.
  119. *
  120. * Protected from multiple admin operations by RTNL mutex
  121. */
  122. static void del_nbp(struct net_bridge_port *p)
  123. {
  124. struct net_bridge *br = p->br;
  125. struct net_device *dev = p->dev;
  126. sysfs_remove_link(&br->ifobj, dev->name);
  127. dev_set_promiscuity(dev, -1);
  128. spin_lock_bh(&br->lock);
  129. br_stp_disable_port(p);
  130. spin_unlock_bh(&br->lock);
  131. br_fdb_delete_by_port(br, p, 1);
  132. list_del_rcu(&p->list);
  133. rcu_assign_pointer(dev->br_port, NULL);
  134. kobject_uevent(&p->kobj, KOBJ_REMOVE);
  135. kobject_del(&p->kobj);
  136. call_rcu(&p->rcu, destroy_nbp_rcu);
  137. }
  138. /* called with RTNL */
  139. static void del_br(struct net_bridge *br)
  140. {
  141. struct net_bridge_port *p, *n;
  142. list_for_each_entry_safe(p, n, &br->port_list, list) {
  143. del_nbp(p);
  144. }
  145. del_timer_sync(&br->gc_timer);
  146. br_sysfs_delbr(br->dev);
  147. unregister_netdevice(br->dev);
  148. }
  149. static struct net_device *new_bridge_dev(const char *name)
  150. {
  151. struct net_bridge *br;
  152. struct net_device *dev;
  153. dev = alloc_netdev(sizeof(struct net_bridge), name,
  154. br_dev_setup);
  155. if (!dev)
  156. return NULL;
  157. br = netdev_priv(dev);
  158. br->dev = dev;
  159. spin_lock_init(&br->lock);
  160. INIT_LIST_HEAD(&br->port_list);
  161. spin_lock_init(&br->hash_lock);
  162. br->bridge_id.prio[0] = 0x80;
  163. br->bridge_id.prio[1] = 0x00;
  164. memcpy(br->group_addr, br_group_address, ETH_ALEN);
  165. br->feature_mask = dev->features;
  166. br->stp_enabled = 0;
  167. br->designated_root = br->bridge_id;
  168. br->root_path_cost = 0;
  169. br->root_port = 0;
  170. br->bridge_max_age = br->max_age = 20 * HZ;
  171. br->bridge_hello_time = br->hello_time = 2 * HZ;
  172. br->bridge_forward_delay = br->forward_delay = 15 * HZ;
  173. br->topology_change = 0;
  174. br->topology_change_detected = 0;
  175. br->ageing_time = 300 * HZ;
  176. INIT_LIST_HEAD(&br->age_list);
  177. br_stp_timer_init(br);
  178. return dev;
  179. }
  180. /* find an available port number */
  181. static int find_portno(struct net_bridge *br)
  182. {
  183. int index;
  184. struct net_bridge_port *p;
  185. unsigned long *inuse;
  186. inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
  187. GFP_KERNEL);
  188. if (!inuse)
  189. return -ENOMEM;
  190. set_bit(0, inuse); /* zero is reserved */
  191. list_for_each_entry(p, &br->port_list, list) {
  192. set_bit(p->port_no, inuse);
  193. }
  194. index = find_first_zero_bit(inuse, BR_MAX_PORTS);
  195. kfree(inuse);
  196. return (index >= BR_MAX_PORTS) ? -EXFULL : index;
  197. }
  198. /* called with RTNL but without bridge lock */
  199. static struct net_bridge_port *new_nbp(struct net_bridge *br,
  200. struct net_device *dev)
  201. {
  202. int index;
  203. struct net_bridge_port *p;
  204. index = find_portno(br);
  205. if (index < 0)
  206. return ERR_PTR(index);
  207. p = kzalloc(sizeof(*p), GFP_KERNEL);
  208. if (p == NULL)
  209. return ERR_PTR(-ENOMEM);
  210. p->br = br;
  211. dev_hold(dev);
  212. p->dev = dev;
  213. p->path_cost = port_cost(dev);
  214. p->priority = 0x8000 >> BR_PORT_BITS;
  215. p->port_no = index;
  216. br_init_port(p);
  217. p->state = BR_STATE_DISABLED;
  218. br_stp_port_timer_init(p);
  219. kobject_init(&p->kobj);
  220. kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR);
  221. p->kobj.ktype = &brport_ktype;
  222. p->kobj.parent = &(dev->dev.kobj);
  223. p->kobj.kset = NULL;
  224. return p;
  225. }
  226. int br_add_bridge(const char *name)
  227. {
  228. struct net_device *dev;
  229. int ret;
  230. dev = new_bridge_dev(name);
  231. if (!dev)
  232. return -ENOMEM;
  233. rtnl_lock();
  234. if (strchr(dev->name, '%')) {
  235. ret = dev_alloc_name(dev, dev->name);
  236. if (ret < 0) {
  237. free_netdev(dev);
  238. goto out;
  239. }
  240. }
  241. ret = register_netdevice(dev);
  242. if (ret)
  243. goto out;
  244. ret = br_sysfs_addbr(dev);
  245. if (ret)
  246. unregister_netdevice(dev);
  247. out:
  248. rtnl_unlock();
  249. return ret;
  250. }
  251. int br_del_bridge(const char *name)
  252. {
  253. struct net_device *dev;
  254. int ret = 0;
  255. rtnl_lock();
  256. dev = __dev_get_by_name(name);
  257. if (dev == NULL)
  258. ret = -ENXIO; /* Could not find device */
  259. else if (!(dev->priv_flags & IFF_EBRIDGE)) {
  260. /* Attempt to delete non bridge device! */
  261. ret = -EPERM;
  262. }
  263. else if (dev->flags & IFF_UP) {
  264. /* Not shutdown yet. */
  265. ret = -EBUSY;
  266. }
  267. else
  268. del_br(netdev_priv(dev));
  269. rtnl_unlock();
  270. return ret;
  271. }
  272. /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
  273. int br_min_mtu(const struct net_bridge *br)
  274. {
  275. const struct net_bridge_port *p;
  276. int mtu = 0;
  277. ASSERT_RTNL();
  278. if (list_empty(&br->port_list))
  279. mtu = ETH_DATA_LEN;
  280. else {
  281. list_for_each_entry(p, &br->port_list, list) {
  282. if (!mtu || p->dev->mtu < mtu)
  283. mtu = p->dev->mtu;
  284. }
  285. }
  286. return mtu;
  287. }
  288. /*
  289. * Recomputes features using slave's features
  290. */
  291. void br_features_recompute(struct net_bridge *br)
  292. {
  293. struct net_bridge_port *p;
  294. unsigned long features, checksum;
  295. checksum = br->feature_mask & NETIF_F_ALL_CSUM ? NETIF_F_NO_CSUM : 0;
  296. features = br->feature_mask & ~NETIF_F_ALL_CSUM;
  297. list_for_each_entry(p, &br->port_list, list) {
  298. unsigned long feature = p->dev->features;
  299. if (checksum & NETIF_F_NO_CSUM && !(feature & NETIF_F_NO_CSUM))
  300. checksum ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
  301. if (checksum & NETIF_F_HW_CSUM && !(feature & NETIF_F_HW_CSUM))
  302. checksum ^= NETIF_F_HW_CSUM | NETIF_F_IP_CSUM;
  303. if (!(feature & NETIF_F_IP_CSUM))
  304. checksum = 0;
  305. if (feature & NETIF_F_GSO)
  306. feature |= NETIF_F_GSO_SOFTWARE;
  307. feature |= NETIF_F_GSO;
  308. features &= feature;
  309. }
  310. if (!(checksum & NETIF_F_ALL_CSUM))
  311. features &= ~NETIF_F_SG;
  312. if (!(features & NETIF_F_SG))
  313. features &= ~NETIF_F_GSO_MASK;
  314. br->dev->features = features | checksum | NETIF_F_LLTX |
  315. NETIF_F_GSO_ROBUST;
  316. }
  317. /* called with RTNL */
  318. int br_add_if(struct net_bridge *br, struct net_device *dev)
  319. {
  320. struct net_bridge_port *p;
  321. int err = 0;
  322. if (dev->flags & IFF_LOOPBACK || dev->type != ARPHRD_ETHER)
  323. return -EINVAL;
  324. if (dev->hard_start_xmit == br_dev_xmit)
  325. return -ELOOP;
  326. if (dev->br_port != NULL)
  327. return -EBUSY;
  328. p = new_nbp(br, dev);
  329. if (IS_ERR(p))
  330. return PTR_ERR(p);
  331. err = kobject_add(&p->kobj);
  332. if (err)
  333. goto err0;
  334. err = br_fdb_insert(br, p, dev->dev_addr);
  335. if (err)
  336. goto err1;
  337. err = br_sysfs_addif(p);
  338. if (err)
  339. goto err2;
  340. rcu_assign_pointer(dev->br_port, p);
  341. dev_set_promiscuity(dev, 1);
  342. list_add_rcu(&p->list, &br->port_list);
  343. spin_lock_bh(&br->lock);
  344. br_stp_recalculate_bridge_id(br);
  345. br_features_recompute(br);
  346. if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
  347. (br->dev->flags & IFF_UP))
  348. br_stp_enable_port(p);
  349. spin_unlock_bh(&br->lock);
  350. dev_set_mtu(br->dev, br_min_mtu(br));
  351. kobject_uevent(&p->kobj, KOBJ_ADD);
  352. return 0;
  353. err2:
  354. br_fdb_delete_by_port(br, p, 1);
  355. err1:
  356. kobject_del(&p->kobj);
  357. err0:
  358. kobject_put(&p->kobj);
  359. return err;
  360. }
  361. /* called with RTNL */
  362. int br_del_if(struct net_bridge *br, struct net_device *dev)
  363. {
  364. struct net_bridge_port *p = dev->br_port;
  365. if (!p || p->br != br)
  366. return -EINVAL;
  367. del_nbp(p);
  368. spin_lock_bh(&br->lock);
  369. br_stp_recalculate_bridge_id(br);
  370. br_features_recompute(br);
  371. spin_unlock_bh(&br->lock);
  372. return 0;
  373. }
  374. void __exit br_cleanup_bridges(void)
  375. {
  376. struct net_device *dev, *nxt;
  377. rtnl_lock();
  378. for (dev = dev_base; dev; dev = nxt) {
  379. nxt = dev->next;
  380. if (dev->priv_flags & IFF_EBRIDGE)
  381. del_br(dev->priv);
  382. }
  383. rtnl_unlock();
  384. }