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