net/bridge/br_netlink.c

   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 <net/switchdev.h>
  20 #include <uapi/linux/if_bridge.h>
  21
  22 #include "br_private.h"
  23 #include "br_private_stp.h"
  24
  25 static inline size_t br_port_info_size(void)
  26 {
  27         return nla_total_size(1)        /* IFLA_BRPORT_STATE  */
  28                 + nla_total_size(2)     /* IFLA_BRPORT_PRIORITY */
  29                 + nla_total_size(4)     /* IFLA_BRPORT_COST */
  30                 + nla_total_size(1)     /* IFLA_BRPORT_MODE */
  31                 + nla_total_size(1)     /* IFLA_BRPORT_GUARD */
  32                 + nla_total_size(1)     /* IFLA_BRPORT_PROTECT */
  33                 + nla_total_size(1)     /* IFLA_BRPORT_FAST_LEAVE */
  34                 + nla_total_size(1)     /* IFLA_BRPORT_LEARNING */
  35                 + nla_total_size(1)     /* IFLA_BRPORT_UNICAST_FLOOD */
  36                 + 0;
  37 }
  38
  39 static inline size_t br_nlmsg_size(void)
  40 {
  41         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  42                 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
  43                 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  44                 + nla_total_size(4) /* IFLA_MASTER */
  45                 + nla_total_size(4) /* IFLA_MTU */
  46                 + nla_total_size(4) /* IFLA_LINK */
  47                 + nla_total_size(1) /* IFLA_OPERSTATE */
  48                 + nla_total_size(br_port_info_size()); /* IFLA_PROTINFO */
  49 }
  50
  51 static int br_port_fill_attrs(struct sk_buff *skb,
  52                               const struct net_bridge_port *p)
  53 {
  54         u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
  55
  56         if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
  57             nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
  58             nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
  59             nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
  60             nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
  61             nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
  62             nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
  63             nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
  64             nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)) ||
  65             nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)))
  66                 return -EMSGSIZE;
  67
  68         return 0;
  69 }
  70
  71 static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
  72                                     u16 vid_end, u16 flags)
  73 {
  74         struct  bridge_vlan_info vinfo;
  75
  76         if ((vid_end - vid_start) > 0) {
  77                 /* add range to skb */
  78                 vinfo.vid = vid_start;
  79                 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
  80                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
  81                             sizeof(vinfo), &vinfo))
  82                         goto nla_put_failure;
  83
  84                 vinfo.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN;
  85
  86                 vinfo.vid = vid_end;
  87                 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
  88                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
  89                             sizeof(vinfo), &vinfo))
  90                         goto nla_put_failure;
  91         } else {
  92                 vinfo.vid = vid_start;
  93                 vinfo.flags = flags;
  94                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
  95                             sizeof(vinfo), &vinfo))
  96                         goto nla_put_failure;
  97         }
  98
  99         return 0;
 100
 101 nla_put_failure:
 102         return -EMSGSIZE;
 103 }
 104
 105 static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
 106                                          const struct net_port_vlans *pv)
 107 {
 108         u16 vid_range_start = 0, vid_range_end = 0;
 109         u16 vid_range_flags = 0;
 110         u16 pvid, vid, flags;
 111         int err = 0;
 112
 113         /* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
 114          * and mark vlan info with begin and end flags
 115          * if vlaninfo represents a range
 116          */
 117         pvid = br_get_pvid(pv);
 118         for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
 119                 flags = 0;
 120                 if (vid == pvid)
 121                         flags |= BRIDGE_VLAN_INFO_PVID;
 122
 123                 if (test_bit(vid, pv->untagged_bitmap))
 124                         flags |= BRIDGE_VLAN_INFO_UNTAGGED;
 125
 126                 if (vid_range_start == 0) {
 127                         goto initvars;
 128                 } else if ((vid - vid_range_end) == 1 &&
 129                         flags == vid_range_flags) {
 130                         vid_range_end = vid;
 131                         continue;
 132                 } else {
 133                         err = br_fill_ifvlaninfo_range(skb, vid_range_start,
 134                                                        vid_range_end,
 135                                                        vid_range_flags);
 136                         if (err)
 137                                 return err;
 138                 }
 139
 140 initvars:
 141                 vid_range_start = vid;
 142                 vid_range_end = vid;
 143                 vid_range_flags = flags;
 144         }
 145
 146         if (vid_range_start != 0) {
 147                 /* Call it once more to send any left over vlans */
 148                 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
 149                                                vid_range_end,
 150                                                vid_range_flags);
 151                 if (err)
 152                         return err;
 153         }
 154
 155         return 0;
 156 }
 157
 158 static int br_fill_ifvlaninfo(struct sk_buff *skb,
 159                               const struct net_port_vlans *pv)
 160 {
 161         struct bridge_vlan_info vinfo;
 162         u16 pvid, vid;
 163
 164         pvid = br_get_pvid(pv);
 165         for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
 166                 vinfo.vid = vid;
 167                 vinfo.flags = 0;
 168                 if (vid == pvid)
 169                         vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
 170
 171                 if (test_bit(vid, pv->untagged_bitmap))
 172                         vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
 173
 174                 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
 175                             sizeof(vinfo), &vinfo))
 176                         goto nla_put_failure;
 177         }
 178
 179         return 0;
 180
 181 nla_put_failure:
 182         return -EMSGSIZE;
 183 }
 184
 185 /*
 186  * Create one netlink message for one interface
 187  * Contains port and master info as well as carrier and bridge state.
 188  */
 189 static int br_fill_ifinfo(struct sk_buff *skb,
 190                           const struct net_bridge_port *port,
 191                           u32 pid, u32 seq, int event, unsigned int flags,
 192                           u32 filter_mask, const struct net_device *dev)
 193 {
 194         const struct net_bridge *br;
 195         struct ifinfomsg *hdr;
 196         struct nlmsghdr *nlh;
 197         u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
 198
 199         if (port)
 200                 br = port->br;
 201         else
 202                 br = netdev_priv(dev);
 203
 204         br_debug(br, "br_fill_info event %d port %s master %s\n",
 205                      event, dev->name, br->dev->name);
 206
 207         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
 208         if (nlh == NULL)
 209                 return -EMSGSIZE;
 210
 211         hdr = nlmsg_data(nlh);
 212         hdr->ifi_family = AF_BRIDGE;
 213         hdr->__ifi_pad = 0;
 214         hdr->ifi_type = dev->type;
 215         hdr->ifi_index = dev->ifindex;
 216         hdr->ifi_flags = dev_get_flags(dev);
 217         hdr->ifi_change = 0;
 218
 219         if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
 220             nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
 221             nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
 222             nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
 223             (dev->addr_len &&
 224              nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
 225             (dev->ifindex != dev->iflink &&
 226              nla_put_u32(skb, IFLA_LINK, dev->iflink)))
 227                 goto nla_put_failure;
 228
 229         if (event == RTM_NEWLINK && port) {
 230                 struct nlattr *nest
 231                         = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
 232
 233                 if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
 234                         goto nla_put_failure;
 235                 nla_nest_end(skb, nest);
 236         }
 237
 238         /* Check if  the VID information is requested */
 239         if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
 240             (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
 241                 const struct net_port_vlans *pv;
 242                 struct nlattr *af;
 243                 int err;
 244
 245                 if (port)
 246                         pv = nbp_get_vlan_info(port);
 247                 else
 248                         pv = br_get_vlan_info(br);
 249
 250                 if (!pv || bitmap_empty(pv->vlan_bitmap, VLAN_N_VID))
 251                         goto done;
 252
 253                 af = nla_nest_start(skb, IFLA_AF_SPEC);
 254                 if (!af)
 255                         goto nla_put_failure;
 256
 257                 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
 258                         err = br_fill_ifvlaninfo_compressed(skb, pv);
 259                 else
 260                         err = br_fill_ifvlaninfo(skb, pv);
 261                 if (err)
 262                         goto nla_put_failure;
 263                 nla_nest_end(skb, af);
 264         }
 265
 266 done:
 267         nlmsg_end(skb, nlh);
 268         return 0;
 269
 270 nla_put_failure:
 271         nlmsg_cancel(skb, nlh);
 272         return -EMSGSIZE;
 273 }
 274
 275 /*
 276  * Notify listeners of a change in port information
 277  */
 278 void br_ifinfo_notify(int event, struct net_bridge_port *port)
 279 {
 280         struct net *net;
 281         struct sk_buff *skb;
 282         int err = -ENOBUFS;
 283
 284         if (!port)
 285                 return;
 286
 287         net = dev_net(port->dev);
 288         br_debug(port->br, "port %u(%s) event %d\n",
 289                  (unsigned int)port->port_no, port->dev->name, event);
 290
 291         skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC);
 292         if (skb == NULL)
 293                 goto errout;
 294
 295         err = br_fill_ifinfo(skb, port, 0, 0, event, 0, 0, port->dev);
 296         if (err < 0) {
 297                 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
 298                 WARN_ON(err == -EMSGSIZE);
 299                 kfree_skb(skb);
 300                 goto errout;
 301         }
 302         rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
 303         return;
 304 errout:
 305         rtnl_set_sk_err(net, RTNLGRP_LINK, err);
 306 }
 307
 308
 309 /*
 310  * Dump information about all ports, in response to GETLINK
 311  */
 312 int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
 313                struct net_device *dev, u32 filter_mask)
 314 {
 315         struct net_bridge_port *port = br_port_get_rtnl(dev);
 316
 317         if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
 318             !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
 319                 return 0;
 320
 321         return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, NLM_F_MULTI,
 322                               filter_mask, dev);
 323 }
 324
 325 static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
 326                         int cmd, struct bridge_vlan_info *vinfo)
 327 {
 328         int err = 0;
 329
 330         switch (cmd) {
 331         case RTM_SETLINK:
 332                 if (p) {
 333                         err = nbp_vlan_add(p, vinfo->vid, vinfo->flags);
 334                         if (err)
 335                                 break;
 336
 337                         if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
 338                                 err = br_vlan_add(p->br, vinfo->vid,
 339                                                   vinfo->flags);
 340                 } else {
 341                         err = br_vlan_add(br, vinfo->vid, vinfo->flags);
 342                 }
 343                 break;
 344
 345         case RTM_DELLINK:
 346                 if (p) {
 347                         nbp_vlan_delete(p, vinfo->vid);
 348                         if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
 349                                 br_vlan_delete(p->br, vinfo->vid);
 350                 } else {
 351                         br_vlan_delete(br, vinfo->vid);
 352                 }
 353                 break;
 354         }
 355
 356         return err;
 357 }
 358
 359 static int br_afspec(struct net_bridge *br,
 360                      struct net_bridge_port *p,
 361                      struct nlattr *af_spec,
 362                      int cmd)
 363 {
 364         struct bridge_vlan_info *vinfo_start = NULL;
 365         struct bridge_vlan_info *vinfo = NULL;
 366         struct nlattr *attr;
 367         int err = 0;
 368         int rem;
 369
 370         nla_for_each_nested(attr, af_spec, rem) {
 371                 if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
 372                         continue;
 373                 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
 374                         return -EINVAL;
 375                 vinfo = nla_data(attr);
 376                 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
 377                         if (vinfo_start)
 378                                 return -EINVAL;
 379                         vinfo_start = vinfo;
 380                         continue;
 381                 }
 382
 383                 if (vinfo_start) {
 384                         struct bridge_vlan_info tmp_vinfo;
 385                         int v;
 386
 387                         if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
 388                                 return -EINVAL;
 389
 390                         if (vinfo->vid <= vinfo_start->vid)
 391                                 return -EINVAL;
 392
 393                         memcpy(&tmp_vinfo, vinfo_start,
 394                                sizeof(struct bridge_vlan_info));
 395
 396                         for (v = vinfo_start->vid; v <= vinfo->vid; v++) {
 397                                 tmp_vinfo.vid = v;
 398                                 err = br_vlan_info(br, p, cmd, &tmp_vinfo);
 399                                 if (err)
 400                                         break;
 401                         }
 402                         vinfo_start = NULL;
 403                 } else {
 404                         err = br_vlan_info(br, p, cmd, vinfo);
 405                 }
 406                 if (err)
 407                         break;
 408         }
 409
 410         return err;
 411 }
 412
 413 static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
 414         [IFLA_BRPORT_STATE]     = { .type = NLA_U8 },
 415         [IFLA_BRPORT_COST]      = { .type = NLA_U32 },
 416         [IFLA_BRPORT_PRIORITY]  = { .type = NLA_U16 },
 417         [IFLA_BRPORT_MODE]      = { .type = NLA_U8 },
 418         [IFLA_BRPORT_GUARD]     = { .type = NLA_U8 },
 419         [IFLA_BRPORT_PROTECT]   = { .type = NLA_U8 },
 420         [IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
 421         [IFLA_BRPORT_LEARNING]  = { .type = NLA_U8 },
 422         [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
 423 };
 424
 425 /* Change the state of the port and notify spanning tree */
 426 static int br_set_port_state(struct net_bridge_port *p, u8 state)
 427 {
 428         if (state > BR_STATE_BLOCKING)
 429                 return -EINVAL;
 430
 431         /* if kernel STP is running, don't allow changes */
 432         if (p->br->stp_enabled == BR_KERNEL_STP)
 433                 return -EBUSY;
 434
 435         /* if device is not up, change is not allowed
 436          * if link is not present, only allowable state is disabled
 437          */
 438         if (!netif_running(p->dev) ||
 439             (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
 440                 return -ENETDOWN;
 441
 442         br_set_state(p, state);
 443         br_log_state(p);
 444         br_port_state_selection(p->br);
 445         return 0;
 446 }
 447
 448 /* Set/clear or port flags based on attribute */
 449 static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
 450                            int attrtype, unsigned long mask)
 451 {
 452         if (tb[attrtype]) {
 453                 u8 flag = nla_get_u8(tb[attrtype]);
 454                 if (flag)
 455                         p->flags |= mask;
 456                 else
 457                         p->flags &= ~mask;
 458         }
 459 }
 460
 461 /* Process bridge protocol info on port */
 462 static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
 463 {
 464         int err;
 465         unsigned long old_flags = p->flags;
 466
 467         br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
 468         br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
 469         br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
 470         br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
 471         br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
 472         br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
 473         br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
 474
 475         if (tb[IFLA_BRPORT_COST]) {
 476                 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
 477                 if (err)
 478                         return err;
 479         }
 480
 481         if (tb[IFLA_BRPORT_PRIORITY]) {
 482                 err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
 483                 if (err)
 484                         return err;
 485         }
 486
 487         if (tb[IFLA_BRPORT_STATE]) {
 488                 err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
 489                 if (err)
 490                         return err;
 491         }
 492
 493         br_port_flags_change(p, old_flags ^ p->flags);
 494         return 0;
 495 }
 496
 497 /* Change state and parameters on port. */
 498 int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
 499 {
 500         struct nlattr *protinfo;
 501         struct nlattr *afspec;
 502         struct net_bridge_port *p;
 503         struct nlattr *tb[IFLA_BRPORT_MAX + 1];
 504         int err = 0, ret_offload = 0;
 505
 506         protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
 507         afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
 508         if (!protinfo && !afspec)
 509                 return 0;
 510
 511         p = br_port_get_rtnl(dev);
 512         /* We want to accept dev as bridge itself if the AF_SPEC
 513          * is set to see if someone is setting vlan info on the bridge
 514          */
 515         if (!p && !afspec)
 516                 return -EINVAL;
 517
 518         if (p && protinfo) {
 519                 if (protinfo->nla_type & NLA_F_NESTED) {
 520                         err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
 521                                                protinfo, br_port_policy);
 522                         if (err)
 523                                 return err;
 524
 525                         spin_lock_bh(&p->br->lock);
 526                         err = br_setport(p, tb);
 527                         spin_unlock_bh(&p->br->lock);
 528                 } else {
 529                         /* Binary compatibility with old RSTP */
 530                         if (nla_len(protinfo) < sizeof(u8))
 531                                 return -EINVAL;
 532
 533                         spin_lock_bh(&p->br->lock);
 534                         err = br_set_port_state(p, nla_get_u8(protinfo));
 535                         spin_unlock_bh(&p->br->lock);
 536                 }
 537                 if (err)
 538                         goto out;
 539         }
 540
 541         if (afspec) {
 542                 err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
 543                                 afspec, RTM_SETLINK);
 544         }
 545
 546         if (p && !(flags & BRIDGE_FLAGS_SELF)) {
 547                 /* set bridge attributes in hardware if supported
 548                  */
 549                 ret_offload = netdev_switch_port_bridge_setlink(dev, nlh,
 550                                                                 flags);
 551                 if (ret_offload && ret_offload != -EOPNOTSUPP)
 552                         br_warn(p->br, "error setting attrs on port %u(%s)\n",
 553                                 (unsigned int)p->port_no, p->dev->name);
 554         }
 555
 556         if (err == 0)
 557                 br_ifinfo_notify(RTM_NEWLINK, p);
 558 out:
 559         return err;
 560 }
 561
 562 /* Delete port information */
 563 int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
 564 {
 565         struct nlattr *afspec;
 566         struct net_bridge_port *p;
 567         int err = 0, ret_offload = 0;
 568
 569         afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
 570         if (!afspec)
 571                 return 0;
 572
 573         p = br_port_get_rtnl(dev);
 574         /* We want to accept dev as bridge itself as well */
 575         if (!p && !(dev->priv_flags & IFF_EBRIDGE))
 576                 return -EINVAL;
 577
 578         err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
 579                         afspec, RTM_DELLINK);
 580         if (err == 0)
 581                 /* Send RTM_NEWLINK because userspace
 582                  * expects RTM_NEWLINK for vlan dels
 583                  */
 584                 br_ifinfo_notify(RTM_NEWLINK, p);
 585
 586         if (p && !(flags & BRIDGE_FLAGS_SELF)) {
 587                 /* del bridge attributes in hardware
 588                  */
 589                 ret_offload = netdev_switch_port_bridge_dellink(dev, nlh,
 590                                                                 flags);
 591                 if (ret_offload && ret_offload != -EOPNOTSUPP)
 592                         br_warn(p->br, "error deleting attrs on port %u (%s)\n",
 593                                 (unsigned int)p->port_no, p->dev->name);
 594         }
 595
 596         return err;
 597 }
 598 static int br_validate(struct nlattr *tb[], struct nlattr *data[])
 599 {
 600         if (tb[IFLA_ADDRESS]) {
 601                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 602                         return -EINVAL;
 603                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 604                         return -EADDRNOTAVAIL;
 605         }
 606
 607         return 0;
 608 }
 609
 610 static int br_dev_newlink(struct net *src_net, struct net_device *dev,
 611                           struct nlattr *tb[], struct nlattr *data[])
 612 {
 613         struct net_bridge *br = netdev_priv(dev);
 614
 615         if (tb[IFLA_ADDRESS]) {
 616                 spin_lock_bh(&br->lock);
 617                 br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
 618                 spin_unlock_bh(&br->lock);
 619         }
 620
 621         return register_netdevice(dev);
 622 }
 623
 624 static int br_port_slave_changelink(struct net_device *brdev,
 625                                     struct net_device *dev,
 626                                     struct nlattr *tb[],
 627                                     struct nlattr *data[])
 628 {
 629         if (!data)
 630                 return 0;
 631         return br_setport(br_port_get_rtnl(dev), data);
 632 }
 633
 634 static int br_port_fill_slave_info(struct sk_buff *skb,
 635                                    const struct net_device *brdev,
 636                                    const struct net_device *dev)
 637 {
 638         return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
 639 }
 640
 641 static size_t br_port_get_slave_size(const struct net_device *brdev,
 642                                      const struct net_device *dev)
 643 {
 644         return br_port_info_size();
 645 }
 646
 647 static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
 648         [IFLA_BR_FORWARD_DELAY] = { .type = NLA_U32 },
 649         [IFLA_BR_HELLO_TIME]    = { .type = NLA_U32 },
 650         [IFLA_BR_MAX_AGE]       = { .type = NLA_U32 },
 651 };
 652
 653 static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
 654                          struct nlattr *data[])
 655 {
 656         struct net_bridge *br = netdev_priv(brdev);
 657         int err;
 658
 659         if (!data)
 660                 return 0;
 661
 662         if (data[IFLA_BR_FORWARD_DELAY]) {
 663                 err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
 664                 if (err)
 665                         return err;
 666         }
 667
 668         if (data[IFLA_BR_HELLO_TIME]) {
 669                 err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
 670                 if (err)
 671                         return err;
 672         }
 673
 674         if (data[IFLA_BR_MAX_AGE]) {
 675                 err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
 676                 if (err)
 677                         return err;
 678         }
 679
 680         return 0;
 681 }
 682
 683 static size_t br_get_size(const struct net_device *brdev)
 684 {
 685         return nla_total_size(sizeof(u32)) +    /* IFLA_BR_FORWARD_DELAY  */
 686                nla_total_size(sizeof(u32)) +    /* IFLA_BR_HELLO_TIME */
 687                nla_total_size(sizeof(u32)) +    /* IFLA_BR_MAX_AGE */
 688                0;
 689 }
 690
 691 static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
 692 {
 693         struct net_bridge *br = netdev_priv(brdev);
 694         u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
 695         u32 hello_time = jiffies_to_clock_t(br->hello_time);
 696         u32 age_time = jiffies_to_clock_t(br->max_age);
 697
 698         if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
 699             nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
 700             nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time))
 701                 return -EMSGSIZE;
 702
 703         return 0;
 704 }
 705
 706 static size_t br_get_link_af_size(const struct net_device *dev)
 707 {
 708         struct net_port_vlans *pv;
 709
 710         if (br_port_exists(dev))
 711                 pv = nbp_get_vlan_info(br_port_get_rtnl(dev));
 712         else if (dev->priv_flags & IFF_EBRIDGE)
 713                 pv = br_get_vlan_info((struct net_bridge *)netdev_priv(dev));
 714         else
 715                 return 0;
 716
 717         if (!pv)
 718                 return 0;
 719
 720         /* Each VLAN is returned in bridge_vlan_info along with flags */
 721         return pv->num_vlans * nla_total_size(sizeof(struct bridge_vlan_info));
 722 }
 723
 724 static struct rtnl_af_ops br_af_ops __read_mostly = {
 725         .family                 = AF_BRIDGE,
 726         .get_link_af_size       = br_get_link_af_size,
 727 };
 728
 729 struct rtnl_link_ops br_link_ops __read_mostly = {
 730         .kind                   = "bridge",
 731         .priv_size              = sizeof(struct net_bridge),
 732         .setup                  = br_dev_setup,
 733         .maxtype                = IFLA_BRPORT_MAX,
 734         .policy                 = br_policy,
 735         .validate               = br_validate,
 736         .newlink                = br_dev_newlink,
 737         .changelink             = br_changelink,
 738         .dellink                = br_dev_delete,
 739         .get_size               = br_get_size,
 740         .fill_info              = br_fill_info,
 741
 742         .slave_maxtype          = IFLA_BRPORT_MAX,
 743         .slave_policy           = br_port_policy,
 744         .slave_changelink       = br_port_slave_changelink,
 745         .get_slave_size         = br_port_get_slave_size,
 746         .fill_slave_info        = br_port_fill_slave_info,
 747 };
 748
 749 int __init br_netlink_init(void)
 750 {
 751         int err;
 752
 753         br_mdb_init();
 754         rtnl_af_register(&br_af_ops);
 755
 756         err = rtnl_link_register(&br_link_ops);
 757         if (err)
 758                 goto out_af;
 759
 760         return 0;
 761
 762 out_af:
 763         rtnl_af_unregister(&br_af_ops);
 764         br_mdb_uninit();
 765         return err;
 766 }
 767
 768 void br_netlink_fini(void)
 769 {
 770         br_mdb_uninit();
 771         rtnl_af_unregister(&br_af_ops);
 772         rtnl_link_unregister(&br_link_ops);
 773 }