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