br_mdb.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <linux/err.h>
  3. #include <linux/igmp.h>
  4. #include <linux/kernel.h>
  5. #include <linux/netdevice.h>
  6. #include <linux/rculist.h>
  7. #include <linux/skbuff.h>
  8. #include <linux/if_ether.h>
  9. #include <net/ip.h>
  10. #include <net/netlink.h>
  11. #include <net/switchdev.h>
  12. #if IS_ENABLED(CONFIG_IPV6)
  13. #include <net/ipv6.h>
  14. #include <net/addrconf.h>
  15. #endif
  16. #include "br_private.h"
  17. static int br_rports_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
  18. struct net_device *dev)
  19. {
  20. struct net_bridge *br = netdev_priv(dev);
  21. struct net_bridge_port *p;
  22. struct nlattr *nest, *port_nest;
  23. if (!br->multicast_router || hlist_empty(&br->router_list))
  24. return 0;
  25. nest = nla_nest_start(skb, MDBA_ROUTER);
  26. if (nest == NULL)
  27. return -EMSGSIZE;
  28. hlist_for_each_entry_rcu(p, &br->router_list, rlist) {
  29. if (!p)
  30. continue;
  31. port_nest = nla_nest_start(skb, MDBA_ROUTER_PORT);
  32. if (!port_nest)
  33. goto fail;
  34. if (nla_put_nohdr(skb, sizeof(u32), &p->dev->ifindex) ||
  35. nla_put_u32(skb, MDBA_ROUTER_PATTR_TIMER,
  36. br_timer_value(&p->multicast_router_timer)) ||
  37. nla_put_u8(skb, MDBA_ROUTER_PATTR_TYPE,
  38. p->multicast_router)) {
  39. nla_nest_cancel(skb, port_nest);
  40. goto fail;
  41. }
  42. nla_nest_end(skb, port_nest);
  43. }
  44. nla_nest_end(skb, nest);
  45. return 0;
  46. fail:
  47. nla_nest_cancel(skb, nest);
  48. return -EMSGSIZE;
  49. }
  50. static void __mdb_entry_fill_flags(struct br_mdb_entry *e, unsigned char flags)
  51. {
  52. e->state = flags & MDB_PG_FLAGS_PERMANENT;
  53. e->flags = 0;
  54. if (flags & MDB_PG_FLAGS_OFFLOAD)
  55. e->flags |= MDB_FLAGS_OFFLOAD;
  56. }
  57. static void __mdb_entry_to_br_ip(struct br_mdb_entry *entry, struct br_ip *ip)
  58. {
  59. memset(ip, 0, sizeof(struct br_ip));
  60. ip->vid = entry->vid;
  61. ip->proto = entry->addr.proto;
  62. if (ip->proto == htons(ETH_P_IP))
  63. ip->u.ip4 = entry->addr.u.ip4;
  64. #if IS_ENABLED(CONFIG_IPV6)
  65. else
  66. ip->u.ip6 = entry->addr.u.ip6;
  67. #endif
  68. }
  69. static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
  70. struct net_device *dev)
  71. {
  72. struct net_bridge *br = netdev_priv(dev);
  73. struct net_bridge_mdb_htable *mdb;
  74. struct nlattr *nest, *nest2;
  75. int i, err = 0;
  76. int idx = 0, s_idx = cb->args[1];
  77. if (br->multicast_disabled)
  78. return 0;
  79. mdb = rcu_dereference(br->mdb);
  80. if (!mdb)
  81. return 0;
  82. nest = nla_nest_start(skb, MDBA_MDB);
  83. if (nest == NULL)
  84. return -EMSGSIZE;
  85. for (i = 0; i < mdb->max; i++) {
  86. struct net_bridge_mdb_entry *mp;
  87. struct net_bridge_port_group *p;
  88. struct net_bridge_port_group __rcu **pp;
  89. struct net_bridge_port *port;
  90. hlist_for_each_entry_rcu(mp, &mdb->mhash[i], hlist[mdb->ver]) {
  91. if (idx < s_idx)
  92. goto skip;
  93. nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY);
  94. if (nest2 == NULL) {
  95. err = -EMSGSIZE;
  96. goto out;
  97. }
  98. for (pp = &mp->ports;
  99. (p = rcu_dereference(*pp)) != NULL;
  100. pp = &p->next) {
  101. struct nlattr *nest_ent;
  102. struct br_mdb_entry e;
  103. port = p->port;
  104. if (!port)
  105. continue;
  106. memset(&e, 0, sizeof(e));
  107. e.ifindex = port->dev->ifindex;
  108. e.vid = p->addr.vid;
  109. __mdb_entry_fill_flags(&e, p->flags);
  110. if (p->addr.proto == htons(ETH_P_IP))
  111. e.addr.u.ip4 = p->addr.u.ip4;
  112. #if IS_ENABLED(CONFIG_IPV6)
  113. if (p->addr.proto == htons(ETH_P_IPV6))
  114. e.addr.u.ip6 = p->addr.u.ip6;
  115. #endif
  116. e.addr.proto = p->addr.proto;
  117. nest_ent = nla_nest_start(skb,
  118. MDBA_MDB_ENTRY_INFO);
  119. if (!nest_ent) {
  120. nla_nest_cancel(skb, nest2);
  121. err = -EMSGSIZE;
  122. goto out;
  123. }
  124. if (nla_put_nohdr(skb, sizeof(e), &e) ||
  125. nla_put_u32(skb,
  126. MDBA_MDB_EATTR_TIMER,
  127. br_timer_value(&p->timer))) {
  128. nla_nest_cancel(skb, nest_ent);
  129. nla_nest_cancel(skb, nest2);
  130. err = -EMSGSIZE;
  131. goto out;
  132. }
  133. nla_nest_end(skb, nest_ent);
  134. }
  135. nla_nest_end(skb, nest2);
  136. skip:
  137. idx++;
  138. }
  139. }
  140. out:
  141. cb->args[1] = idx;
  142. nla_nest_end(skb, nest);
  143. return err;
  144. }
  145. static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
  146. {
  147. struct net_device *dev;
  148. struct net *net = sock_net(skb->sk);
  149. struct nlmsghdr *nlh = NULL;
  150. int idx = 0, s_idx;
  151. s_idx = cb->args[0];
  152. rcu_read_lock();
  153. /* In theory this could be wrapped to 0... */
  154. cb->seq = net->dev_base_seq + br_mdb_rehash_seq;
  155. for_each_netdev_rcu(net, dev) {
  156. if (dev->priv_flags & IFF_EBRIDGE) {
  157. struct br_port_msg *bpm;
  158. if (idx < s_idx)
  159. goto skip;
  160. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
  161. cb->nlh->nlmsg_seq, RTM_GETMDB,
  162. sizeof(*bpm), NLM_F_MULTI);
  163. if (nlh == NULL)
  164. break;
  165. bpm = nlmsg_data(nlh);
  166. memset(bpm, 0, sizeof(*bpm));
  167. bpm->ifindex = dev->ifindex;
  168. if (br_mdb_fill_info(skb, cb, dev) < 0)
  169. goto out;
  170. if (br_rports_fill_info(skb, cb, dev) < 0)
  171. goto out;
  172. cb->args[1] = 0;
  173. nlmsg_end(skb, nlh);
  174. skip:
  175. idx++;
  176. }
  177. }
  178. out:
  179. if (nlh)
  180. nlmsg_end(skb, nlh);
  181. rcu_read_unlock();
  182. cb->args[0] = idx;
  183. return skb->len;
  184. }
  185. static int nlmsg_populate_mdb_fill(struct sk_buff *skb,
  186. struct net_device *dev,
  187. struct br_mdb_entry *entry, u32 pid,
  188. u32 seq, int type, unsigned int flags)
  189. {
  190. struct nlmsghdr *nlh;
  191. struct br_port_msg *bpm;
  192. struct nlattr *nest, *nest2;
  193. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0);
  194. if (!nlh)
  195. return -EMSGSIZE;
  196. bpm = nlmsg_data(nlh);
  197. memset(bpm, 0, sizeof(*bpm));
  198. bpm->family = AF_BRIDGE;
  199. bpm->ifindex = dev->ifindex;
  200. nest = nla_nest_start(skb, MDBA_MDB);
  201. if (nest == NULL)
  202. goto cancel;
  203. nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY);
  204. if (nest2 == NULL)
  205. goto end;
  206. if (nla_put(skb, MDBA_MDB_ENTRY_INFO, sizeof(*entry), entry))
  207. goto end;
  208. nla_nest_end(skb, nest2);
  209. nla_nest_end(skb, nest);
  210. nlmsg_end(skb, nlh);
  211. return 0;
  212. end:
  213. nla_nest_end(skb, nest);
  214. cancel:
  215. nlmsg_cancel(skb, nlh);
  216. return -EMSGSIZE;
  217. }
  218. static inline size_t rtnl_mdb_nlmsg_size(void)
  219. {
  220. return NLMSG_ALIGN(sizeof(struct br_port_msg))
  221. + nla_total_size(sizeof(struct br_mdb_entry));
  222. }
  223. struct br_mdb_complete_info {
  224. struct net_bridge_port *port;
  225. struct br_ip ip;
  226. };
  227. static void br_mdb_complete(struct net_device *dev, int err, void *priv)
  228. {
  229. struct br_mdb_complete_info *data = priv;
  230. struct net_bridge_port_group __rcu **pp;
  231. struct net_bridge_port_group *p;
  232. struct net_bridge_mdb_htable *mdb;
  233. struct net_bridge_mdb_entry *mp;
  234. struct net_bridge_port *port = data->port;
  235. struct net_bridge *br = port->br;
  236. if (err)
  237. goto err;
  238. spin_lock_bh(&br->multicast_lock);
  239. mdb = mlock_dereference(br->mdb, br);
  240. mp = br_mdb_ip_get(mdb, &data->ip);
  241. if (!mp)
  242. goto out;
  243. for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
  244. pp = &p->next) {
  245. if (p->port != port)
  246. continue;
  247. p->flags |= MDB_PG_FLAGS_OFFLOAD;
  248. }
  249. out:
  250. spin_unlock_bh(&br->multicast_lock);
  251. err:
  252. kfree(priv);
  253. }
  254. static void __br_mdb_notify(struct net_device *dev, struct net_bridge_port *p,
  255. struct br_mdb_entry *entry, int type)
  256. {
  257. struct br_mdb_complete_info *complete_info;
  258. struct switchdev_obj_port_mdb mdb = {
  259. .obj = {
  260. .id = SWITCHDEV_OBJ_ID_PORT_MDB,
  261. .flags = SWITCHDEV_F_DEFER,
  262. },
  263. .vid = entry->vid,
  264. };
  265. struct net_device *port_dev;
  266. struct net *net = dev_net(dev);
  267. struct sk_buff *skb;
  268. int err = -ENOBUFS;
  269. port_dev = __dev_get_by_index(net, entry->ifindex);
  270. if (entry->addr.proto == htons(ETH_P_IP))
  271. ip_eth_mc_map(entry->addr.u.ip4, mdb.addr);
  272. #if IS_ENABLED(CONFIG_IPV6)
  273. else
  274. ipv6_eth_mc_map(&entry->addr.u.ip6, mdb.addr);
  275. #endif
  276. mdb.obj.orig_dev = port_dev;
  277. if (port_dev && type == RTM_NEWMDB) {
  278. complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
  279. if (complete_info) {
  280. complete_info->port = p;
  281. __mdb_entry_to_br_ip(entry, &complete_info->ip);
  282. mdb.obj.complete_priv = complete_info;
  283. mdb.obj.complete = br_mdb_complete;
  284. if (switchdev_port_obj_add(port_dev, &mdb.obj))
  285. kfree(complete_info);
  286. }
  287. } else if (port_dev && type == RTM_DELMDB) {
  288. switchdev_port_obj_del(port_dev, &mdb.obj);
  289. }
  290. skb = nlmsg_new(rtnl_mdb_nlmsg_size(), GFP_ATOMIC);
  291. if (!skb)
  292. goto errout;
  293. err = nlmsg_populate_mdb_fill(skb, dev, entry, 0, 0, type, NTF_SELF);
  294. if (err < 0) {
  295. kfree_skb(skb);
  296. goto errout;
  297. }
  298. rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
  299. return;
  300. errout:
  301. rtnl_set_sk_err(net, RTNLGRP_MDB, err);
  302. }
  303. void br_mdb_notify(struct net_device *dev, struct net_bridge_port *port,
  304. struct br_ip *group, int type, u8 flags)
  305. {
  306. struct br_mdb_entry entry;
  307. memset(&entry, 0, sizeof(entry));
  308. entry.ifindex = port->dev->ifindex;
  309. entry.addr.proto = group->proto;
  310. entry.addr.u.ip4 = group->u.ip4;
  311. #if IS_ENABLED(CONFIG_IPV6)
  312. entry.addr.u.ip6 = group->u.ip6;
  313. #endif
  314. entry.vid = group->vid;
  315. __mdb_entry_fill_flags(&entry, flags);
  316. __br_mdb_notify(dev, port, &entry, type);
  317. }
  318. static int nlmsg_populate_rtr_fill(struct sk_buff *skb,
  319. struct net_device *dev,
  320. int ifindex, u32 pid,
  321. u32 seq, int type, unsigned int flags)
  322. {
  323. struct br_port_msg *bpm;
  324. struct nlmsghdr *nlh;
  325. struct nlattr *nest;
  326. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), NLM_F_MULTI);
  327. if (!nlh)
  328. return -EMSGSIZE;
  329. bpm = nlmsg_data(nlh);
  330. memset(bpm, 0, sizeof(*bpm));
  331. bpm->family = AF_BRIDGE;
  332. bpm->ifindex = dev->ifindex;
  333. nest = nla_nest_start(skb, MDBA_ROUTER);
  334. if (!nest)
  335. goto cancel;
  336. if (nla_put_u32(skb, MDBA_ROUTER_PORT, ifindex))
  337. goto end;
  338. nla_nest_end(skb, nest);
  339. nlmsg_end(skb, nlh);
  340. return 0;
  341. end:
  342. nla_nest_end(skb, nest);
  343. cancel:
  344. nlmsg_cancel(skb, nlh);
  345. return -EMSGSIZE;
  346. }
  347. static inline size_t rtnl_rtr_nlmsg_size(void)
  348. {
  349. return NLMSG_ALIGN(sizeof(struct br_port_msg))
  350. + nla_total_size(sizeof(__u32));
  351. }
  352. void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port,
  353. int type)
  354. {
  355. struct net *net = dev_net(dev);
  356. struct sk_buff *skb;
  357. int err = -ENOBUFS;
  358. int ifindex;
  359. ifindex = port ? port->dev->ifindex : 0;
  360. skb = nlmsg_new(rtnl_rtr_nlmsg_size(), GFP_ATOMIC);
  361. if (!skb)
  362. goto errout;
  363. err = nlmsg_populate_rtr_fill(skb, dev, ifindex, 0, 0, type, NTF_SELF);
  364. if (err < 0) {
  365. kfree_skb(skb);
  366. goto errout;
  367. }
  368. rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
  369. return;
  370. errout:
  371. rtnl_set_sk_err(net, RTNLGRP_MDB, err);
  372. }
  373. static bool is_valid_mdb_entry(struct br_mdb_entry *entry)
  374. {
  375. if (entry->ifindex == 0)
  376. return false;
  377. if (entry->addr.proto == htons(ETH_P_IP)) {
  378. if (!ipv4_is_multicast(entry->addr.u.ip4))
  379. return false;
  380. if (ipv4_is_local_multicast(entry->addr.u.ip4))
  381. return false;
  382. #if IS_ENABLED(CONFIG_IPV6)
  383. } else if (entry->addr.proto == htons(ETH_P_IPV6)) {
  384. if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6))
  385. return false;
  386. #endif
  387. } else
  388. return false;
  389. if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY)
  390. return false;
  391. if (entry->vid >= VLAN_VID_MASK)
  392. return false;
  393. return true;
  394. }
  395. static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh,
  396. struct net_device **pdev, struct br_mdb_entry **pentry)
  397. {
  398. struct net *net = sock_net(skb->sk);
  399. struct br_mdb_entry *entry;
  400. struct br_port_msg *bpm;
  401. struct nlattr *tb[MDBA_SET_ENTRY_MAX+1];
  402. struct net_device *dev;
  403. int err;
  404. err = nlmsg_parse(nlh, sizeof(*bpm), tb, MDBA_SET_ENTRY_MAX, NULL,
  405. NULL);
  406. if (err < 0)
  407. return err;
  408. bpm = nlmsg_data(nlh);
  409. if (bpm->ifindex == 0) {
  410. pr_info("PF_BRIDGE: br_mdb_parse() with invalid ifindex\n");
  411. return -EINVAL;
  412. }
  413. dev = __dev_get_by_index(net, bpm->ifindex);
  414. if (dev == NULL) {
  415. pr_info("PF_BRIDGE: br_mdb_parse() with unknown ifindex\n");
  416. return -ENODEV;
  417. }
  418. if (!(dev->priv_flags & IFF_EBRIDGE)) {
  419. pr_info("PF_BRIDGE: br_mdb_parse() with non-bridge\n");
  420. return -EOPNOTSUPP;
  421. }
  422. *pdev = dev;
  423. if (!tb[MDBA_SET_ENTRY] ||
  424. nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) {
  425. pr_info("PF_BRIDGE: br_mdb_parse() with invalid attr\n");
  426. return -EINVAL;
  427. }
  428. entry = nla_data(tb[MDBA_SET_ENTRY]);
  429. if (!is_valid_mdb_entry(entry)) {
  430. pr_info("PF_BRIDGE: br_mdb_parse() with invalid entry\n");
  431. return -EINVAL;
  432. }
  433. *pentry = entry;
  434. return 0;
  435. }
  436. static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port,
  437. struct br_ip *group, unsigned char state)
  438. {
  439. struct net_bridge_mdb_entry *mp;
  440. struct net_bridge_port_group *p;
  441. struct net_bridge_port_group __rcu **pp;
  442. struct net_bridge_mdb_htable *mdb;
  443. unsigned long now = jiffies;
  444. int err;
  445. mdb = mlock_dereference(br->mdb, br);
  446. mp = br_mdb_ip_get(mdb, group);
  447. if (!mp) {
  448. mp = br_multicast_new_group(br, port, group);
  449. err = PTR_ERR_OR_ZERO(mp);
  450. if (err)
  451. return err;
  452. }
  453. for (pp = &mp->ports;
  454. (p = mlock_dereference(*pp, br)) != NULL;
  455. pp = &p->next) {
  456. if (p->port == port)
  457. return -EEXIST;
  458. if ((unsigned long)p->port < (unsigned long)port)
  459. break;
  460. }
  461. p = br_multicast_new_port_group(port, group, *pp, state, NULL);
  462. if (unlikely(!p))
  463. return -ENOMEM;
  464. rcu_assign_pointer(*pp, p);
  465. if (state == MDB_TEMPORARY)
  466. mod_timer(&p->timer, now + br->multicast_membership_interval);
  467. return 0;
  468. }
  469. static int __br_mdb_add(struct net *net, struct net_bridge *br,
  470. struct br_mdb_entry *entry)
  471. {
  472. struct br_ip ip;
  473. struct net_device *dev;
  474. struct net_bridge_port *p;
  475. int ret;
  476. if (!netif_running(br->dev) || br->multicast_disabled)
  477. return -EINVAL;
  478. dev = __dev_get_by_index(net, entry->ifindex);
  479. if (!dev)
  480. return -ENODEV;
  481. p = br_port_get_rtnl(dev);
  482. if (!p || p->br != br || p->state == BR_STATE_DISABLED)
  483. return -EINVAL;
  484. __mdb_entry_to_br_ip(entry, &ip);
  485. spin_lock_bh(&br->multicast_lock);
  486. ret = br_mdb_add_group(br, p, &ip, entry->state);
  487. spin_unlock_bh(&br->multicast_lock);
  488. return ret;
  489. }
  490. static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
  491. struct netlink_ext_ack *extack)
  492. {
  493. struct net *net = sock_net(skb->sk);
  494. struct net_bridge_vlan_group *vg;
  495. struct net_device *dev, *pdev;
  496. struct br_mdb_entry *entry;
  497. struct net_bridge_port *p;
  498. struct net_bridge_vlan *v;
  499. struct net_bridge *br;
  500. int err;
  501. err = br_mdb_parse(skb, nlh, &dev, &entry);
  502. if (err < 0)
  503. return err;
  504. br = netdev_priv(dev);
  505. /* If vlan filtering is enabled and VLAN is not specified
  506. * install mdb entry on all vlans configured on the port.
  507. */
  508. pdev = __dev_get_by_index(net, entry->ifindex);
  509. if (!pdev)
  510. return -ENODEV;
  511. p = br_port_get_rtnl(pdev);
  512. if (!p || p->br != br || p->state == BR_STATE_DISABLED)
  513. return -EINVAL;
  514. vg = nbp_vlan_group(p);
  515. if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
  516. list_for_each_entry(v, &vg->vlan_list, vlist) {
  517. entry->vid = v->vid;
  518. err = __br_mdb_add(net, br, entry);
  519. if (err)
  520. break;
  521. __br_mdb_notify(dev, p, entry, RTM_NEWMDB);
  522. }
  523. } else {
  524. err = __br_mdb_add(net, br, entry);
  525. if (!err)
  526. __br_mdb_notify(dev, p, entry, RTM_NEWMDB);
  527. }
  528. return err;
  529. }
  530. static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry)
  531. {
  532. struct net_bridge_mdb_htable *mdb;
  533. struct net_bridge_mdb_entry *mp;
  534. struct net_bridge_port_group *p;
  535. struct net_bridge_port_group __rcu **pp;
  536. struct br_ip ip;
  537. int err = -EINVAL;
  538. if (!netif_running(br->dev) || br->multicast_disabled)
  539. return -EINVAL;
  540. __mdb_entry_to_br_ip(entry, &ip);
  541. spin_lock_bh(&br->multicast_lock);
  542. mdb = mlock_dereference(br->mdb, br);
  543. mp = br_mdb_ip_get(mdb, &ip);
  544. if (!mp)
  545. goto unlock;
  546. for (pp = &mp->ports;
  547. (p = mlock_dereference(*pp, br)) != NULL;
  548. pp = &p->next) {
  549. if (!p->port || p->port->dev->ifindex != entry->ifindex)
  550. continue;
  551. if (p->port->state == BR_STATE_DISABLED)
  552. goto unlock;
  553. __mdb_entry_fill_flags(entry, p->flags);
  554. rcu_assign_pointer(*pp, p->next);
  555. hlist_del_init(&p->mglist);
  556. del_timer(&p->timer);
  557. call_rcu_bh(&p->rcu, br_multicast_free_pg);
  558. err = 0;
  559. if (!mp->ports && !mp->mglist &&
  560. netif_running(br->dev))
  561. mod_timer(&mp->timer, jiffies);
  562. break;
  563. }
  564. unlock:
  565. spin_unlock_bh(&br->multicast_lock);
  566. return err;
  567. }
  568. static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
  569. struct netlink_ext_ack *extack)
  570. {
  571. struct net *net = sock_net(skb->sk);
  572. struct net_bridge_vlan_group *vg;
  573. struct net_device *dev, *pdev;
  574. struct br_mdb_entry *entry;
  575. struct net_bridge_port *p;
  576. struct net_bridge_vlan *v;
  577. struct net_bridge *br;
  578. int err;
  579. err = br_mdb_parse(skb, nlh, &dev, &entry);
  580. if (err < 0)
  581. return err;
  582. br = netdev_priv(dev);
  583. /* If vlan filtering is enabled and VLAN is not specified
  584. * delete mdb entry on all vlans configured on the port.
  585. */
  586. pdev = __dev_get_by_index(net, entry->ifindex);
  587. if (!pdev)
  588. return -ENODEV;
  589. p = br_port_get_rtnl(pdev);
  590. if (!p || p->br != br || p->state == BR_STATE_DISABLED)
  591. return -EINVAL;
  592. vg = nbp_vlan_group(p);
  593. if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
  594. list_for_each_entry(v, &vg->vlan_list, vlist) {
  595. entry->vid = v->vid;
  596. err = __br_mdb_del(br, entry);
  597. if (!err)
  598. __br_mdb_notify(dev, p, entry, RTM_DELMDB);
  599. }
  600. } else {
  601. err = __br_mdb_del(br, entry);
  602. if (!err)
  603. __br_mdb_notify(dev, p, entry, RTM_DELMDB);
  604. }
  605. return err;
  606. }
  607. void br_mdb_init(void)
  608. {
  609. rtnl_register(PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, 0);
  610. rtnl_register(PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, 0);
  611. rtnl_register(PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, 0);
  612. }
  613. void br_mdb_uninit(void)
  614. {
  615. rtnl_unregister(PF_BRIDGE, RTM_GETMDB);
  616. rtnl_unregister(PF_BRIDGE, RTM_NEWMDB);
  617. rtnl_unregister(PF_BRIDGE, RTM_DELMDB);
  618. }