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