~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bridge/br_mdb.c

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 17 #include "br_private.h"
 18 
 19 static int br_rports_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
 20                                struct net_device *dev)
 21 {
 22         struct net_bridge *br = netdev_priv(dev);
 23         struct net_bridge_port *p;
 24         struct nlattr *nest, *port_nest;
 25 
 26         if (!br->multicast_router || hlist_empty(&br->router_list))
 27                 return 0;
 28 
 29         nest = nla_nest_start_noflag(skb, MDBA_ROUTER);
 30         if (nest == NULL)
 31                 return -EMSGSIZE;
 32 
 33         hlist_for_each_entry_rcu(p, &br->router_list, rlist) {
 34                 if (!p)
 35                         continue;
 36                 port_nest = nla_nest_start_noflag(skb, MDBA_ROUTER_PORT);
 37                 if (!port_nest)
 38                         goto fail;
 39                 if (nla_put_nohdr(skb, sizeof(u32), &p->dev->ifindex) ||
 40                     nla_put_u32(skb, MDBA_ROUTER_PATTR_TIMER,
 41                                 br_timer_value(&p->multicast_router_timer)) ||
 42                     nla_put_u8(skb, MDBA_ROUTER_PATTR_TYPE,
 43                                p->multicast_router)) {
 44                         nla_nest_cancel(skb, port_nest);
 45                         goto fail;
 46                 }
 47                 nla_nest_end(skb, port_nest);
 48         }
 49 
 50         nla_nest_end(skb, nest);
 51         return 0;
 52 fail:
 53         nla_nest_cancel(skb, nest);
 54         return -EMSGSIZE;
 55 }
 56 
 57 static void __mdb_entry_fill_flags(struct br_mdb_entry *e, unsigned char flags)
 58 {
 59         e->state = flags & MDB_PG_FLAGS_PERMANENT;
 60         e->flags = 0;
 61         if (flags & MDB_PG_FLAGS_OFFLOAD)
 62                 e->flags |= MDB_FLAGS_OFFLOAD;
 63 }
 64 
 65 static void __mdb_entry_to_br_ip(struct br_mdb_entry *entry, struct br_ip *ip)
 66 {
 67         memset(ip, 0, sizeof(struct br_ip));
 68         ip->vid = entry->vid;
 69         ip->proto = entry->addr.proto;
 70         if (ip->proto == htons(ETH_P_IP))
 71                 ip->u.ip4 = entry->addr.u.ip4;
 72 #if IS_ENABLED(CONFIG_IPV6)
 73         else
 74                 ip->u.ip6 = entry->addr.u.ip6;
 75 #endif
 76 }
 77 
 78 static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
 79                             struct net_device *dev)
 80 {
 81         int idx = 0, s_idx = cb->args[1], err = 0;
 82         struct net_bridge *br = netdev_priv(dev);
 83         struct net_bridge_mdb_entry *mp;
 84         struct nlattr *nest, *nest2;
 85 
 86         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
 87                 return 0;
 88 
 89         nest = nla_nest_start_noflag(skb, MDBA_MDB);
 90         if (nest == NULL)
 91                 return -EMSGSIZE;
 92 
 93         hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) {
 94                 struct net_bridge_port_group *p;
 95                 struct net_bridge_port_group __rcu **pp;
 96                 struct net_bridge_port *port;
 97 
 98                 if (idx < s_idx)
 99                         goto skip;
100 
101                 nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
102                 if (!nest2) {
103                         err = -EMSGSIZE;
104                         break;
105                 }
106 
107                 for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL;
108                       pp = &p->next) {
109                         struct nlattr *nest_ent;
110                         struct br_mdb_entry e;
111 
112                         port = p->port;
113                         if (!port)
114                                 continue;
115 
116                         memset(&e, 0, sizeof(e));
117                         e.ifindex = port->dev->ifindex;
118                         e.vid = p->addr.vid;
119                         __mdb_entry_fill_flags(&e, p->flags);
120                         if (p->addr.proto == htons(ETH_P_IP))
121                                 e.addr.u.ip4 = p->addr.u.ip4;
122 #if IS_ENABLED(CONFIG_IPV6)
123                         if (p->addr.proto == htons(ETH_P_IPV6))
124                                 e.addr.u.ip6 = p->addr.u.ip6;
125 #endif
126                         e.addr.proto = p->addr.proto;
127                         nest_ent = nla_nest_start_noflag(skb,
128                                                          MDBA_MDB_ENTRY_INFO);
129                         if (!nest_ent) {
130                                 nla_nest_cancel(skb, nest2);
131                                 err = -EMSGSIZE;
132                                 goto out;
133                         }
134                         if (nla_put_nohdr(skb, sizeof(e), &e) ||
135                             nla_put_u32(skb,
136                                         MDBA_MDB_EATTR_TIMER,
137                                         br_timer_value(&p->timer))) {
138                                 nla_nest_cancel(skb, nest_ent);
139                                 nla_nest_cancel(skb, nest2);
140                                 err = -EMSGSIZE;
141                                 goto out;
142                         }
143                         nla_nest_end(skb, nest_ent);
144                 }
145                 nla_nest_end(skb, nest2);
146 skip:
147                 idx++;
148         }
149 
150 out:
151         cb->args[1] = idx;
152         nla_nest_end(skb, nest);
153         return err;
154 }
155 
156 static int br_mdb_valid_dump_req(const struct nlmsghdr *nlh,
157                                  struct netlink_ext_ack *extack)
158 {
159         struct br_port_msg *bpm;
160 
161         if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*bpm))) {
162                 NL_SET_ERR_MSG_MOD(extack, "Invalid header for mdb dump request");
163                 return -EINVAL;
164         }
165 
166         bpm = nlmsg_data(nlh);
167         if (bpm->ifindex) {
168                 NL_SET_ERR_MSG_MOD(extack, "Filtering by device index is not supported for mdb dump request");
169                 return -EINVAL;
170         }
171         if (nlmsg_attrlen(nlh, sizeof(*bpm))) {
172                 NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request");
173                 return -EINVAL;
174         }
175 
176         return 0;
177 }
178 
179 static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
180 {
181         struct net_device *dev;
182         struct net *net = sock_net(skb->sk);
183         struct nlmsghdr *nlh = NULL;
184         int idx = 0, s_idx;
185 
186         if (cb->strict_check) {
187                 int err = br_mdb_valid_dump_req(cb->nlh, cb->extack);
188 
189                 if (err < 0)
190                         return err;
191         }
192 
193         s_idx = cb->args[0];
194 
195         rcu_read_lock();
196 
197         cb->seq = net->dev_base_seq;
198 
199         for_each_netdev_rcu(net, dev) {
200                 if (dev->priv_flags & IFF_EBRIDGE) {
201                         struct br_port_msg *bpm;
202 
203                         if (idx < s_idx)
204                                 goto skip;
205 
206                         nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
207                                         cb->nlh->nlmsg_seq, RTM_GETMDB,
208                                         sizeof(*bpm), NLM_F_MULTI);
209                         if (nlh == NULL)
210                                 break;
211 
212                         bpm = nlmsg_data(nlh);
213                         memset(bpm, 0, sizeof(*bpm));
214                         bpm->ifindex = dev->ifindex;
215                         if (br_mdb_fill_info(skb, cb, dev) < 0)
216                                 goto out;
217                         if (br_rports_fill_info(skb, cb, dev) < 0)
218                                 goto out;
219 
220                         cb->args[1] = 0;
221                         nlmsg_end(skb, nlh);
222                 skip:
223                         idx++;
224                 }
225         }
226 
227 out:
228         if (nlh)
229                 nlmsg_end(skb, nlh);
230         rcu_read_unlock();
231         cb->args[0] = idx;
232         return skb->len;
233 }
234 
235 static int nlmsg_populate_mdb_fill(struct sk_buff *skb,
236                                    struct net_device *dev,
237                                    struct br_mdb_entry *entry, u32 pid,
238                                    u32 seq, int type, unsigned int flags)
239 {
240         struct nlmsghdr *nlh;
241         struct br_port_msg *bpm;
242         struct nlattr *nest, *nest2;
243 
244         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0);
245         if (!nlh)
246                 return -EMSGSIZE;
247 
248         bpm = nlmsg_data(nlh);
249         memset(bpm, 0, sizeof(*bpm));
250         bpm->family  = AF_BRIDGE;
251         bpm->ifindex = dev->ifindex;
252         nest = nla_nest_start_noflag(skb, MDBA_MDB);
253         if (nest == NULL)
254                 goto cancel;
255         nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
256         if (nest2 == NULL)
257                 goto end;
258 
259         if (nla_put(skb, MDBA_MDB_ENTRY_INFO, sizeof(*entry), entry))
260                 goto end;
261 
262         nla_nest_end(skb, nest2);
263         nla_nest_end(skb, nest);
264         nlmsg_end(skb, nlh);
265         return 0;
266 
267 end:
268         nla_nest_end(skb, nest);
269 cancel:
270         nlmsg_cancel(skb, nlh);
271         return -EMSGSIZE;
272 }
273 
274 static inline size_t rtnl_mdb_nlmsg_size(void)
275 {
276         return NLMSG_ALIGN(sizeof(struct br_port_msg))
277                 + nla_total_size(sizeof(struct br_mdb_entry));
278 }
279 
280 struct br_mdb_complete_info {
281         struct net_bridge_port *port;
282         struct br_ip ip;
283 };
284 
285 static void br_mdb_complete(struct net_device *dev, int err, void *priv)
286 {
287         struct br_mdb_complete_info *data = priv;
288         struct net_bridge_port_group __rcu **pp;
289         struct net_bridge_port_group *p;
290         struct net_bridge_mdb_entry *mp;
291         struct net_bridge_port *port = data->port;
292         struct net_bridge *br = port->br;
293 
294         if (err)
295                 goto err;
296 
297         spin_lock_bh(&br->multicast_lock);
298         mp = br_mdb_ip_get(br, &data->ip);
299         if (!mp)
300                 goto out;
301         for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
302              pp = &p->next) {
303                 if (p->port != port)
304                         continue;
305                 p->flags |= MDB_PG_FLAGS_OFFLOAD;
306         }
307 out:
308         spin_unlock_bh(&br->multicast_lock);
309 err:
310         kfree(priv);
311 }
312 
313 static void br_mdb_switchdev_host_port(struct net_device *dev,
314                                        struct net_device *lower_dev,
315                                        struct br_mdb_entry *entry, int type)
316 {
317         struct switchdev_obj_port_mdb mdb = {
318                 .obj = {
319                         .id = SWITCHDEV_OBJ_ID_HOST_MDB,
320                         .flags = SWITCHDEV_F_DEFER,
321                 },
322                 .vid = entry->vid,
323         };
324 
325         if (entry->addr.proto == htons(ETH_P_IP))
326                 ip_eth_mc_map(entry->addr.u.ip4, mdb.addr);
327 #if IS_ENABLED(CONFIG_IPV6)
328         else
329                 ipv6_eth_mc_map(&entry->addr.u.ip6, mdb.addr);
330 #endif
331 
332         mdb.obj.orig_dev = dev;
333         switch (type) {
334         case RTM_NEWMDB:
335                 switchdev_port_obj_add(lower_dev, &mdb.obj, NULL);
336                 break;
337         case RTM_DELMDB:
338                 switchdev_port_obj_del(lower_dev, &mdb.obj);
339                 break;
340         }
341 }
342 
343 static void br_mdb_switchdev_host(struct net_device *dev,
344                                   struct br_mdb_entry *entry, int type)
345 {
346         struct net_device *lower_dev;
347         struct list_head *iter;
348 
349         netdev_for_each_lower_dev(dev, lower_dev, iter)
350                 br_mdb_switchdev_host_port(dev, lower_dev, entry, type);
351 }
352 
353 static void __br_mdb_notify(struct net_device *dev, struct net_bridge_port *p,
354                             struct br_mdb_entry *entry, int type)
355 {
356         struct br_mdb_complete_info *complete_info;
357         struct switchdev_obj_port_mdb mdb = {
358                 .obj = {
359                         .id = SWITCHDEV_OBJ_ID_PORT_MDB,
360                         .flags = SWITCHDEV_F_DEFER,
361                 },
362                 .vid = entry->vid,
363         };
364         struct net_device *port_dev;
365         struct net *net = dev_net(dev);
366         struct sk_buff *skb;
367         int err = -ENOBUFS;
368 
369         port_dev = __dev_get_by_index(net, entry->ifindex);
370         if (entry->addr.proto == htons(ETH_P_IP))
371                 ip_eth_mc_map(entry->addr.u.ip4, mdb.addr);
372 #if IS_ENABLED(CONFIG_IPV6)
373         else
374                 ipv6_eth_mc_map(&entry->addr.u.ip6, mdb.addr);
375 #endif
376 
377         mdb.obj.orig_dev = port_dev;
378         if (p && port_dev && type == RTM_NEWMDB) {
379                 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
380                 if (complete_info) {
381                         complete_info->port = p;
382                         __mdb_entry_to_br_ip(entry, &complete_info->ip);
383                         mdb.obj.complete_priv = complete_info;
384                         mdb.obj.complete = br_mdb_complete;
385                         if (switchdev_port_obj_add(port_dev, &mdb.obj, NULL))
386                                 kfree(complete_info);
387                 }
388         } else if (p && port_dev && type == RTM_DELMDB) {
389                 switchdev_port_obj_del(port_dev, &mdb.obj);
390         }
391 
392         if (!p)
393                 br_mdb_switchdev_host(dev, entry, type);
394 
395         skb = nlmsg_new(rtnl_mdb_nlmsg_size(), GFP_ATOMIC);
396         if (!skb)
397                 goto errout;
398 
399         err = nlmsg_populate_mdb_fill(skb, dev, entry, 0, 0, type, NTF_SELF);
400         if (err < 0) {
401                 kfree_skb(skb);
402                 goto errout;
403         }
404 
405         rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
406         return;
407 errout:
408         rtnl_set_sk_err(net, RTNLGRP_MDB, err);
409 }
410 
411 void br_mdb_notify(struct net_device *dev, struct net_bridge_port *port,
412                    struct br_ip *group, int type, u8 flags)
413 {
414         struct br_mdb_entry entry;
415 
416         memset(&entry, 0, sizeof(entry));
417         if (port)
418                 entry.ifindex = port->dev->ifindex;
419         else
420                 entry.ifindex = dev->ifindex;
421         entry.addr.proto = group->proto;
422         entry.addr.u.ip4 = group->u.ip4;
423 #if IS_ENABLED(CONFIG_IPV6)
424         entry.addr.u.ip6 = group->u.ip6;
425 #endif
426         entry.vid = group->vid;
427         __mdb_entry_fill_flags(&entry, flags);
428         __br_mdb_notify(dev, port, &entry, type);
429 }
430 
431 static int nlmsg_populate_rtr_fill(struct sk_buff *skb,
432                                    struct net_device *dev,
433                                    int ifindex, u32 pid,
434                                    u32 seq, int type, unsigned int flags)
435 {
436         struct br_port_msg *bpm;
437         struct nlmsghdr *nlh;
438         struct nlattr *nest;
439 
440         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0);
441         if (!nlh)
442                 return -EMSGSIZE;
443 
444         bpm = nlmsg_data(nlh);
445         memset(bpm, 0, sizeof(*bpm));
446         bpm->family = AF_BRIDGE;
447         bpm->ifindex = dev->ifindex;
448         nest = nla_nest_start_noflag(skb, MDBA_ROUTER);
449         if (!nest)
450                 goto cancel;
451 
452         if (nla_put_u32(skb, MDBA_ROUTER_PORT, ifindex))
453                 goto end;
454 
455         nla_nest_end(skb, nest);
456         nlmsg_end(skb, nlh);
457         return 0;
458 
459 end:
460         nla_nest_end(skb, nest);
461 cancel:
462         nlmsg_cancel(skb, nlh);
463         return -EMSGSIZE;
464 }
465 
466 static inline size_t rtnl_rtr_nlmsg_size(void)
467 {
468         return NLMSG_ALIGN(sizeof(struct br_port_msg))
469                 + nla_total_size(sizeof(__u32));
470 }
471 
472 void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port,
473                    int type)
474 {
475         struct net *net = dev_net(dev);
476         struct sk_buff *skb;
477         int err = -ENOBUFS;
478         int ifindex;
479 
480         ifindex = port ? port->dev->ifindex : 0;
481         skb = nlmsg_new(rtnl_rtr_nlmsg_size(), GFP_ATOMIC);
482         if (!skb)
483                 goto errout;
484 
485         err = nlmsg_populate_rtr_fill(skb, dev, ifindex, 0, 0, type, NTF_SELF);
486         if (err < 0) {
487                 kfree_skb(skb);
488                 goto errout;
489         }
490 
491         rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
492         return;
493 
494 errout:
495         rtnl_set_sk_err(net, RTNLGRP_MDB, err);
496 }
497 
498 static bool is_valid_mdb_entry(struct br_mdb_entry *entry)
499 {
500         if (entry->ifindex == 0)
501                 return false;
502 
503         if (entry->addr.proto == htons(ETH_P_IP)) {
504                 if (!ipv4_is_multicast(entry->addr.u.ip4))
505                         return false;
506                 if (ipv4_is_local_multicast(entry->addr.u.ip4))
507                         return false;
508 #if IS_ENABLED(CONFIG_IPV6)
509         } else if (entry->addr.proto == htons(ETH_P_IPV6)) {
510                 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6))
511                         return false;
512 #endif
513         } else
514                 return false;
515         if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY)
516                 return false;
517         if (entry->vid >= VLAN_VID_MASK)
518                 return false;
519 
520         return true;
521 }
522 
523 static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh,
524                         struct net_device **pdev, struct br_mdb_entry **pentry)
525 {
526         struct net *net = sock_net(skb->sk);
527         struct br_mdb_entry *entry;
528         struct br_port_msg *bpm;
529         struct nlattr *tb[MDBA_SET_ENTRY_MAX+1];
530         struct net_device *dev;
531         int err;
532 
533         err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
534                                      MDBA_SET_ENTRY_MAX, NULL, NULL);
535         if (err < 0)
536                 return err;
537 
538         bpm = nlmsg_data(nlh);
539         if (bpm->ifindex == 0) {
540                 pr_info("PF_BRIDGE: br_mdb_parse() with invalid ifindex\n");
541                 return -EINVAL;
542         }
543 
544         dev = __dev_get_by_index(net, bpm->ifindex);
545         if (dev == NULL) {
546                 pr_info("PF_BRIDGE: br_mdb_parse() with unknown ifindex\n");
547                 return -ENODEV;
548         }
549 
550         if (!(dev->priv_flags & IFF_EBRIDGE)) {
551                 pr_info("PF_BRIDGE: br_mdb_parse() with non-bridge\n");
552                 return -EOPNOTSUPP;
553         }
554 
555         *pdev = dev;
556 
557         if (!tb[MDBA_SET_ENTRY] ||
558             nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) {
559                 pr_info("PF_BRIDGE: br_mdb_parse() with invalid attr\n");
560                 return -EINVAL;
561         }
562 
563         entry = nla_data(tb[MDBA_SET_ENTRY]);
564         if (!is_valid_mdb_entry(entry)) {
565                 pr_info("PF_BRIDGE: br_mdb_parse() with invalid entry\n");
566                 return -EINVAL;
567         }
568 
569         *pentry = entry;
570         return 0;
571 }
572 
573 static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port,
574                             struct br_ip *group, unsigned char state)
575 {
576         struct net_bridge_mdb_entry *mp;
577         struct net_bridge_port_group *p;
578         struct net_bridge_port_group __rcu **pp;
579         unsigned long now = jiffies;
580         int err;
581 
582         mp = br_mdb_ip_get(br, group);
583         if (!mp) {
584                 mp = br_multicast_new_group(br, group);
585                 err = PTR_ERR_OR_ZERO(mp);
586                 if (err)
587                         return err;
588         }
589 
590         for (pp = &mp->ports;
591              (p = mlock_dereference(*pp, br)) != NULL;
592              pp = &p->next) {
593                 if (p->port == port)
594                         return -EEXIST;
595                 if ((unsigned long)p->port < (unsigned long)port)
596                         break;
597         }
598 
599         p = br_multicast_new_port_group(port, group, *pp, state, NULL);
600         if (unlikely(!p))
601                 return -ENOMEM;
602         rcu_assign_pointer(*pp, p);
603         if (state == MDB_TEMPORARY)
604                 mod_timer(&p->timer, now + br->multicast_membership_interval);
605 
606         return 0;
607 }
608 
609 static int __br_mdb_add(struct net *net, struct net_bridge *br,
610                         struct br_mdb_entry *entry)
611 {
612         struct br_ip ip;
613         struct net_device *dev;
614         struct net_bridge_port *p;
615         int ret;
616 
617         if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
618                 return -EINVAL;
619 
620         dev = __dev_get_by_index(net, entry->ifindex);
621         if (!dev)
622                 return -ENODEV;
623 
624         p = br_port_get_rtnl(dev);
625         if (!p || p->br != br || p->state == BR_STATE_DISABLED)
626                 return -EINVAL;
627 
628         __mdb_entry_to_br_ip(entry, &ip);
629 
630         spin_lock_bh(&br->multicast_lock);
631         ret = br_mdb_add_group(br, p, &ip, entry->state);
632         spin_unlock_bh(&br->multicast_lock);
633         return ret;
634 }
635 
636 static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
637                       struct netlink_ext_ack *extack)
638 {
639         struct net *net = sock_net(skb->sk);
640         struct net_bridge_vlan_group *vg;
641         struct net_device *dev, *pdev;
642         struct br_mdb_entry *entry;
643         struct net_bridge_port *p;
644         struct net_bridge_vlan *v;
645         struct net_bridge *br;
646         int err;
647 
648         err = br_mdb_parse(skb, nlh, &dev, &entry);
649         if (err < 0)
650                 return err;
651 
652         br = netdev_priv(dev);
653 
654         /* If vlan filtering is enabled and VLAN is not specified
655          * install mdb entry on all vlans configured on the port.
656          */
657         pdev = __dev_get_by_index(net, entry->ifindex);
658         if (!pdev)
659                 return -ENODEV;
660 
661         p = br_port_get_rtnl(pdev);
662         if (!p || p->br != br || p->state == BR_STATE_DISABLED)
663                 return -EINVAL;
664 
665         vg = nbp_vlan_group(p);
666         if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
667                 list_for_each_entry(v, &vg->vlan_list, vlist) {
668                         entry->vid = v->vid;
669                         err = __br_mdb_add(net, br, entry);
670                         if (err)
671                                 break;
672                         __br_mdb_notify(dev, p, entry, RTM_NEWMDB);
673                 }
674         } else {
675                 err = __br_mdb_add(net, br, entry);
676                 if (!err)
677                         __br_mdb_notify(dev, p, entry, RTM_NEWMDB);
678         }
679 
680         return err;
681 }
682 
683 static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry)
684 {
685         struct net_bridge_mdb_entry *mp;
686         struct net_bridge_port_group *p;
687         struct net_bridge_port_group __rcu **pp;
688         struct br_ip ip;
689         int err = -EINVAL;
690 
691         if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
692                 return -EINVAL;
693 
694         __mdb_entry_to_br_ip(entry, &ip);
695 
696         spin_lock_bh(&br->multicast_lock);
697         mp = br_mdb_ip_get(br, &ip);
698         if (!mp)
699                 goto unlock;
700 
701         for (pp = &mp->ports;
702              (p = mlock_dereference(*pp, br)) != NULL;
703              pp = &p->next) {
704                 if (!p->port || p->port->dev->ifindex != entry->ifindex)
705                         continue;
706 
707                 if (p->port->state == BR_STATE_DISABLED)
708                         goto unlock;
709 
710                 __mdb_entry_fill_flags(entry, p->flags);
711                 rcu_assign_pointer(*pp, p->next);
712                 hlist_del_init(&p->mglist);
713                 del_timer(&p->timer);
714                 kfree_rcu(p, rcu);
715                 err = 0;
716 
717                 if (!mp->ports && !mp->host_joined &&
718                     netif_running(br->dev))
719                         mod_timer(&mp->timer, jiffies);
720                 break;
721         }
722 
723 unlock:
724         spin_unlock_bh(&br->multicast_lock);
725         return err;
726 }
727 
728 static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
729                       struct netlink_ext_ack *extack)
730 {
731         struct net *net = sock_net(skb->sk);
732         struct net_bridge_vlan_group *vg;
733         struct net_device *dev, *pdev;
734         struct br_mdb_entry *entry;
735         struct net_bridge_port *p;
736         struct net_bridge_vlan *v;
737         struct net_bridge *br;
738         int err;
739 
740         err = br_mdb_parse(skb, nlh, &dev, &entry);
741         if (err < 0)
742                 return err;
743 
744         br = netdev_priv(dev);
745 
746         /* If vlan filtering is enabled and VLAN is not specified
747          * delete mdb entry on all vlans configured on the port.
748          */
749         pdev = __dev_get_by_index(net, entry->ifindex);
750         if (!pdev)
751                 return -ENODEV;
752 
753         p = br_port_get_rtnl(pdev);
754         if (!p || p->br != br || p->state == BR_STATE_DISABLED)
755                 return -EINVAL;
756 
757         vg = nbp_vlan_group(p);
758         if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
759                 list_for_each_entry(v, &vg->vlan_list, vlist) {
760                         entry->vid = v->vid;
761                         err = __br_mdb_del(br, entry);
762                         if (!err)
763                                 __br_mdb_notify(dev, p, entry, RTM_DELMDB);
764                 }
765         } else {
766                 err = __br_mdb_del(br, entry);
767                 if (!err)
768                         __br_mdb_notify(dev, p, entry, RTM_DELMDB);
769         }
770 
771         return err;
772 }
773 
774 void br_mdb_init(void)
775 {
776         rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, 0);
777         rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, 0);
778         rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, 0);
779 }
780 
781 void br_mdb_uninit(void)
782 {
783         rtnl_unregister(PF_BRIDGE, RTM_GETMDB);
784         rtnl_unregister(PF_BRIDGE, RTM_NEWMDB);
785         rtnl_unregister(PF_BRIDGE, RTM_DELMDB);
786 }
787 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp