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