drivers/net/bonding/bond_netlink.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * drivers/net/bond/bond_netlink.c - Netlink interface for bonding
   4  * Copyright (c) 2013 Jiri Pirko <[email protected]>
   5  * Copyright (c) 2013 Scott Feldman <[email protected]>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/errno.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/etherdevice.h>
  12 #include <linux/if_link.h>
  13 #include <linux/if_ether.h>
  14 #include <net/netlink.h>
  15 #include <net/rtnetlink.h>
  16 #include <net/bonding.h>
  17 #include <net/ipv6.h>
  18
  19 static size_t bond_get_slave_size(const struct net_device *bond_dev,
  20                                   const struct net_device *slave_dev)
  21 {
  22         return nla_total_size(sizeof(u8)) +     /* IFLA_BOND_SLAVE_STATE */
  23                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_SLAVE_MII_STATUS */
  24                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_SLAVE_LINK_FAILURE_COUNT */
  25                 nla_total_size(MAX_ADDR_LEN) +  /* IFLA_BOND_SLAVE_PERM_HWADDR */
  26                 nla_total_size(sizeof(u16)) +   /* IFLA_BOND_SLAVE_QUEUE_ID */
  27                 nla_total_size(sizeof(u16)) +   /* IFLA_BOND_SLAVE_AD_AGGREGATOR_ID */
  28                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE */
  29                 nla_total_size(sizeof(u16)) +   /* IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE */
  30                 nla_total_size(sizeof(s32)) +   /* IFLA_BOND_SLAVE_PRIO */
  31                 0;
  32 }
  33
  34 static int bond_fill_slave_info(struct sk_buff *skb,
  35                                 const struct net_device *bond_dev,
  36                                 const struct net_device *slave_dev)
  37 {
  38         struct slave *slave = bond_slave_get_rtnl(slave_dev);
  39
  40         if (nla_put_u8(skb, IFLA_BOND_SLAVE_STATE, bond_slave_state(slave)))
  41                 goto nla_put_failure;
  42
  43         if (nla_put_u8(skb, IFLA_BOND_SLAVE_MII_STATUS, slave->link))
  44                 goto nla_put_failure;
  45
  46         if (nla_put_u32(skb, IFLA_BOND_SLAVE_LINK_FAILURE_COUNT,
  47                         slave->link_failure_count))
  48                 goto nla_put_failure;
  49
  50         if (nla_put(skb, IFLA_BOND_SLAVE_PERM_HWADDR,
  51                     slave_dev->addr_len, slave->perm_hwaddr))
  52                 goto nla_put_failure;
  53
  54         if (nla_put_u16(skb, IFLA_BOND_SLAVE_QUEUE_ID,
  55                         READ_ONCE(slave->queue_id)))
  56                 goto nla_put_failure;
  57
  58         if (nla_put_s32(skb, IFLA_BOND_SLAVE_PRIO, slave->prio))
  59                 goto nla_put_failure;
  60
  61         if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
  62                 const struct aggregator *agg;
  63                 const struct port *ad_port;
  64
  65                 ad_port = &SLAVE_AD_INFO(slave)->port;
  66                 agg = SLAVE_AD_INFO(slave)->port.aggregator;
  67                 if (agg) {
  68                         if (nla_put_u16(skb, IFLA_BOND_SLAVE_AD_AGGREGATOR_ID,
  69                                         agg->aggregator_identifier))
  70                                 goto nla_put_failure;
  71                         if (nla_put_u8(skb,
  72                                        IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE,
  73                                        ad_port->actor_oper_port_state))
  74                                 goto nla_put_failure;
  75                         if (nla_put_u16(skb,
  76                                         IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE,
  77                                         ad_port->partner_oper.port_state))
  78                                 goto nla_put_failure;
  79                 }
  80         }
  81
  82         return 0;
  83
  84 nla_put_failure:
  85         return -EMSGSIZE;
  86 }
  87
  88 /* Limit the max delay range to 300s */
  89 static const struct netlink_range_validation delay_range = {
  90         .max = 300000,
  91 };
  92
  93 static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
  94         [IFLA_BOND_MODE]                = { .type = NLA_U8 },
  95         [IFLA_BOND_ACTIVE_SLAVE]        = { .type = NLA_U32 },
  96         [IFLA_BOND_MIIMON]              = { .type = NLA_U32 },
  97         [IFLA_BOND_UPDELAY]             = { .type = NLA_U32 },
  98         [IFLA_BOND_DOWNDELAY]           = { .type = NLA_U32 },
  99         [IFLA_BOND_USE_CARRIER]         = { .type = NLA_U8 },
 100         [IFLA_BOND_ARP_INTERVAL]        = { .type = NLA_U32 },
 101         [IFLA_BOND_ARP_IP_TARGET]       = { .type = NLA_NESTED },
 102         [IFLA_BOND_ARP_VALIDATE]        = { .type = NLA_U32 },
 103         [IFLA_BOND_ARP_ALL_TARGETS]     = { .type = NLA_U32 },
 104         [IFLA_BOND_PRIMARY]             = { .type = NLA_U32 },
 105         [IFLA_BOND_PRIMARY_RESELECT]    = { .type = NLA_U8 },
 106         [IFLA_BOND_FAIL_OVER_MAC]       = { .type = NLA_U8 },
 107         [IFLA_BOND_XMIT_HASH_POLICY]    = { .type = NLA_U8 },
 108         [IFLA_BOND_RESEND_IGMP]         = { .type = NLA_U32 },
 109         [IFLA_BOND_NUM_PEER_NOTIF]      = { .type = NLA_U8 },
 110         [IFLA_BOND_ALL_SLAVES_ACTIVE]   = { .type = NLA_U8 },
 111         [IFLA_BOND_MIN_LINKS]           = { .type = NLA_U32 },
 112         [IFLA_BOND_LP_INTERVAL]         = { .type = NLA_U32 },
 113         [IFLA_BOND_PACKETS_PER_SLAVE]   = { .type = NLA_U32 },
 114         [IFLA_BOND_AD_LACP_ACTIVE]      = { .type = NLA_U8 },
 115         [IFLA_BOND_AD_LACP_RATE]        = { .type = NLA_U8 },
 116         [IFLA_BOND_AD_SELECT]           = { .type = NLA_U8 },
 117         [IFLA_BOND_AD_INFO]             = { .type = NLA_NESTED },
 118         [IFLA_BOND_AD_ACTOR_SYS_PRIO]   = { .type = NLA_U16 },
 119         [IFLA_BOND_AD_USER_PORT_KEY]    = { .type = NLA_U16 },
 120         [IFLA_BOND_AD_ACTOR_SYSTEM]     = { .type = NLA_BINARY,
 121                                             .len  = ETH_ALEN },
 122         [IFLA_BOND_TLB_DYNAMIC_LB]      = { .type = NLA_U8 },
 123         [IFLA_BOND_PEER_NOTIF_DELAY]    = NLA_POLICY_FULL_RANGE(NLA_U32, &delay_range),
 124         [IFLA_BOND_MISSED_MAX]          = { .type = NLA_U8 },
 125         [IFLA_BOND_NS_IP6_TARGET]       = { .type = NLA_NESTED },
 126         [IFLA_BOND_COUPLED_CONTROL]     = { .type = NLA_U8 },
 127 };
 128
 129 static const struct nla_policy bond_slave_policy[IFLA_BOND_SLAVE_MAX + 1] = {
 130         [IFLA_BOND_SLAVE_QUEUE_ID]      = { .type = NLA_U16 },
 131         [IFLA_BOND_SLAVE_PRIO]          = { .type = NLA_S32 },
 132 };
 133
 134 static int bond_validate(struct nlattr *tb[], struct nlattr *data[],
 135                          struct netlink_ext_ack *extack)
 136 {
 137         if (tb[IFLA_ADDRESS]) {
 138                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 139                         return -EINVAL;
 140                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 141                         return -EADDRNOTAVAIL;
 142         }
 143         return 0;
 144 }
 145
 146 static int bond_slave_changelink(struct net_device *bond_dev,
 147                                  struct net_device *slave_dev,
 148                                  struct nlattr *tb[], struct nlattr *data[],
 149                                  struct netlink_ext_ack *extack)
 150 {
 151         struct bonding *bond = netdev_priv(bond_dev);
 152         struct bond_opt_value newval;
 153         int err;
 154
 155         if (!data)
 156                 return 0;
 157
 158         if (data[IFLA_BOND_SLAVE_QUEUE_ID]) {
 159                 u16 queue_id = nla_get_u16(data[IFLA_BOND_SLAVE_QUEUE_ID]);
 160                 char queue_id_str[IFNAMSIZ + 7];
 161
 162                 /* queue_id option setting expects slave_name:queue_id */
 163                 snprintf(queue_id_str, sizeof(queue_id_str), "%s:%u\n",
 164                          slave_dev->name, queue_id);
 165                 bond_opt_initstr(&newval, queue_id_str);
 166                 err = __bond_opt_set(bond, BOND_OPT_QUEUE_ID, &newval,
 167                                      data[IFLA_BOND_SLAVE_QUEUE_ID], extack);
 168                 if (err)
 169                         return err;
 170         }
 171
 172         if (data[IFLA_BOND_SLAVE_PRIO]) {
 173                 int prio = nla_get_s32(data[IFLA_BOND_SLAVE_PRIO]);
 174
 175                 bond_opt_slave_initval(&newval, &slave_dev, prio);
 176                 err = __bond_opt_set(bond, BOND_OPT_PRIO, &newval,
 177                                      data[IFLA_BOND_SLAVE_PRIO], extack);
 178                 if (err)
 179                         return err;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static int bond_changelink(struct net_device *bond_dev, struct nlattr *tb[],
 186                            struct nlattr *data[],
 187                            struct netlink_ext_ack *extack)
 188 {
 189         struct bonding *bond = netdev_priv(bond_dev);
 190         struct bond_opt_value newval;
 191         int miimon = 0;
 192         int err;
 193
 194         if (!data)
 195                 return 0;
 196
 197         if (data[IFLA_BOND_MODE]) {
 198                 int mode = nla_get_u8(data[IFLA_BOND_MODE]);
 199
 200                 bond_opt_initval(&newval, mode);
 201                 err = __bond_opt_set(bond, BOND_OPT_MODE, &newval,
 202                                      data[IFLA_BOND_MODE], extack);
 203                 if (err)
 204                         return err;
 205         }
 206         if (data[IFLA_BOND_ACTIVE_SLAVE]) {
 207                 int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
 208                 struct net_device *slave_dev;
 209                 char *active_slave = "";
 210
 211                 if (ifindex != 0) {
 212                         slave_dev = __dev_get_by_index(dev_net(bond_dev),
 213                                                        ifindex);
 214                         if (!slave_dev)
 215                                 return -ENODEV;
 216                         active_slave = slave_dev->name;
 217                 }
 218                 bond_opt_initstr(&newval, active_slave);
 219                 err = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval,
 220                                      data[IFLA_BOND_ACTIVE_SLAVE], extack);
 221                 if (err)
 222                         return err;
 223         }
 224         if (data[IFLA_BOND_MIIMON]) {
 225                 miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);
 226
 227                 bond_opt_initval(&newval, miimon);
 228                 err = __bond_opt_set(bond, BOND_OPT_MIIMON, &newval,
 229                                      data[IFLA_BOND_MIIMON], extack);
 230                 if (err)
 231                         return err;
 232         }
 233         if (data[IFLA_BOND_UPDELAY]) {
 234                 int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);
 235
 236                 bond_opt_initval(&newval, updelay);
 237                 err = __bond_opt_set(bond, BOND_OPT_UPDELAY, &newval,
 238                                      data[IFLA_BOND_UPDELAY], extack);
 239                 if (err)
 240                         return err;
 241         }
 242         if (data[IFLA_BOND_DOWNDELAY]) {
 243                 int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);
 244
 245                 bond_opt_initval(&newval, downdelay);
 246                 err = __bond_opt_set(bond, BOND_OPT_DOWNDELAY, &newval,
 247                                      data[IFLA_BOND_DOWNDELAY], extack);
 248                 if (err)
 249                         return err;
 250         }
 251         if (data[IFLA_BOND_PEER_NOTIF_DELAY]) {
 252                 int delay = nla_get_u32(data[IFLA_BOND_PEER_NOTIF_DELAY]);
 253
 254                 bond_opt_initval(&newval, delay);
 255                 err = __bond_opt_set(bond, BOND_OPT_PEER_NOTIF_DELAY, &newval,
 256                                      data[IFLA_BOND_PEER_NOTIF_DELAY], extack);
 257                 if (err)
 258                         return err;
 259         }
 260         if (data[IFLA_BOND_USE_CARRIER]) {
 261                 int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]);
 262
 263                 bond_opt_initval(&newval, use_carrier);
 264                 err = __bond_opt_set(bond, BOND_OPT_USE_CARRIER, &newval,
 265                                      data[IFLA_BOND_USE_CARRIER], extack);
 266                 if (err)
 267                         return err;
 268         }
 269         if (data[IFLA_BOND_ARP_INTERVAL]) {
 270                 int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]);
 271
 272                 if (arp_interval && miimon) {
 273                         NL_SET_ERR_MSG_ATTR(extack, data[IFLA_BOND_ARP_INTERVAL],
 274                                             "ARP monitoring cannot be used with MII monitoring");
 275                         return -EINVAL;
 276                 }
 277
 278                 bond_opt_initval(&newval, arp_interval);
 279                 err = __bond_opt_set(bond, BOND_OPT_ARP_INTERVAL, &newval,
 280                                      data[IFLA_BOND_ARP_INTERVAL], extack);
 281                 if (err)
 282                         return err;
 283         }
 284         if (data[IFLA_BOND_ARP_IP_TARGET]) {
 285                 struct nlattr *attr;
 286                 int i = 0, rem;
 287
 288                 bond_option_arp_ip_targets_clear(bond);
 289                 nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
 290                         __be32 target;
 291
 292                         if (nla_len(attr) < sizeof(target))
 293                                 return -EINVAL;
 294
 295                         target = nla_get_be32(attr);
 296
 297                         bond_opt_initval(&newval, (__force u64)target);
 298                         err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
 299                                              &newval,
 300                                              data[IFLA_BOND_ARP_IP_TARGET],
 301                                              extack);
 302                         if (err)
 303                                 break;
 304                         i++;
 305                 }
 306                 if (i == 0 && bond->params.arp_interval)
 307                         netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n");
 308                 if (err)
 309                         return err;
 310         }
 311 #if IS_ENABLED(CONFIG_IPV6)
 312         if (data[IFLA_BOND_NS_IP6_TARGET]) {
 313                 struct nlattr *attr;
 314                 int i = 0, rem;
 315
 316                 bond_option_ns_ip6_targets_clear(bond);
 317                 nla_for_each_nested(attr, data[IFLA_BOND_NS_IP6_TARGET], rem) {
 318                         struct in6_addr addr6;
 319
 320                         if (nla_len(attr) < sizeof(addr6)) {
 321                                 NL_SET_ERR_MSG(extack, "Invalid IPv6 address");
 322                                 return -EINVAL;
 323                         }
 324
 325                         addr6 = nla_get_in6_addr(attr);
 326
 327                         bond_opt_initextra(&newval, &addr6, sizeof(addr6));
 328                         err = __bond_opt_set(bond, BOND_OPT_NS_TARGETS,
 329                                              &newval,
 330                                              data[IFLA_BOND_NS_IP6_TARGET],
 331                                              extack);
 332                         if (err)
 333                                 break;
 334                         i++;
 335                 }
 336                 if (i == 0 && bond->params.arp_interval)
 337                         netdev_warn(bond->dev, "Removing last ns target with arp_interval on\n");
 338                 if (err)
 339                         return err;
 340         }
 341 #endif
 342         if (data[IFLA_BOND_ARP_VALIDATE]) {
 343                 int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]);
 344
 345                 if (arp_validate && miimon) {
 346                         NL_SET_ERR_MSG_ATTR(extack, data[IFLA_BOND_ARP_INTERVAL],
 347                                             "ARP validating cannot be used with MII monitoring");
 348                         return -EINVAL;
 349                 }
 350
 351                 bond_opt_initval(&newval, arp_validate);
 352                 err = __bond_opt_set(bond, BOND_OPT_ARP_VALIDATE, &newval,
 353                                      data[IFLA_BOND_ARP_VALIDATE], extack);
 354                 if (err)
 355                         return err;
 356         }
 357         if (data[IFLA_BOND_ARP_ALL_TARGETS]) {
 358                 int arp_all_targets =
 359                         nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]);
 360
 361                 bond_opt_initval(&newval, arp_all_targets);
 362                 err = __bond_opt_set(bond, BOND_OPT_ARP_ALL_TARGETS, &newval,
 363                                      data[IFLA_BOND_ARP_ALL_TARGETS], extack);
 364                 if (err)
 365                         return err;
 366         }
 367         if (data[IFLA_BOND_PRIMARY]) {
 368                 int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]);
 369                 struct net_device *dev;
 370                 char *primary = "";
 371
 372                 dev = __dev_get_by_index(dev_net(bond_dev), ifindex);
 373                 if (dev)
 374                         primary = dev->name;
 375
 376                 bond_opt_initstr(&newval, primary);
 377                 err = __bond_opt_set(bond, BOND_OPT_PRIMARY, &newval,
 378                                      data[IFLA_BOND_PRIMARY], extack);
 379                 if (err)
 380                         return err;
 381         }
 382         if (data[IFLA_BOND_PRIMARY_RESELECT]) {
 383                 int primary_reselect =
 384                         nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]);
 385
 386                 bond_opt_initval(&newval, primary_reselect);
 387                 err = __bond_opt_set(bond, BOND_OPT_PRIMARY_RESELECT, &newval,
 388                                      data[IFLA_BOND_PRIMARY_RESELECT], extack);
 389                 if (err)
 390                         return err;
 391         }
 392         if (data[IFLA_BOND_FAIL_OVER_MAC]) {
 393                 int fail_over_mac =
 394                         nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]);
 395
 396                 bond_opt_initval(&newval, fail_over_mac);
 397                 err = __bond_opt_set(bond, BOND_OPT_FAIL_OVER_MAC, &newval,
 398                                      data[IFLA_BOND_FAIL_OVER_MAC], extack);
 399                 if (err)
 400                         return err;
 401         }
 402         if (data[IFLA_BOND_XMIT_HASH_POLICY]) {
 403                 int xmit_hash_policy =
 404                         nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]);
 405
 406                 bond_opt_initval(&newval, xmit_hash_policy);
 407                 err = __bond_opt_set(bond, BOND_OPT_XMIT_HASH, &newval,
 408                                      data[IFLA_BOND_XMIT_HASH_POLICY], extack);
 409                 if (err)
 410                         return err;
 411         }
 412         if (data[IFLA_BOND_RESEND_IGMP]) {
 413                 int resend_igmp =
 414                         nla_get_u32(data[IFLA_BOND_RESEND_IGMP]);
 415
 416                 bond_opt_initval(&newval, resend_igmp);
 417                 err = __bond_opt_set(bond, BOND_OPT_RESEND_IGMP, &newval,
 418                                      data[IFLA_BOND_RESEND_IGMP], extack);
 419                 if (err)
 420                         return err;
 421         }
 422         if (data[IFLA_BOND_NUM_PEER_NOTIF]) {
 423                 int num_peer_notif =
 424                         nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]);
 425
 426                 bond_opt_initval(&newval, num_peer_notif);
 427                 err = __bond_opt_set(bond, BOND_OPT_NUM_PEER_NOTIF, &newval,
 428                                      data[IFLA_BOND_NUM_PEER_NOTIF], extack);
 429                 if (err)
 430                         return err;
 431         }
 432         if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) {
 433                 int all_slaves_active =
 434                         nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]);
 435
 436                 bond_opt_initval(&newval, all_slaves_active);
 437                 err = __bond_opt_set(bond, BOND_OPT_ALL_SLAVES_ACTIVE, &newval,
 438                                      data[IFLA_BOND_ALL_SLAVES_ACTIVE], extack);
 439                 if (err)
 440                         return err;
 441         }
 442         if (data[IFLA_BOND_MIN_LINKS]) {
 443                 int min_links =
 444                         nla_get_u32(data[IFLA_BOND_MIN_LINKS]);
 445
 446                 bond_opt_initval(&newval, min_links);
 447                 err = __bond_opt_set(bond, BOND_OPT_MINLINKS, &newval,
 448                                      data[IFLA_BOND_MIN_LINKS], extack);
 449                 if (err)
 450                         return err;
 451         }
 452         if (data[IFLA_BOND_LP_INTERVAL]) {
 453                 int lp_interval =
 454                         nla_get_u32(data[IFLA_BOND_LP_INTERVAL]);
 455
 456                 bond_opt_initval(&newval, lp_interval);
 457                 err = __bond_opt_set(bond, BOND_OPT_LP_INTERVAL, &newval,
 458                                      data[IFLA_BOND_LP_INTERVAL], extack);
 459                 if (err)
 460                         return err;
 461         }
 462         if (data[IFLA_BOND_PACKETS_PER_SLAVE]) {
 463                 int packets_per_slave =
 464                         nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]);
 465
 466                 bond_opt_initval(&newval, packets_per_slave);
 467                 err = __bond_opt_set(bond, BOND_OPT_PACKETS_PER_SLAVE, &newval,
 468                                      data[IFLA_BOND_PACKETS_PER_SLAVE], extack);
 469                 if (err)
 470                         return err;
 471         }
 472
 473         if (data[IFLA_BOND_AD_LACP_ACTIVE]) {
 474                 int lacp_active = nla_get_u8(data[IFLA_BOND_AD_LACP_ACTIVE]);
 475
 476                 bond_opt_initval(&newval, lacp_active);
 477                 err = __bond_opt_set(bond, BOND_OPT_LACP_ACTIVE, &newval,
 478                                      data[IFLA_BOND_AD_LACP_ACTIVE], extack);
 479                 if (err)
 480                         return err;
 481         }
 482
 483         if (data[IFLA_BOND_AD_LACP_RATE]) {
 484                 int lacp_rate =
 485                         nla_get_u8(data[IFLA_BOND_AD_LACP_RATE]);
 486
 487                 bond_opt_initval(&newval, lacp_rate);
 488                 err = __bond_opt_set(bond, BOND_OPT_LACP_RATE, &newval,
 489                                      data[IFLA_BOND_AD_LACP_RATE], extack);
 490                 if (err)
 491                         return err;
 492         }
 493         if (data[IFLA_BOND_AD_SELECT]) {
 494                 int ad_select =
 495                         nla_get_u8(data[IFLA_BOND_AD_SELECT]);
 496
 497                 bond_opt_initval(&newval, ad_select);
 498                 err = __bond_opt_set(bond, BOND_OPT_AD_SELECT, &newval,
 499                                      data[IFLA_BOND_AD_SELECT], extack);
 500                 if (err)
 501                         return err;
 502         }
 503         if (data[IFLA_BOND_AD_ACTOR_SYS_PRIO]) {
 504                 int actor_sys_prio =
 505                         nla_get_u16(data[IFLA_BOND_AD_ACTOR_SYS_PRIO]);
 506
 507                 bond_opt_initval(&newval, actor_sys_prio);
 508                 err = __bond_opt_set(bond, BOND_OPT_AD_ACTOR_SYS_PRIO, &newval,
 509                                      data[IFLA_BOND_AD_ACTOR_SYS_PRIO], extack);
 510                 if (err)
 511                         return err;
 512         }
 513         if (data[IFLA_BOND_AD_USER_PORT_KEY]) {
 514                 int port_key =
 515                         nla_get_u16(data[IFLA_BOND_AD_USER_PORT_KEY]);
 516
 517                 bond_opt_initval(&newval, port_key);
 518                 err = __bond_opt_set(bond, BOND_OPT_AD_USER_PORT_KEY, &newval,
 519                                      data[IFLA_BOND_AD_USER_PORT_KEY], extack);
 520                 if (err)
 521                         return err;
 522         }
 523         if (data[IFLA_BOND_AD_ACTOR_SYSTEM]) {
 524                 if (nla_len(data[IFLA_BOND_AD_ACTOR_SYSTEM]) != ETH_ALEN)
 525                         return -EINVAL;
 526
 527                 bond_opt_initval(&newval,
 528                                  nla_get_u64(data[IFLA_BOND_AD_ACTOR_SYSTEM]));
 529                 err = __bond_opt_set(bond, BOND_OPT_AD_ACTOR_SYSTEM, &newval,
 530                                      data[IFLA_BOND_AD_ACTOR_SYSTEM], extack);
 531                 if (err)
 532                         return err;
 533         }
 534         if (data[IFLA_BOND_TLB_DYNAMIC_LB]) {
 535                 int dynamic_lb = nla_get_u8(data[IFLA_BOND_TLB_DYNAMIC_LB]);
 536
 537                 bond_opt_initval(&newval, dynamic_lb);
 538                 err = __bond_opt_set(bond, BOND_OPT_TLB_DYNAMIC_LB, &newval,
 539                                      data[IFLA_BOND_TLB_DYNAMIC_LB], extack);
 540                 if (err)
 541                         return err;
 542         }
 543
 544         if (data[IFLA_BOND_MISSED_MAX]) {
 545                 int missed_max = nla_get_u8(data[IFLA_BOND_MISSED_MAX]);
 546
 547                 bond_opt_initval(&newval, missed_max);
 548                 err = __bond_opt_set(bond, BOND_OPT_MISSED_MAX, &newval,
 549                                      data[IFLA_BOND_MISSED_MAX], extack);
 550                 if (err)
 551                         return err;
 552         }
 553
 554         if (data[IFLA_BOND_COUPLED_CONTROL]) {
 555                 int coupled_control = nla_get_u8(data[IFLA_BOND_COUPLED_CONTROL]);
 556
 557                 bond_opt_initval(&newval, coupled_control);
 558                 err = __bond_opt_set(bond, BOND_OPT_COUPLED_CONTROL, &newval,
 559                                      data[IFLA_BOND_COUPLED_CONTROL], extack);
 560                 if (err)
 561                         return err;
 562         }
 563
 564         return 0;
 565 }
 566
 567 static int bond_newlink(struct net *src_net, struct net_device *bond_dev,
 568                         struct nlattr *tb[], struct nlattr *data[],
 569                         struct netlink_ext_ack *extack)
 570 {
 571         int err;
 572
 573         err = bond_changelink(bond_dev, tb, data, extack);
 574         if (err < 0)
 575                 return err;
 576
 577         err = register_netdevice(bond_dev);
 578         if (!err) {
 579                 struct bonding *bond = netdev_priv(bond_dev);
 580
 581                 netif_carrier_off(bond_dev);
 582                 bond_work_init_all(bond);
 583         }
 584
 585         return err;
 586 }
 587
 588 static size_t bond_get_size(const struct net_device *bond_dev)
 589 {
 590         return nla_total_size(sizeof(u8)) +     /* IFLA_BOND_MODE */
 591                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ACTIVE_SLAVE */
 592                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_MIIMON */
 593                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_UPDELAY */
 594                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_DOWNDELAY */
 595                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_USE_CARRIER */
 596                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_INTERVAL */
 597                                                 /* IFLA_BOND_ARP_IP_TARGET */
 598                 nla_total_size(sizeof(struct nlattr)) +
 599                 nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
 600                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_VALIDATE */
 601                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_ALL_TARGETS */
 602                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_PRIMARY */
 603                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_PRIMARY_RESELECT */
 604                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_FAIL_OVER_MAC */
 605                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_XMIT_HASH_POLICY */
 606                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_RESEND_IGMP */
 607                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_NUM_PEER_NOTIF */
 608                 nla_total_size(sizeof(u8)) +   /* IFLA_BOND_ALL_SLAVES_ACTIVE */
 609                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_MIN_LINKS */
 610                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_LP_INTERVAL */
 611                 nla_total_size(sizeof(u32)) +  /* IFLA_BOND_PACKETS_PER_SLAVE */
 612                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_AD_LACP_ACTIVE */
 613                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_AD_LACP_RATE */
 614                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_AD_SELECT */
 615                 nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
 616                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
 617                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
 618                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
 619                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
 620                 nla_total_size(ETH_ALEN) +    /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
 621                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_ACTOR_SYS_PRIO */
 622                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_USER_PORT_KEY */
 623                 nla_total_size(ETH_ALEN) + /* IFLA_BOND_AD_ACTOR_SYSTEM */
 624                 nla_total_size(sizeof(u8)) + /* IFLA_BOND_TLB_DYNAMIC_LB */
 625                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_PEER_NOTIF_DELAY */
 626                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_MISSED_MAX */
 627                                                 /* IFLA_BOND_NS_IP6_TARGET */
 628                 nla_total_size(sizeof(struct nlattr)) +
 629                 nla_total_size(sizeof(struct in6_addr)) * BOND_MAX_NS_TARGETS +
 630                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_COUPLED_CONTROL */
 631                 0;
 632 }
 633
 634 static int bond_option_active_slave_get_ifindex(struct bonding *bond)
 635 {
 636         const struct net_device *slave;
 637         int ifindex;
 638
 639         rcu_read_lock();
 640         slave = bond_option_active_slave_get_rcu(bond);
 641         ifindex = slave ? slave->ifindex : 0;
 642         rcu_read_unlock();
 643         return ifindex;
 644 }
 645
 646 static int bond_fill_info(struct sk_buff *skb,
 647                           const struct net_device *bond_dev)
 648 {
 649         struct bonding *bond = netdev_priv(bond_dev);
 650         unsigned int packets_per_slave;
 651         int ifindex, i, targets_added;
 652         struct nlattr *targets;
 653         struct slave *primary;
 654
 655         if (nla_put_u8(skb, IFLA_BOND_MODE, BOND_MODE(bond)))
 656                 goto nla_put_failure;
 657
 658         ifindex = bond_option_active_slave_get_ifindex(bond);
 659         if (ifindex && nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, ifindex))
 660                 goto nla_put_failure;
 661
 662         if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
 663                 goto nla_put_failure;
 664
 665         if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
 666                         bond->params.updelay * bond->params.miimon))
 667                 goto nla_put_failure;
 668
 669         if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
 670                         bond->params.downdelay * bond->params.miimon))
 671                 goto nla_put_failure;
 672
 673         if (nla_put_u32(skb, IFLA_BOND_PEER_NOTIF_DELAY,
 674                         bond->params.peer_notif_delay * bond->params.miimon))
 675                 goto nla_put_failure;
 676
 677         if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
 678                 goto nla_put_failure;
 679
 680         if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
 681                 goto nla_put_failure;
 682
 683         targets = nla_nest_start_noflag(skb, IFLA_BOND_ARP_IP_TARGET);
 684         if (!targets)
 685                 goto nla_put_failure;
 686
 687         targets_added = 0;
 688         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 689                 if (bond->params.arp_targets[i]) {
 690                         if (nla_put_be32(skb, i, bond->params.arp_targets[i]))
 691                                 goto nla_put_failure;
 692                         targets_added = 1;
 693                 }
 694         }
 695
 696         if (targets_added)
 697                 nla_nest_end(skb, targets);
 698         else
 699                 nla_nest_cancel(skb, targets);
 700
 701         if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
 702                 goto nla_put_failure;
 703
 704         if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
 705                         bond->params.arp_all_targets))
 706                 goto nla_put_failure;
 707
 708 #if IS_ENABLED(CONFIG_IPV6)
 709         targets = nla_nest_start(skb, IFLA_BOND_NS_IP6_TARGET);
 710         if (!targets)
 711                 goto nla_put_failure;
 712
 713         targets_added = 0;
 714         for (i = 0; i < BOND_MAX_NS_TARGETS; i++) {
 715                 if (!ipv6_addr_any(&bond->params.ns_targets[i])) {
 716                         if (nla_put_in6_addr(skb, i, &bond->params.ns_targets[i]))
 717                                 goto nla_put_failure;
 718                         targets_added = 1;
 719                 }
 720         }
 721
 722         if (targets_added)
 723                 nla_nest_end(skb, targets);
 724         else
 725                 nla_nest_cancel(skb, targets);
 726 #endif
 727
 728         primary = rtnl_dereference(bond->primary_slave);
 729         if (primary &&
 730             nla_put_u32(skb, IFLA_BOND_PRIMARY, primary->dev->ifindex))
 731                 goto nla_put_failure;
 732
 733         if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
 734                        bond->params.primary_reselect))
 735                 goto nla_put_failure;
 736
 737         if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
 738                        bond->params.fail_over_mac))
 739                 goto nla_put_failure;
 740
 741         if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
 742                        bond->params.xmit_policy))
 743                 goto nla_put_failure;
 744
 745         if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
 746                         bond->params.resend_igmp))
 747                 goto nla_put_failure;
 748
 749         if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
 750                        bond->params.num_peer_notif))
 751                 goto nla_put_failure;
 752
 753         if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
 754                        bond->params.all_slaves_active))
 755                 goto nla_put_failure;
 756
 757         if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
 758                         bond->params.min_links))
 759                 goto nla_put_failure;
 760
 761         if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
 762                         bond->params.lp_interval))
 763                 goto nla_put_failure;
 764
 765         packets_per_slave = bond->params.packets_per_slave;
 766         if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
 767                         packets_per_slave))
 768                 goto nla_put_failure;
 769
 770         if (nla_put_u8(skb, IFLA_BOND_AD_LACP_ACTIVE,
 771                        bond->params.lacp_active))
 772                 goto nla_put_failure;
 773
 774         if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
 775                        bond->params.lacp_fast))
 776                 goto nla_put_failure;
 777
 778         if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
 779                        bond->params.ad_select))
 780                 goto nla_put_failure;
 781
 782         if (nla_put_u8(skb, IFLA_BOND_TLB_DYNAMIC_LB,
 783                        bond->params.tlb_dynamic_lb))
 784                 goto nla_put_failure;
 785
 786         if (nla_put_u8(skb, IFLA_BOND_MISSED_MAX,
 787                        bond->params.missed_max))
 788                 goto nla_put_failure;
 789
 790         if (nla_put_u8(skb, IFLA_BOND_COUPLED_CONTROL,
 791                        bond->params.coupled_control))
 792                 goto nla_put_failure;
 793
 794         if (BOND_MODE(bond) == BOND_MODE_8023AD) {
 795                 struct ad_info info;
 796
 797                 if (capable(CAP_NET_ADMIN)) {
 798                         if (nla_put_u16(skb, IFLA_BOND_AD_ACTOR_SYS_PRIO,
 799                                         bond->params.ad_actor_sys_prio))
 800                                 goto nla_put_failure;
 801
 802                         if (nla_put_u16(skb, IFLA_BOND_AD_USER_PORT_KEY,
 803                                         bond->params.ad_user_port_key))
 804                                 goto nla_put_failure;
 805
 806                         if (nla_put(skb, IFLA_BOND_AD_ACTOR_SYSTEM,
 807                                     ETH_ALEN, &bond->params.ad_actor_system))
 808                                 goto nla_put_failure;
 809                 }
 810                 if (!bond_3ad_get_active_agg_info(bond, &info)) {
 811                         struct nlattr *nest;
 812
 813                         nest = nla_nest_start_noflag(skb, IFLA_BOND_AD_INFO);
 814                         if (!nest)
 815                                 goto nla_put_failure;
 816
 817                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
 818                                         info.aggregator_id))
 819                                 goto nla_put_failure;
 820                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
 821                                         info.ports))
 822                                 goto nla_put_failure;
 823                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
 824                                         info.actor_key))
 825                                 goto nla_put_failure;
 826                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
 827                                         info.partner_key))
 828                                 goto nla_put_failure;
 829                         if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
 830                                     sizeof(info.partner_system),
 831                                     &info.partner_system))
 832                                 goto nla_put_failure;
 833
 834                         nla_nest_end(skb, nest);
 835                 }
 836         }
 837
 838         return 0;
 839
 840 nla_put_failure:
 841         return -EMSGSIZE;
 842 }
 843
 844 static size_t bond_get_linkxstats_size(const struct net_device *dev, int attr)
 845 {
 846         switch (attr) {
 847         case IFLA_STATS_LINK_XSTATS:
 848         case IFLA_STATS_LINK_XSTATS_SLAVE:
 849                 break;
 850         default:
 851                 return 0;
 852         }
 853
 854         return bond_3ad_stats_size() + nla_total_size(0);
 855 }
 856
 857 static int bond_fill_linkxstats(struct sk_buff *skb,
 858                                 const struct net_device *dev,
 859                                 int *prividx, int attr)
 860 {
 861         struct nlattr *nla __maybe_unused;
 862         struct slave *slave = NULL;
 863         struct nlattr *nest, *nest2;
 864         struct bonding *bond;
 865
 866         switch (attr) {
 867         case IFLA_STATS_LINK_XSTATS:
 868                 bond = netdev_priv(dev);
 869                 break;
 870         case IFLA_STATS_LINK_XSTATS_SLAVE:
 871                 slave = bond_slave_get_rtnl(dev);
 872                 if (!slave)
 873                         return 0;
 874                 bond = slave->bond;
 875                 break;
 876         default:
 877                 return -EINVAL;
 878         }
 879
 880         nest = nla_nest_start_noflag(skb, LINK_XSTATS_TYPE_BOND);
 881         if (!nest)
 882                 return -EMSGSIZE;
 883         if (BOND_MODE(bond) == BOND_MODE_8023AD) {
 884                 struct bond_3ad_stats *stats;
 885
 886                 if (slave)
 887                         stats = &SLAVE_AD_INFO(slave)->stats;
 888                 else
 889                         stats = &BOND_AD_INFO(bond).stats;
 890
 891                 nest2 = nla_nest_start_noflag(skb, BOND_XSTATS_3AD);
 892                 if (!nest2) {
 893                         nla_nest_end(skb, nest);
 894                         return -EMSGSIZE;
 895                 }
 896
 897                 if (bond_3ad_stats_fill(skb, stats)) {
 898                         nla_nest_cancel(skb, nest2);
 899                         nla_nest_end(skb, nest);
 900                         return -EMSGSIZE;
 901                 }
 902                 nla_nest_end(skb, nest2);
 903         }
 904         nla_nest_end(skb, nest);
 905
 906         return 0;
 907 }
 908
 909 struct rtnl_link_ops bond_link_ops __read_mostly = {
 910         .kind                   = "bond",
 911         .priv_size              = sizeof(struct bonding),
 912         .setup                  = bond_setup,
 913         .maxtype                = IFLA_BOND_MAX,
 914         .policy                 = bond_policy,
 915         .validate               = bond_validate,
 916         .newlink                = bond_newlink,
 917         .changelink             = bond_changelink,
 918         .get_size               = bond_get_size,
 919         .fill_info              = bond_fill_info,
 920         .get_num_tx_queues      = bond_get_num_tx_queues,
 921         .get_num_rx_queues      = bond_get_num_tx_queues, /* Use the same number
 922                                                              as for TX queues */
 923         .fill_linkxstats        = bond_fill_linkxstats,
 924         .get_linkxstats_size    = bond_get_linkxstats_size,
 925         .slave_maxtype          = IFLA_BOND_SLAVE_MAX,
 926         .slave_policy           = bond_slave_policy,
 927         .slave_changelink       = bond_slave_changelink,
 928         .get_slave_size         = bond_get_slave_size,
 929         .fill_slave_info        = bond_fill_slave_info,
 930 };
 931
 932 int __init bond_netlink_init(void)
 933 {
 934         return rtnl_link_register(&bond_link_ops);
 935 }
 936
 937 void bond_netlink_fini(void)
 938 {
 939         rtnl_link_unregister(&bond_link_ops);
 940 }
 941
 942 MODULE_ALIAS_RTNL_LINK("bond");