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