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