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
  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
 460         netif_carrier_off(bond_dev);
 461         if (!err) {
 462                 struct bonding *bond = netdev_priv(bond_dev);
 463
 464                 bond_work_init_all(bond);
 465         }
 466
 467         return err;
 468 }
 469
 470 static size_t bond_get_size(const struct net_device *bond_dev)
 471 {
 472         return nla_total_size(sizeof(u8)) +     /* IFLA_BOND_MODE */
 473                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ACTIVE_SLAVE */
 474                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_MIIMON */
 475                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_UPDELAY */
 476                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_DOWNDELAY */
 477                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_USE_CARRIER */
 478                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_INTERVAL */
 479                                                 /* IFLA_BOND_ARP_IP_TARGET */
 480                 nla_total_size(sizeof(struct nlattr)) +
 481                 nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
 482                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_VALIDATE */
 483                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_ARP_ALL_TARGETS */
 484                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_PRIMARY */
 485                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_PRIMARY_RESELECT */
 486                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_FAIL_OVER_MAC */
 487                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_XMIT_HASH_POLICY */
 488                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_RESEND_IGMP */
 489                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_NUM_PEER_NOTIF */
 490                 nla_total_size(sizeof(u8)) +   /* IFLA_BOND_ALL_SLAVES_ACTIVE */
 491                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_MIN_LINKS */
 492                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_LP_INTERVAL */
 493                 nla_total_size(sizeof(u32)) +  /* IFLA_BOND_PACKETS_PER_SLAVE */
 494                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_AD_LACP_RATE */
 495                 nla_total_size(sizeof(u8)) +    /* IFLA_BOND_AD_SELECT */
 496                 nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
 497                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
 498                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
 499                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
 500                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
 501                 nla_total_size(ETH_ALEN) +    /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
 502                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_ACTOR_SYS_PRIO */
 503                 nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_USER_PORT_KEY */
 504                 nla_total_size(ETH_ALEN) + /* IFLA_BOND_AD_ACTOR_SYSTEM */
 505                 nla_total_size(sizeof(u8)) + /* IFLA_BOND_TLB_DYNAMIC_LB */
 506                 nla_total_size(sizeof(u32)) +   /* IFLA_BOND_PEER_NOTIF_DELAY */
 507                 0;
 508 }
 509
 510 static int bond_option_active_slave_get_ifindex(struct bonding *bond)
 511 {
 512         const struct net_device *slave;
 513         int ifindex;
 514
 515         rcu_read_lock();
 516         slave = bond_option_active_slave_get_rcu(bond);
 517         ifindex = slave ? slave->ifindex : 0;
 518         rcu_read_unlock();
 519         return ifindex;
 520 }
 521
 522 static int bond_fill_info(struct sk_buff *skb,
 523                           const struct net_device *bond_dev)
 524 {
 525         struct bonding *bond = netdev_priv(bond_dev);
 526         unsigned int packets_per_slave;
 527         int ifindex, i, targets_added;
 528         struct nlattr *targets;
 529         struct slave *primary;
 530
 531         if (nla_put_u8(skb, IFLA_BOND_MODE, BOND_MODE(bond)))
 532                 goto nla_put_failure;
 533
 534         ifindex = bond_option_active_slave_get_ifindex(bond);
 535         if (ifindex && nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, ifindex))
 536                 goto nla_put_failure;
 537
 538         if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
 539                 goto nla_put_failure;
 540
 541         if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
 542                         bond->params.updelay * bond->params.miimon))
 543                 goto nla_put_failure;
 544
 545         if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
 546                         bond->params.downdelay * bond->params.miimon))
 547                 goto nla_put_failure;
 548
 549         if (nla_put_u32(skb, IFLA_BOND_PEER_NOTIF_DELAY,
 550                         bond->params.peer_notif_delay * bond->params.miimon))
 551                 goto nla_put_failure;
 552
 553         if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
 554                 goto nla_put_failure;
 555
 556         if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
 557                 goto nla_put_failure;
 558
 559         targets = nla_nest_start_noflag(skb, IFLA_BOND_ARP_IP_TARGET);
 560         if (!targets)
 561                 goto nla_put_failure;
 562
 563         targets_added = 0;
 564         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 565                 if (bond->params.arp_targets[i]) {
 566                         if (nla_put_be32(skb, i, bond->params.arp_targets[i]))
 567                                 goto nla_put_failure;
 568                         targets_added = 1;
 569                 }
 570         }
 571
 572         if (targets_added)
 573                 nla_nest_end(skb, targets);
 574         else
 575                 nla_nest_cancel(skb, targets);
 576
 577         if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
 578                 goto nla_put_failure;
 579
 580         if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
 581                         bond->params.arp_all_targets))
 582                 goto nla_put_failure;
 583
 584         primary = rtnl_dereference(bond->primary_slave);
 585         if (primary &&
 586             nla_put_u32(skb, IFLA_BOND_PRIMARY, primary->dev->ifindex))
 587                 goto nla_put_failure;
 588
 589         if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
 590                        bond->params.primary_reselect))
 591                 goto nla_put_failure;
 592
 593         if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
 594                        bond->params.fail_over_mac))
 595                 goto nla_put_failure;
 596
 597         if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
 598                        bond->params.xmit_policy))
 599                 goto nla_put_failure;
 600
 601         if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
 602                         bond->params.resend_igmp))
 603                 goto nla_put_failure;
 604
 605         if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
 606                        bond->params.num_peer_notif))
 607                 goto nla_put_failure;
 608
 609         if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
 610                        bond->params.all_slaves_active))
 611                 goto nla_put_failure;
 612
 613         if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
 614                         bond->params.min_links))
 615                 goto nla_put_failure;
 616
 617         if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
 618                         bond->params.lp_interval))
 619                 goto nla_put_failure;
 620
 621         packets_per_slave = bond->params.packets_per_slave;
 622         if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
 623                         packets_per_slave))
 624                 goto nla_put_failure;
 625
 626         if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
 627                        bond->params.lacp_fast))
 628                 goto nla_put_failure;
 629
 630         if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
 631                        bond->params.ad_select))
 632                 goto nla_put_failure;
 633
 634         if (nla_put_u8(skb, IFLA_BOND_TLB_DYNAMIC_LB,
 635                        bond->params.tlb_dynamic_lb))
 636                 goto nla_put_failure;
 637
 638         if (BOND_MODE(bond) == BOND_MODE_8023AD) {
 639                 struct ad_info info;
 640
 641                 if (capable(CAP_NET_ADMIN)) {
 642                         if (nla_put_u16(skb, IFLA_BOND_AD_ACTOR_SYS_PRIO,
 643                                         bond->params.ad_actor_sys_prio))
 644                                 goto nla_put_failure;
 645
 646                         if (nla_put_u16(skb, IFLA_BOND_AD_USER_PORT_KEY,
 647                                         bond->params.ad_user_port_key))
 648                                 goto nla_put_failure;
 649
 650                         if (nla_put(skb, IFLA_BOND_AD_ACTOR_SYSTEM,
 651                                     ETH_ALEN, &bond->params.ad_actor_system))
 652                                 goto nla_put_failure;
 653                 }
 654                 if (!bond_3ad_get_active_agg_info(bond, &info)) {
 655                         struct nlattr *nest;
 656
 657                         nest = nla_nest_start_noflag(skb, IFLA_BOND_AD_INFO);
 658                         if (!nest)
 659                                 goto nla_put_failure;
 660
 661                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
 662                                         info.aggregator_id))
 663                                 goto nla_put_failure;
 664                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
 665                                         info.ports))
 666                                 goto nla_put_failure;
 667                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
 668                                         info.actor_key))
 669                                 goto nla_put_failure;
 670                         if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
 671                                         info.partner_key))
 672                                 goto nla_put_failure;
 673                         if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
 674                                     sizeof(info.partner_system),
 675                                     &info.partner_system))
 676                                 goto nla_put_failure;
 677
 678                         nla_nest_end(skb, nest);
 679                 }
 680         }
 681
 682         return 0;
 683
 684 nla_put_failure:
 685         return -EMSGSIZE;
 686 }
 687
 688 static size_t bond_get_linkxstats_size(const struct net_device *dev, int attr)
 689 {
 690         switch (attr) {
 691         case IFLA_STATS_LINK_XSTATS:
 692         case IFLA_STATS_LINK_XSTATS_SLAVE:
 693                 break;
 694         default:
 695                 return 0;
 696         }
 697
 698         return bond_3ad_stats_size() + nla_total_size(0);
 699 }
 700
 701 static int bond_fill_linkxstats(struct sk_buff *skb,
 702                                 const struct net_device *dev,
 703                                 int *prividx, int attr)
 704 {
 705         struct nlattr *nla __maybe_unused;
 706         struct slave *slave = NULL;
 707         struct nlattr *nest, *nest2;
 708         struct bonding *bond;
 709
 710         switch (attr) {
 711         case IFLA_STATS_LINK_XSTATS:
 712                 bond = netdev_priv(dev);
 713                 break;
 714         case IFLA_STATS_LINK_XSTATS_SLAVE:
 715                 slave = bond_slave_get_rtnl(dev);
 716                 if (!slave)
 717                         return 0;
 718                 bond = slave->bond;
 719                 break;
 720         default:
 721                 return -EINVAL;
 722         }
 723
 724         nest = nla_nest_start_noflag(skb, LINK_XSTATS_TYPE_BOND);
 725         if (!nest)
 726                 return -EMSGSIZE;
 727         if (BOND_MODE(bond) == BOND_MODE_8023AD) {
 728                 struct bond_3ad_stats *stats;
 729
 730                 if (slave)
 731                         stats = &SLAVE_AD_INFO(slave)->stats;
 732                 else
 733                         stats = &BOND_AD_INFO(bond).stats;
 734
 735                 nest2 = nla_nest_start_noflag(skb, BOND_XSTATS_3AD);
 736                 if (!nest2) {
 737                         nla_nest_end(skb, nest);
 738                         return -EMSGSIZE;
 739                 }
 740
 741                 if (bond_3ad_stats_fill(skb, stats)) {
 742                         nla_nest_cancel(skb, nest2);
 743                         nla_nest_end(skb, nest);
 744                         return -EMSGSIZE;
 745                 }
 746                 nla_nest_end(skb, nest2);
 747         }
 748         nla_nest_end(skb, nest);
 749
 750         return 0;
 751 }
 752
 753 struct rtnl_link_ops bond_link_ops __read_mostly = {
 754         .kind                   = "bond",
 755         .priv_size              = sizeof(struct bonding),
 756         .setup                  = bond_setup,
 757         .maxtype                = IFLA_BOND_MAX,
 758         .policy                 = bond_policy,
 759         .validate               = bond_validate,
 760         .newlink                = bond_newlink,
 761         .changelink             = bond_changelink,
 762         .get_size               = bond_get_size,
 763         .fill_info              = bond_fill_info,
 764         .get_num_tx_queues      = bond_get_num_tx_queues,
 765         .get_num_rx_queues      = bond_get_num_tx_queues, /* Use the same number
 766                                                              as for TX queues */
 767         .fill_linkxstats        = bond_fill_linkxstats,
 768         .get_linkxstats_size    = bond_get_linkxstats_size,
 769         .slave_maxtype          = IFLA_BOND_SLAVE_MAX,
 770         .slave_policy           = bond_slave_policy,
 771         .slave_changelink       = bond_slave_changelink,
 772         .get_slave_size         = bond_get_slave_size,
 773         .fill_slave_info        = bond_fill_slave_info,
 774 };
 775
 776 int __init bond_netlink_init(void)
 777 {
 778         return rtnl_link_register(&bond_link_ops);
 779 }
 780
 781 void bond_netlink_fini(void)
 782 {
 783         rtnl_link_unregister(&bond_link_ops);
 784 }
 785
 786 MODULE_ALIAS_RTNL_LINK("bond");