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