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

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

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  *      Bridge netlink control interface
  3  *
  4  *      Authors:
  5  *      Stephen Hemminger               <shemminger@osdl.org>
  6  *
  7  *      This program is free software; you can redistribute it and/or
  8  *      modify it under the terms of the GNU General Public License
  9  *      as published by the Free Software Foundation; either version
 10  *      2 of the License, or (at your option) any later version.
 11  */
 12 
 13 #include <linux/kernel.h>
 14 #include <linux/slab.h>
 15 #include <linux/etherdevice.h>
 16 #include <net/rtnetlink.h>
 17 #include <net/net_namespace.h>
 18 #include <net/sock.h>
 19 #include <uapi/linux/if_bridge.h>
 20 
 21 #include "br_private.h"
 22 #include "br_private_stp.h"
 23 
 24 static int __get_num_vlan_infos(struct net_bridge_vlan_group *vg,
 25                                 u32 filter_mask)
 26 {
 27         struct net_bridge_vlan *v;
 28         u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
 29         u16 flags, pvid;
 30         int num_vlans = 0;
 31 
 32         if (!(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
 33                 return 0;
 34 
 35         pvid = br_get_pvid(vg);
 36         /* Count number of vlan infos */
 37         list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
 38                 flags = 0;
 39                 /* only a context, bridge vlan not activated */
 40                 if (!br_vlan_should_use(v))
 41                         continue;
 42                 if (v->vid == pvid)
 43                         flags |= BRIDGE_VLAN_INFO_PVID;
 44 
 45                 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
 46                         flags |= BRIDGE_VLAN_INFO_UNTAGGED;
 47 
 48                 if (vid_range_start == 0) {
 49                         goto initvars;
 50                 } else if ((v->vid - vid_range_end) == 1 &&
 51                         flags == vid_range_flags) {
 52                         vid_range_end = v->vid;
 53                         continue;
 54                 } else {
 55                         if ((vid_range_end - vid_range_start) > 0)
 56                                 num_vlans += 2;
 57                         else
 58                                 num_vlans += 1;
 59                 }
 60 initvars:
 61                 vid_range_start = v->vid;
 62                 vid_range_end = v->vid;
 63                 vid_range_flags = flags;
 64         }
 65 
 66         if (vid_range_start != 0) {
 67                 if ((vid_range_end - vid_range_start) > 0)
 68                         num_vlans += 2;
 69                 else
 70                         num_vlans += 1;
 71         }
 72 
 73         return num_vlans;
 74 }
 75 
 76 static int br_get_num_vlan_infos(struct net_bridge_vlan_group *vg,
 77                                  u32 filter_mask)
 78 {
 79         int num_vlans;
 80 
 81         if (!vg)
 82                 return 0;
 83 
 84         if (filter_mask & RTEXT_FILTER_BRVLAN)
 85                 return vg->num_vlans;
 86 
 87         rcu_read_lock();
 88         num_vlans = __get_num_vlan_infos(vg, filter_mask);
 89         rcu_read_unlock();
 90 
 91         return num_vlans;
 92 }
 93 
 94 static size_t br_get_link_af_size_filtered(const struct net_device *dev,
 95                                            u32 filter_mask)
 96 {
 97         struct net_bridge_vlan_group *vg = NULL;
 98         struct net_bridge_port *p;
 99         struct net_bridge *br;
100         int num_vlan_infos;
101 
102         rcu_read_lock();
103         if (br_port_exists(dev)) {
104                 p = br_port_get_rcu(dev);
105                 vg = nbp_vlan_group_rcu(p);
106         } else if (dev->priv_flags & IFF_EBRIDGE) {
107                 br = netdev_priv(dev);
108                 vg = br_vlan_group_rcu(br);
109         }
110         num_vlan_infos = br_get_num_vlan_infos(vg, filter_mask);
111         rcu_read_unlock();
112 
113         /* Each VLAN is returned in bridge_vlan_info along with flags */
114         return num_vlan_infos * nla_total_size(sizeof(struct bridge_vlan_info));
115 }
116 
117 static inline size_t br_port_info_size(void)
118 {
119         return nla_total_size(1)        /* IFLA_BRPORT_STATE  */
120                 + nla_total_size(2)     /* IFLA_BRPORT_PRIORITY */
121                 + nla_total_size(4)     /* IFLA_BRPORT_COST */
122                 + nla_total_size(1)     /* IFLA_BRPORT_MODE */
123                 + nla_total_size(1)     /* IFLA_BRPORT_GUARD */
124                 + nla_total_size(1)     /* IFLA_BRPORT_PROTECT */
125                 + nla_total_size(1)     /* IFLA_BRPORT_FAST_LEAVE */
126                 + nla_total_size(1)     /* IFLA_BRPORT_LEARNING */
127                 + nla_total_size(1)     /* IFLA_BRPORT_UNICAST_FLOOD */
128                 + nla_total_size(1)     /* IFLA_BRPORT_PROXYARP */
129                 + nla_total_size(1)     /* IFLA_BRPORT_PROXYARP_WIFI */
130                 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_ROOT_ID */
131                 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_BRIDGE_ID */
132                 + nla_total_size(sizeof(u16))   /* IFLA_BRPORT_DESIGNATED_PORT */
133                 + nla_total_size(sizeof(u16))   /* IFLA_BRPORT_DESIGNATED_COST */
134                 + nla_total_size(sizeof(u16))   /* IFLA_BRPORT_ID */
135                 + nla_total_size(sizeof(u16))   /* IFLA_BRPORT_NO */
136                 + nla_total_size(sizeof(u8))    /* IFLA_BRPORT_TOPOLOGY_CHANGE_ACK */
137                 + nla_total_size(sizeof(u8))    /* IFLA_BRPORT_CONFIG_PENDING */
138                 + nla_total_size(sizeof(u64))   /* IFLA_BRPORT_MESSAGE_AGE_TIMER */
139                 + nla_total_size(sizeof(u64))   /* IFLA_BRPORT_FORWARD_DELAY_TIMER */
140                 + nla_total_size(sizeof(u64))   /* IFLA_BRPORT_HOLD_TIMER */
141 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
142                 + nla_total_size(sizeof(u8))    /* IFLA_BRPORT_MULTICAST_ROUTER */
143 #endif
144                 + 0;
145 }
146 
147 static inline size_t br_nlmsg_size(struct net_device *dev, u32 filter_mask)
148 {
149         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
150                 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
151                 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
152                 + nla_total_size(4) /* IFLA_MASTER */
153                 + nla_total_size(4) /* IFLA_MTU */
154                 + nla_total_size(4) /* IFLA_LINK */
155                 + nla_total_size(1) /* IFLA_OPERSTATE */
156                 + nla_total_size(br_port_info_size()) /* IFLA_PROTINFO */
157                 + nla_total_size(br_get_link_af_size_filtered(dev,
158                                  filter_mask)); /* IFLA_AF_SPEC */
159 }
160 
161 static int br_port_fill_attrs(struct sk_buff *skb,
162                               const struct net_bridge_port *p)
163 {
164         u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
165         u64 timerval;
166 
167         if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
168             nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
169             nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
170             nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
171             nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
172             nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
173             nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
174             nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
175             nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)) ||
176             nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)) ||
177             nla_put_u8(skb, IFLA_BRPORT_PROXYARP_WIFI,
178                        !!(p->flags & BR_PROXYARP_WIFI)) ||
179             nla_put(skb, IFLA_BRPORT_ROOT_ID, sizeof(struct ifla_bridge_id),
180                     &p->designated_root) ||
181             nla_put(skb, IFLA_BRPORT_BRIDGE_ID, sizeof(struct ifla_bridge_id),
182                     &p->designated_bridge) ||
183             nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_PORT, p->designated_port) ||
184             nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_COST, p->designated_cost) ||
185             nla_put_u16(skb, IFLA_BRPORT_ID, p->port_id) ||
186             nla_put_u16(skb, IFLA_BRPORT_NO, p->port_no) ||
187             nla_put_u8(skb, IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
188                        p->topology_change_ack) ||
189             nla_put_u8(skb, IFLA_BRPORT_CONFIG_PENDING, p->config_pending))
190                 return -EMSGSIZE;
191 
192         timerval = br_timer_value(&p->message_age_timer);
193         if (nla_put_u64(skb, IFLA_BRPORT_MESSAGE_AGE_TIMER, timerval))
194                 return -EMSGSIZE;
195         timerval = br_timer_value(&p->forward_delay_timer);
196         if (nla_put_u64(skb, IFLA_BRPORT_FORWARD_DELAY_TIMER, timerval))
197                 return -EMSGSIZE;
198         timerval = br_timer_value(&p->hold_timer);
199         if (nla_put_u64(skb, IFLA_BRPORT_HOLD_TIMER, timerval))
200                 return -EMSGSIZE;
201 
202 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
203         if (nla_put_u8(skb, IFLA_BRPORT_MULTICAST_ROUTER,
204                        p->multicast_router))
205                 return -EMSGSIZE;
206 #endif
207 
208         return 0;
209 }
210 
211 static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
212                                     u16 vid_end, u16 flags)
213 {
214         struct  bridge_vlan_info vinfo;
215 
216         if ((vid_end - vid_start) > 0) {
217                 /* add range to skb */
218                 vinfo.vid = vid_start;
219                 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
220                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
221                             sizeof(vinfo), &vinfo))
222                         goto nla_put_failure;
223 
224                 vinfo.vid = vid_end;
225                 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
226                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
227                             sizeof(vinfo), &vinfo))
228                         goto nla_put_failure;
229         } else {
230                 vinfo.vid = vid_start;
231                 vinfo.flags = flags;
232                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
233                             sizeof(vinfo), &vinfo))
234                         goto nla_put_failure;
235         }
236 
237         return 0;
238 
239 nla_put_failure:
240         return -EMSGSIZE;
241 }
242 
243 static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
244                                          struct net_bridge_vlan_group *vg)
245 {
246         struct net_bridge_vlan *v;
247         u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
248         u16 flags, pvid;
249         int err = 0;
250 
251         /* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
252          * and mark vlan info with begin and end flags
253          * if vlaninfo represents a range
254          */
255         pvid = br_get_pvid(vg);
256         list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
257                 flags = 0;
258                 if (!br_vlan_should_use(v))
259                         continue;
260                 if (v->vid == pvid)
261                         flags |= BRIDGE_VLAN_INFO_PVID;
262 
263                 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
264                         flags |= BRIDGE_VLAN_INFO_UNTAGGED;
265 
266                 if (vid_range_start == 0) {
267                         goto initvars;
268                 } else if ((v->vid - vid_range_end) == 1 &&
269                         flags == vid_range_flags) {
270                         vid_range_end = v->vid;
271                         continue;
272                 } else {
273                         err = br_fill_ifvlaninfo_range(skb, vid_range_start,
274                                                        vid_range_end,
275                                                        vid_range_flags);
276                         if (err)
277                                 return err;
278                 }
279 
280 initvars:
281                 vid_range_start = v->vid;
282                 vid_range_end = v->vid;
283                 vid_range_flags = flags;
284         }
285 
286         if (vid_range_start != 0) {
287                 /* Call it once more to send any left over vlans */
288                 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
289                                                vid_range_end,
290                                                vid_range_flags);
291                 if (err)
292                         return err;
293         }
294 
295         return 0;
296 }
297 
298 static int br_fill_ifvlaninfo(struct sk_buff *skb,
299                               struct net_bridge_vlan_group *vg)
300 {
301         struct bridge_vlan_info vinfo;
302         struct net_bridge_vlan *v;
303         u16 pvid;
304 
305         pvid = br_get_pvid(vg);
306         list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
307                 if (!br_vlan_should_use(v))
308                         continue;
309 
310                 vinfo.vid = v->vid;
311                 vinfo.flags = 0;
312                 if (v->vid == pvid)
313                         vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
314 
315                 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
316                         vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
317 
318                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
319                             sizeof(vinfo), &vinfo))
320                         goto nla_put_failure;
321         }
322 
323         return 0;
324 
325 nla_put_failure:
326         return -EMSGSIZE;
327 }
328 
329 /*
330  * Create one netlink message for one interface
331  * Contains port and master info as well as carrier and bridge state.
332  */
333 static int br_fill_ifinfo(struct sk_buff *skb,
334                           struct net_bridge_port *port,
335                           u32 pid, u32 seq, int event, unsigned int flags,
336                           u32 filter_mask, const struct net_device *dev)
337 {
338         struct net_bridge *br;
339         struct ifinfomsg *hdr;
340         struct nlmsghdr *nlh;
341         u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
342 
343         if (port)
344                 br = port->br;
345         else
346                 br = netdev_priv(dev);
347 
348         br_debug(br, "br_fill_info event %d port %s master %s\n",
349                      event, dev->name, br->dev->name);
350 
351         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
352         if (nlh == NULL)
353                 return -EMSGSIZE;
354 
355         hdr = nlmsg_data(nlh);
356         hdr->ifi_family = AF_BRIDGE;
357         hdr->__ifi_pad = 0;
358         hdr->ifi_type = dev->type;
359         hdr->ifi_index = dev->ifindex;
360         hdr->ifi_flags = dev_get_flags(dev);
361         hdr->ifi_change = 0;
362 
363         if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
364             nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
365             nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
366             nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
367             (dev->addr_len &&
368              nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
369             (dev->ifindex != dev_get_iflink(dev) &&
370              nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
371                 goto nla_put_failure;
372 
373         if (event == RTM_NEWLINK && port) {
374                 struct nlattr *nest
375                         = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
376 
377                 if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
378                         goto nla_put_failure;
379                 nla_nest_end(skb, nest);
380         }
381 
382         /* Check if  the VID information is requested */
383         if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
384             (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
385                 struct net_bridge_vlan_group *vg;
386                 struct nlattr *af;
387                 int err;
388 
389                 /* RCU needed because of the VLAN locking rules (rcu || rtnl) */
390                 rcu_read_lock();
391                 if (port)
392                         vg = nbp_vlan_group_rcu(port);
393                 else
394                         vg = br_vlan_group_rcu(br);
395 
396                 if (!vg || !vg->num_vlans) {
397                         rcu_read_unlock();
398                         goto done;
399                 }
400                 af = nla_nest_start(skb, IFLA_AF_SPEC);
401                 if (!af) {
402                         rcu_read_unlock();
403                         goto nla_put_failure;
404                 }
405                 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
406                         err = br_fill_ifvlaninfo_compressed(skb, vg);
407                 else
408                         err = br_fill_ifvlaninfo(skb, vg);
409                 rcu_read_unlock();
410                 if (err)
411                         goto nla_put_failure;
412                 nla_nest_end(skb, af);
413         }
414 
415 done:
416         nlmsg_end(skb, nlh);
417         return 0;
418 
419 nla_put_failure:
420         nlmsg_cancel(skb, nlh);
421         return -EMSGSIZE;
422 }
423 
424 /*
425  * Notify listeners of a change in port information
426  */
427 void br_ifinfo_notify(int event, struct net_bridge_port *port)
428 {
429         struct net *net;
430         struct sk_buff *skb;
431         int err = -ENOBUFS;
432         u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
433 
434         if (!port)
435                 return;
436 
437         net = dev_net(port->dev);
438         br_debug(port->br, "port %u(%s) event %d\n",
439                  (unsigned int)port->port_no, port->dev->name, event);
440 
441         skb = nlmsg_new(br_nlmsg_size(port->dev, filter), GFP_ATOMIC);
442         if (skb == NULL)
443                 goto errout;
444 
445         err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, port->dev);
446         if (err < 0) {
447                 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
448                 WARN_ON(err == -EMSGSIZE);
449                 kfree_skb(skb);
450                 goto errout;
451         }
452         rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
453         return;
454 errout:
455         rtnl_set_sk_err(net, RTNLGRP_LINK, err);
456 }
457 
458 
459 /*
460  * Dump information about all ports, in response to GETLINK
461  */
462 int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
463                struct net_device *dev, u32 filter_mask, int nlflags)
464 {
465         struct net_bridge_port *port = br_port_get_rtnl(dev);
466 
467         if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
468             !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
469                 return 0;
470 
471         return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
472                               filter_mask, dev);
473 }
474 
475 static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
476                         int cmd, struct bridge_vlan_info *vinfo)
477 {
478         int err = 0;
479 
480         switch (cmd) {
481         case RTM_SETLINK:
482                 if (p) {
483                         /* if the MASTER flag is set this will act on the global
484                          * per-VLAN entry as well
485                          */
486                         err = nbp_vlan_add(p, vinfo->vid, vinfo->flags);
487                         if (err)
488                                 break;
489                 } else {
490                         vinfo->flags |= BRIDGE_VLAN_INFO_BRENTRY;
491                         err = br_vlan_add(br, vinfo->vid, vinfo->flags);
492                 }
493                 break;
494 
495         case RTM_DELLINK:
496                 if (p) {
497                         nbp_vlan_delete(p, vinfo->vid);
498                         if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
499                                 br_vlan_delete(p->br, vinfo->vid);
500                 } else {
501                         br_vlan_delete(br, vinfo->vid);
502                 }
503                 break;
504         }
505 
506         return err;
507 }
508 
509 static int br_afspec(struct net_bridge *br,
510                      struct net_bridge_port *p,
511                      struct nlattr *af_spec,
512                      int cmd)
513 {
514         struct bridge_vlan_info *vinfo_start = NULL;
515         struct bridge_vlan_info *vinfo = NULL;
516         struct nlattr *attr;
517         int err = 0;
518         int rem;
519 
520         nla_for_each_nested(attr, af_spec, rem) {
521                 if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
522                         continue;
523                 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
524                         return -EINVAL;
525                 vinfo = nla_data(attr);
526                 if (!vinfo->vid || vinfo->vid >= VLAN_VID_MASK)
527                         return -EINVAL;
528                 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
529                         if (vinfo_start)
530                                 return -EINVAL;
531                         vinfo_start = vinfo;
532                         /* don't allow range of pvids */
533                         if (vinfo_start->flags & BRIDGE_VLAN_INFO_PVID)
534                                 return -EINVAL;
535                         continue;
536                 }
537 
538                 if (vinfo_start) {
539                         struct bridge_vlan_info tmp_vinfo;
540                         int v;
541 
542                         if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
543                                 return -EINVAL;
544 
545                         if (vinfo->vid <= vinfo_start->vid)
546                                 return -EINVAL;
547 
548                         memcpy(&tmp_vinfo, vinfo_start,
549                                sizeof(struct bridge_vlan_info));
550 
551                         for (v = vinfo_start->vid; v <= vinfo->vid; v++) {
552                                 tmp_vinfo.vid = v;
553                                 err = br_vlan_info(br, p, cmd, &tmp_vinfo);
554                                 if (err)
555                                         break;
556                         }
557                         vinfo_start = NULL;
558                 } else {
559                         err = br_vlan_info(br, p, cmd, vinfo);
560                 }
561                 if (err)
562                         break;
563         }
564 
565         return err;
566 }
567 
568 static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
569         [IFLA_BRPORT_STATE]     = { .type = NLA_U8 },
570         [IFLA_BRPORT_COST]      = { .type = NLA_U32 },
571         [IFLA_BRPORT_PRIORITY]  = { .type = NLA_U16 },
572         [IFLA_BRPORT_MODE]      = { .type = NLA_U8 },
573         [IFLA_BRPORT_GUARD]     = { .type = NLA_U8 },
574         [IFLA_BRPORT_PROTECT]   = { .type = NLA_U8 },
575         [IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
576         [IFLA_BRPORT_LEARNING]  = { .type = NLA_U8 },
577         [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
578         [IFLA_BRPORT_PROXYARP]  = { .type = NLA_U8 },
579         [IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
580         [IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
581 };
582 
583 /* Change the state of the port and notify spanning tree */
584 static int br_set_port_state(struct net_bridge_port *p, u8 state)
585 {
586         if (state > BR_STATE_BLOCKING)
587                 return -EINVAL;
588 
589         /* if kernel STP is running, don't allow changes */
590         if (p->br->stp_enabled == BR_KERNEL_STP)
591                 return -EBUSY;
592 
593         /* if device is not up, change is not allowed
594          * if link is not present, only allowable state is disabled
595          */
596         if (!netif_running(p->dev) ||
597             (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
598                 return -ENETDOWN;
599 
600         br_set_state(p, state);
601         br_port_state_selection(p->br);
602         return 0;
603 }
604 
605 /* Set/clear or port flags based on attribute */
606 static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
607                            int attrtype, unsigned long mask)
608 {
609         if (tb[attrtype]) {
610                 u8 flag = nla_get_u8(tb[attrtype]);
611                 if (flag)
612                         p->flags |= mask;
613                 else
614                         p->flags &= ~mask;
615         }
616 }
617 
618 /* Process bridge protocol info on port */
619 static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
620 {
621         int err;
622         unsigned long old_flags = p->flags;
623 
624         br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
625         br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
626         br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
627         br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
628         br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
629         br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
630         br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
631         br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
632 
633         if (tb[IFLA_BRPORT_COST]) {
634                 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
635                 if (err)
636                         return err;
637         }
638 
639         if (tb[IFLA_BRPORT_PRIORITY]) {
640                 err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
641                 if (err)
642                         return err;
643         }
644 
645         if (tb[IFLA_BRPORT_STATE]) {
646                 err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
647                 if (err)
648                         return err;
649         }
650 
651         if (tb[IFLA_BRPORT_FLUSH])
652                 br_fdb_delete_by_port(p->br, p, 0, 0);
653 
654 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
655         if (tb[IFLA_BRPORT_MULTICAST_ROUTER]) {
656                 u8 mcast_router = nla_get_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]);
657 
658                 err = br_multicast_set_port_router(p, mcast_router);
659                 if (err)
660                         return err;
661         }
662 #endif
663         br_port_flags_change(p, old_flags ^ p->flags);
664         return 0;
665 }
666 
667 /* Change state and parameters on port. */
668 int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
669 {
670         struct nlattr *protinfo;
671         struct nlattr *afspec;
672         struct net_bridge_port *p;
673         struct nlattr *tb[IFLA_BRPORT_MAX + 1];
674         int err = 0;
675 
676         protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
677         afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
678         if (!protinfo && !afspec)
679                 return 0;
680 
681         p = br_port_get_rtnl(dev);
682         /* We want to accept dev as bridge itself if the AF_SPEC
683          * is set to see if someone is setting vlan info on the bridge
684          */
685         if (!p && !afspec)
686                 return -EINVAL;
687 
688         if (p && protinfo) {
689                 if (protinfo->nla_type & NLA_F_NESTED) {
690                         err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
691                                                protinfo, br_port_policy);
692                         if (err)
693                                 return err;
694 
695                         spin_lock_bh(&p->br->lock);
696                         err = br_setport(p, tb);
697                         spin_unlock_bh(&p->br->lock);
698                 } else {
699                         /* Binary compatibility with old RSTP */
700                         if (nla_len(protinfo) < sizeof(u8))
701                                 return -EINVAL;
702 
703                         spin_lock_bh(&p->br->lock);
704                         err = br_set_port_state(p, nla_get_u8(protinfo));
705                         spin_unlock_bh(&p->br->lock);
706                 }
707                 if (err)
708                         goto out;
709         }
710 
711         if (afspec) {
712                 err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
713                                 afspec, RTM_SETLINK);
714         }
715 
716         if (err == 0)
717                 br_ifinfo_notify(RTM_NEWLINK, p);
718 out:
719         return err;
720 }
721 
722 /* Delete port information */
723 int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
724 {
725         struct nlattr *afspec;
726         struct net_bridge_port *p;
727         int err = 0;
728 
729         afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
730         if (!afspec)
731                 return 0;
732 
733         p = br_port_get_rtnl(dev);
734         /* We want to accept dev as bridge itself as well */
735         if (!p && !(dev->priv_flags & IFF_EBRIDGE))
736                 return -EINVAL;
737 
738         err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
739                         afspec, RTM_DELLINK);
740         if (err == 0)
741                 /* Send RTM_NEWLINK because userspace
742                  * expects RTM_NEWLINK for vlan dels
743                  */
744                 br_ifinfo_notify(RTM_NEWLINK, p);
745 
746         return err;
747 }
748 static int br_validate(struct nlattr *tb[], struct nlattr *data[])
749 {
750         if (tb[IFLA_ADDRESS]) {
751                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
752                         return -EINVAL;
753                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
754                         return -EADDRNOTAVAIL;
755         }
756 
757         if (!data)
758                 return 0;
759 
760 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
761         if (data[IFLA_BR_VLAN_PROTOCOL]) {
762                 switch (nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL])) {
763                 case htons(ETH_P_8021Q):
764                 case htons(ETH_P_8021AD):
765                         break;
766                 default:
767                         return -EPROTONOSUPPORT;
768                 }
769         }
770 #endif
771 
772         return 0;
773 }
774 
775 static int br_dev_newlink(struct net *src_net, struct net_device *dev,
776                           struct nlattr *tb[], struct nlattr *data[])
777 {
778         struct net_bridge *br = netdev_priv(dev);
779 
780         if (tb[IFLA_ADDRESS]) {
781                 spin_lock_bh(&br->lock);
782                 br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
783                 spin_unlock_bh(&br->lock);
784         }
785 
786         return register_netdevice(dev);
787 }
788 
789 static int br_port_slave_changelink(struct net_device *brdev,
790                                     struct net_device *dev,
791                                     struct nlattr *tb[],
792                                     struct nlattr *data[])
793 {
794         struct net_bridge *br = netdev_priv(brdev);
795         int ret;
796 
797         if (!data)
798                 return 0;
799 
800         spin_lock_bh(&br->lock);
801         ret = br_setport(br_port_get_rtnl(dev), data);
802         spin_unlock_bh(&br->lock);
803 
804         return ret;
805 }
806 
807 static int br_port_fill_slave_info(struct sk_buff *skb,
808                                    const struct net_device *brdev,
809                                    const struct net_device *dev)
810 {
811         return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
812 }
813 
814 static size_t br_port_get_slave_size(const struct net_device *brdev,
815                                      const struct net_device *dev)
816 {
817         return br_port_info_size();
818 }
819 
820 static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
821         [IFLA_BR_FORWARD_DELAY] = { .type = NLA_U32 },
822         [IFLA_BR_HELLO_TIME]    = { .type = NLA_U32 },
823         [IFLA_BR_MAX_AGE]       = { .type = NLA_U32 },
824         [IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
825         [IFLA_BR_STP_STATE] = { .type = NLA_U32 },
826         [IFLA_BR_PRIORITY] = { .type = NLA_U16 },
827         [IFLA_BR_VLAN_FILTERING] = { .type = NLA_U8 },
828         [IFLA_BR_VLAN_PROTOCOL] = { .type = NLA_U16 },
829         [IFLA_BR_GROUP_FWD_MASK] = { .type = NLA_U16 },
830         [IFLA_BR_GROUP_ADDR] = { .type = NLA_BINARY,
831                                  .len  = ETH_ALEN },
832         [IFLA_BR_MCAST_ROUTER] = { .type = NLA_U8 },
833         [IFLA_BR_MCAST_SNOOPING] = { .type = NLA_U8 },
834         [IFLA_BR_MCAST_QUERY_USE_IFADDR] = { .type = NLA_U8 },
835         [IFLA_BR_MCAST_QUERIER] = { .type = NLA_U8 },
836         [IFLA_BR_MCAST_HASH_ELASTICITY] = { .type = NLA_U32 },
837         [IFLA_BR_MCAST_HASH_MAX] = { .type = NLA_U32 },
838         [IFLA_BR_MCAST_LAST_MEMBER_CNT] = { .type = NLA_U32 },
839         [IFLA_BR_MCAST_STARTUP_QUERY_CNT] = { .type = NLA_U32 },
840         [IFLA_BR_MCAST_LAST_MEMBER_INTVL] = { .type = NLA_U64 },
841         [IFLA_BR_MCAST_MEMBERSHIP_INTVL] = { .type = NLA_U64 },
842         [IFLA_BR_MCAST_QUERIER_INTVL] = { .type = NLA_U64 },
843         [IFLA_BR_MCAST_QUERY_INTVL] = { .type = NLA_U64 },
844         [IFLA_BR_MCAST_QUERY_RESPONSE_INTVL] = { .type = NLA_U64 },
845         [IFLA_BR_MCAST_STARTUP_QUERY_INTVL] = { .type = NLA_U64 },
846         [IFLA_BR_NF_CALL_IPTABLES] = { .type = NLA_U8 },
847         [IFLA_BR_NF_CALL_IP6TABLES] = { .type = NLA_U8 },
848         [IFLA_BR_NF_CALL_ARPTABLES] = { .type = NLA_U8 },
849         [IFLA_BR_VLAN_DEFAULT_PVID] = { .type = NLA_U16 },
850 };
851 
852 static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
853                          struct nlattr *data[])
854 {
855         struct net_bridge *br = netdev_priv(brdev);
856         int err;
857 
858         if (!data)
859                 return 0;
860 
861         if (data[IFLA_BR_FORWARD_DELAY]) {
862                 err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
863                 if (err)
864                         return err;
865         }
866 
867         if (data[IFLA_BR_HELLO_TIME]) {
868                 err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
869                 if (err)
870                         return err;
871         }
872 
873         if (data[IFLA_BR_MAX_AGE]) {
874                 err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
875                 if (err)
876                         return err;
877         }
878 
879         if (data[IFLA_BR_AGEING_TIME]) {
880                 err = br_set_ageing_time(br, nla_get_u32(data[IFLA_BR_AGEING_TIME]));
881                 if (err)
882                         return err;
883         }
884 
885         if (data[IFLA_BR_STP_STATE]) {
886                 u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);
887 
888                 br_stp_set_enabled(br, stp_enabled);
889         }
890 
891         if (data[IFLA_BR_PRIORITY]) {
892                 u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);
893 
894                 br_stp_set_bridge_priority(br, priority);
895         }
896 
897         if (data[IFLA_BR_VLAN_FILTERING]) {
898                 u8 vlan_filter = nla_get_u8(data[IFLA_BR_VLAN_FILTERING]);
899 
900                 err = __br_vlan_filter_toggle(br, vlan_filter);
901                 if (err)
902                         return err;
903         }
904 
905 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
906         if (data[IFLA_BR_VLAN_PROTOCOL]) {
907                 __be16 vlan_proto = nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL]);
908 
909                 err = __br_vlan_set_proto(br, vlan_proto);
910                 if (err)
911                         return err;
912         }
913 
914         if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
915                 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
916 
917                 err = __br_vlan_set_default_pvid(br, defpvid);
918                 if (err)
919                         return err;
920         }
921 #endif
922 
923         if (data[IFLA_BR_GROUP_FWD_MASK]) {
924                 u16 fwd_mask = nla_get_u16(data[IFLA_BR_GROUP_FWD_MASK]);
925 
926                 if (fwd_mask & BR_GROUPFWD_RESTRICTED)
927                         return -EINVAL;
928                 br->group_fwd_mask = fwd_mask;
929         }
930 
931         if (data[IFLA_BR_GROUP_ADDR]) {
932                 u8 new_addr[ETH_ALEN];
933 
934                 if (nla_len(data[IFLA_BR_GROUP_ADDR]) != ETH_ALEN)
935                         return -EINVAL;
936                 memcpy(new_addr, nla_data(data[IFLA_BR_GROUP_ADDR]), ETH_ALEN);
937                 if (!is_link_local_ether_addr(new_addr))
938                         return -EINVAL;
939                 if (new_addr[5] == 1 ||         /* 802.3x Pause address */
940                     new_addr[5] == 2 ||         /* 802.3ad Slow protocols */
941                     new_addr[5] == 3)           /* 802.1X PAE address */
942                         return -EINVAL;
943                 spin_lock_bh(&br->lock);
944                 memcpy(br->group_addr, new_addr, sizeof(br->group_addr));
945                 spin_unlock_bh(&br->lock);
946                 br->group_addr_set = true;
947                 br_recalculate_fwd_mask(br);
948         }
949 
950         if (data[IFLA_BR_FDB_FLUSH])
951                 br_fdb_flush(br);
952 
953 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
954         if (data[IFLA_BR_MCAST_ROUTER]) {
955                 u8 multicast_router = nla_get_u8(data[IFLA_BR_MCAST_ROUTER]);
956 
957                 err = br_multicast_set_router(br, multicast_router);
958                 if (err)
959                         return err;
960         }
961 
962         if (data[IFLA_BR_MCAST_SNOOPING]) {
963                 u8 mcast_snooping = nla_get_u8(data[IFLA_BR_MCAST_SNOOPING]);
964 
965                 err = br_multicast_toggle(br, mcast_snooping);
966                 if (err)
967                         return err;
968         }
969 
970         if (data[IFLA_BR_MCAST_QUERY_USE_IFADDR]) {
971                 u8 val;
972 
973                 val = nla_get_u8(data[IFLA_BR_MCAST_QUERY_USE_IFADDR]);
974                 br->multicast_query_use_ifaddr = !!val;
975         }
976 
977         if (data[IFLA_BR_MCAST_QUERIER]) {
978                 u8 mcast_querier = nla_get_u8(data[IFLA_BR_MCAST_QUERIER]);
979 
980                 err = br_multicast_set_querier(br, mcast_querier);
981                 if (err)
982                         return err;
983         }
984 
985         if (data[IFLA_BR_MCAST_HASH_ELASTICITY]) {
986                 u32 val = nla_get_u32(data[IFLA_BR_MCAST_HASH_ELASTICITY]);
987 
988                 br->hash_elasticity = val;
989         }
990 
991         if (data[IFLA_BR_MCAST_HASH_MAX]) {
992                 u32 hash_max = nla_get_u32(data[IFLA_BR_MCAST_HASH_MAX]);
993 
994                 err = br_multicast_set_hash_max(br, hash_max);
995                 if (err)
996                         return err;
997         }
998 
999         if (data[IFLA_BR_MCAST_LAST_MEMBER_CNT]) {
1000                 u32 val = nla_get_u32(data[IFLA_BR_MCAST_LAST_MEMBER_CNT]);
1001 
1002                 br->multicast_last_member_count = val;
1003         }
1004 
1005         if (data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]) {
1006                 u32 val = nla_get_u32(data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]);
1007 
1008                 br->multicast_startup_query_count = val;
1009         }
1010 
1011         if (data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]) {
1012                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]);
1013 
1014                 br->multicast_last_member_interval = clock_t_to_jiffies(val);
1015         }
1016 
1017         if (data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]) {
1018                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]);
1019 
1020                 br->multicast_membership_interval = clock_t_to_jiffies(val);
1021         }
1022 
1023         if (data[IFLA_BR_MCAST_QUERIER_INTVL]) {
1024                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERIER_INTVL]);
1025 
1026                 br->multicast_querier_interval = clock_t_to_jiffies(val);
1027         }
1028 
1029         if (data[IFLA_BR_MCAST_QUERY_INTVL]) {
1030                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_INTVL]);
1031 
1032                 br->multicast_query_interval = clock_t_to_jiffies(val);
1033         }
1034 
1035         if (data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]) {
1036                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]);
1037 
1038                 br->multicast_query_response_interval = clock_t_to_jiffies(val);
1039         }
1040 
1041         if (data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]) {
1042                 u64 val = nla_get_u64(data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]);
1043 
1044                 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
1045         }
1046 #endif
1047 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1048         if (data[IFLA_BR_NF_CALL_IPTABLES]) {
1049                 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IPTABLES]);
1050 
1051                 br->nf_call_iptables = val ? true : false;
1052         }
1053 
1054         if (data[IFLA_BR_NF_CALL_IP6TABLES]) {
1055                 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IP6TABLES]);
1056 
1057                 br->nf_call_ip6tables = val ? true : false;
1058         }
1059 
1060         if (data[IFLA_BR_NF_CALL_ARPTABLES]) {
1061                 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_ARPTABLES]);
1062 
1063                 br->nf_call_arptables = val ? true : false;
1064         }
1065 #endif
1066 
1067         return 0;
1068 }
1069 
1070 static size_t br_get_size(const struct net_device *brdev)
1071 {
1072         return nla_total_size(sizeof(u32)) +    /* IFLA_BR_FORWARD_DELAY  */
1073                nla_total_size(sizeof(u32)) +    /* IFLA_BR_HELLO_TIME */
1074                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MAX_AGE */
1075                nla_total_size(sizeof(u32)) +    /* IFLA_BR_AGEING_TIME */
1076                nla_total_size(sizeof(u32)) +    /* IFLA_BR_STP_STATE */
1077                nla_total_size(sizeof(u16)) +    /* IFLA_BR_PRIORITY */
1078                nla_total_size(sizeof(u8)) +     /* IFLA_BR_VLAN_FILTERING */
1079 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
1080                nla_total_size(sizeof(__be16)) + /* IFLA_BR_VLAN_PROTOCOL */
1081                nla_total_size(sizeof(u16)) +    /* IFLA_BR_VLAN_DEFAULT_PVID */
1082 #endif
1083                nla_total_size(sizeof(u16)) +    /* IFLA_BR_GROUP_FWD_MASK */
1084                nla_total_size(sizeof(struct ifla_bridge_id)) +   /* IFLA_BR_ROOT_ID */
1085                nla_total_size(sizeof(struct ifla_bridge_id)) +   /* IFLA_BR_BRIDGE_ID */
1086                nla_total_size(sizeof(u16)) +    /* IFLA_BR_ROOT_PORT */
1087                nla_total_size(sizeof(u32)) +    /* IFLA_BR_ROOT_PATH_COST */
1088                nla_total_size(sizeof(u8)) +     /* IFLA_BR_TOPOLOGY_CHANGE */
1089                nla_total_size(sizeof(u8)) +     /* IFLA_BR_TOPOLOGY_CHANGE_DETECTED */
1090                nla_total_size(sizeof(u64)) +    /* IFLA_BR_HELLO_TIMER */
1091                nla_total_size(sizeof(u64)) +    /* IFLA_BR_TCN_TIMER */
1092                nla_total_size(sizeof(u64)) +    /* IFLA_BR_TOPOLOGY_CHANGE_TIMER */
1093                nla_total_size(sizeof(u64)) +    /* IFLA_BR_GC_TIMER */
1094                nla_total_size(ETH_ALEN) +       /* IFLA_BR_GROUP_ADDR */
1095 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1096                nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_ROUTER */
1097                nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_SNOOPING */
1098                nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_QUERY_USE_IFADDR */
1099                nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_QUERIER */
1100                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_HASH_ELASTICITY */
1101                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_HASH_MAX */
1102                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_LAST_MEMBER_CNT */
1103                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_STARTUP_QUERY_CNT */
1104                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_LAST_MEMBER_INTVL */
1105                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_MEMBERSHIP_INTVL */
1106                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_QUERIER_INTVL */
1107                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_QUERY_INTVL */
1108                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_QUERY_RESPONSE_INTVL */
1109                nla_total_size(sizeof(u64)) +    /* IFLA_BR_MCAST_STARTUP_QUERY_INTVL */
1110 #endif
1111 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1112                nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_IPTABLES */
1113                nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_IP6TABLES */
1114                nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_ARPTABLES */
1115 #endif
1116                0;
1117 }
1118 
1119 static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
1120 {
1121         struct net_bridge *br = netdev_priv(brdev);
1122         u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
1123         u32 hello_time = jiffies_to_clock_t(br->hello_time);
1124         u32 age_time = jiffies_to_clock_t(br->max_age);
1125         u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
1126         u32 stp_enabled = br->stp_enabled;
1127         u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
1128         u8 vlan_enabled = br_vlan_enabled(br);
1129         u64 clockval;
1130 
1131         clockval = br_timer_value(&br->hello_timer);
1132         if (nla_put_u64(skb, IFLA_BR_HELLO_TIMER, clockval))
1133                 return -EMSGSIZE;
1134         clockval = br_timer_value(&br->tcn_timer);
1135         if (nla_put_u64(skb, IFLA_BR_TCN_TIMER, clockval))
1136                 return -EMSGSIZE;
1137         clockval = br_timer_value(&br->topology_change_timer);
1138         if (nla_put_u64(skb, IFLA_BR_TOPOLOGY_CHANGE_TIMER, clockval))
1139                 return -EMSGSIZE;
1140         clockval = br_timer_value(&br->gc_timer);
1141         if (nla_put_u64(skb, IFLA_BR_GC_TIMER, clockval))
1142                 return -EMSGSIZE;
1143 
1144         if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
1145             nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
1146             nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
1147             nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
1148             nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
1149             nla_put_u16(skb, IFLA_BR_PRIORITY, priority) ||
1150             nla_put_u8(skb, IFLA_BR_VLAN_FILTERING, vlan_enabled) ||
1151             nla_put_u16(skb, IFLA_BR_GROUP_FWD_MASK, br->group_fwd_mask) ||
1152             nla_put(skb, IFLA_BR_BRIDGE_ID, sizeof(struct ifla_bridge_id),
1153                     &br->bridge_id) ||
1154             nla_put(skb, IFLA_BR_ROOT_ID, sizeof(struct ifla_bridge_id),
1155                     &br->designated_root) ||
1156             nla_put_u16(skb, IFLA_BR_ROOT_PORT, br->root_port) ||
1157             nla_put_u32(skb, IFLA_BR_ROOT_PATH_COST, br->root_path_cost) ||
1158             nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE, br->topology_change) ||
1159             nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
1160                        br->topology_change_detected) ||
1161             nla_put(skb, IFLA_BR_GROUP_ADDR, ETH_ALEN, br->group_addr))
1162                 return -EMSGSIZE;
1163 
1164 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
1165         if (nla_put_be16(skb, IFLA_BR_VLAN_PROTOCOL, br->vlan_proto) ||
1166             nla_put_u16(skb, IFLA_BR_VLAN_DEFAULT_PVID, br->default_pvid))
1167                 return -EMSGSIZE;
1168 #endif
1169 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1170         if (nla_put_u8(skb, IFLA_BR_MCAST_ROUTER, br->multicast_router) ||
1171             nla_put_u8(skb, IFLA_BR_MCAST_SNOOPING, !br->multicast_disabled) ||
1172             nla_put_u8(skb, IFLA_BR_MCAST_QUERY_USE_IFADDR,
1173                        br->multicast_query_use_ifaddr) ||
1174             nla_put_u8(skb, IFLA_BR_MCAST_QUERIER, br->multicast_querier) ||
1175             nla_put_u32(skb, IFLA_BR_MCAST_HASH_ELASTICITY,
1176                         br->hash_elasticity) ||
1177             nla_put_u32(skb, IFLA_BR_MCAST_HASH_MAX, br->hash_max) ||
1178             nla_put_u32(skb, IFLA_BR_MCAST_LAST_MEMBER_CNT,
1179                         br->multicast_last_member_count) ||
1180             nla_put_u32(skb, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
1181                         br->multicast_startup_query_count))
1182                 return -EMSGSIZE;
1183 
1184         clockval = jiffies_to_clock_t(br->multicast_last_member_interval);
1185         if (nla_put_u64(skb, IFLA_BR_MCAST_LAST_MEMBER_INTVL, clockval))
1186                 return -EMSGSIZE;
1187         clockval = jiffies_to_clock_t(br->multicast_membership_interval);
1188         if (nla_put_u64(skb, IFLA_BR_MCAST_MEMBERSHIP_INTVL, clockval))
1189                 return -EMSGSIZE;
1190         clockval = jiffies_to_clock_t(br->multicast_querier_interval);
1191         if (nla_put_u64(skb, IFLA_BR_MCAST_QUERIER_INTVL, clockval))
1192                 return -EMSGSIZE;
1193         clockval = jiffies_to_clock_t(br->multicast_query_interval);
1194         if (nla_put_u64(skb, IFLA_BR_MCAST_QUERY_INTVL, clockval))
1195                 return -EMSGSIZE;
1196         clockval = jiffies_to_clock_t(br->multicast_query_response_interval);
1197         if (nla_put_u64(skb, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, clockval))
1198                 return -EMSGSIZE;
1199         clockval = jiffies_to_clock_t(br->multicast_startup_query_interval);
1200         if (nla_put_u64(skb, IFLA_BR_MCAST_STARTUP_QUERY_INTVL, clockval))
1201                 return -EMSGSIZE;
1202 #endif
1203 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1204         if (nla_put_u8(skb, IFLA_BR_NF_CALL_IPTABLES,
1205                        br->nf_call_iptables ? 1 : 0) ||
1206             nla_put_u8(skb, IFLA_BR_NF_CALL_IP6TABLES,
1207                        br->nf_call_ip6tables ? 1 : 0) ||
1208             nla_put_u8(skb, IFLA_BR_NF_CALL_ARPTABLES,
1209                        br->nf_call_arptables ? 1 : 0))
1210                 return -EMSGSIZE;
1211 #endif
1212 
1213         return 0;
1214 }
1215 
1216 
1217 static struct rtnl_af_ops br_af_ops __read_mostly = {
1218         .family                 = AF_BRIDGE,
1219         .get_link_af_size       = br_get_link_af_size_filtered,
1220 };
1221 
1222 struct rtnl_link_ops br_link_ops __read_mostly = {
1223         .kind                   = "bridge",
1224         .priv_size              = sizeof(struct net_bridge),
1225         .setup                  = br_dev_setup,
1226         .maxtype                = IFLA_BR_MAX,
1227         .policy                 = br_policy,
1228         .validate               = br_validate,
1229         .newlink                = br_dev_newlink,
1230         .changelink             = br_changelink,
1231         .dellink                = br_dev_delete,
1232         .get_size               = br_get_size,
1233         .fill_info              = br_fill_info,
1234 
1235         .slave_maxtype          = IFLA_BRPORT_MAX,
1236         .slave_policy           = br_port_policy,
1237         .slave_changelink       = br_port_slave_changelink,
1238         .get_slave_size         = br_port_get_slave_size,
1239         .fill_slave_info        = br_port_fill_slave_info,
1240 };
1241 
1242 int __init br_netlink_init(void)
1243 {
1244         int err;
1245 
1246         br_mdb_init();
1247         rtnl_af_register(&br_af_ops);
1248 
1249         err = rtnl_link_register(&br_link_ops);
1250         if (err)
1251                 goto out_af;
1252 
1253         return 0;
1254 
1255 out_af:
1256         rtnl_af_unregister(&br_af_ops);
1257         br_mdb_uninit();
1258         return err;
1259 }
1260 
1261 void br_netlink_fini(void)
1262 {
1263         br_mdb_uninit();
1264         rtnl_af_unregister(&br_af_ops);
1265         rtnl_link_unregister(&br_link_ops);
1266 }
1267 

~ [ 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