Pileus Git - ~andy/linux/blob - drivers/net/bonding/bond_sysfs.c

   1 /*
   2  * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * The full GNU General Public License is included in this distribution in the
  18  * file called LICENSE.
  19  *
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/device.h>
  27 #include <linux/sched.h>
  28 #include <linux/fs.h>
  29 #include <linux/types.h>
  30 #include <linux/string.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/inetdevice.h>
  33 #include <linux/in.h>
  34 #include <linux/sysfs.h>
  35 #include <linux/ctype.h>
  36 #include <linux/inet.h>
  37 #include <linux/rtnetlink.h>
  38 #include <linux/etherdevice.h>
  39 #include <net/net_namespace.h>
  40 #include <net/netns/generic.h>
  41 #include <linux/nsproxy.h>
  42 #include <linux/reciprocal_div.h>
  43
  44 #include "bonding.h"
  45
  46 #define to_dev(obj)     container_of(obj, struct device, kobj)
  47 #define to_bond(cd)     ((struct bonding *)(netdev_priv(to_net_dev(cd))))
  48
  49 /*
  50  * "show" function for the bond_masters attribute.
  51  * The class parameter is ignored.
  52  */
  53 static ssize_t bonding_show_bonds(struct class *cls,
  54                                   struct class_attribute *attr,
  55                                   char *buf)
  56 {
  57         struct bond_net *bn =
  58                 container_of(attr, struct bond_net, class_attr_bonding_masters);
  59         int res = 0;
  60         struct bonding *bond;
  61
  62         rtnl_lock();
  63
  64         list_for_each_entry(bond, &bn->dev_list, bond_list) {
  65                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
  66                         /* not enough space for another interface name */
  67                         if ((PAGE_SIZE - res) > 10)
  68                                 res = PAGE_SIZE - 10;
  69                         res += sprintf(buf + res, "++more++ ");
  70                         break;
  71                 }
  72                 res += sprintf(buf + res, "%s ", bond->dev->name);
  73         }
  74         if (res)
  75                 buf[res-1] = '\n'; /* eat the leftover space */
  76
  77         rtnl_unlock();
  78         return res;
  79 }
  80
  81 static struct net_device *bond_get_by_name(struct bond_net *bn, const char *ifname)
  82 {
  83         struct bonding *bond;
  84
  85         list_for_each_entry(bond, &bn->dev_list, bond_list) {
  86                 if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0)
  87                         return bond->dev;
  88         }
  89         return NULL;
  90 }
  91
  92 /*
  93  * "store" function for the bond_masters attribute.  This is what
  94  * creates and deletes entire bonds.
  95  *
  96  * The class parameter is ignored.
  97  *
  98  */
  99
 100 static ssize_t bonding_store_bonds(struct class *cls,
 101                                    struct class_attribute *attr,
 102                                    const char *buffer, size_t count)
 103 {
 104         struct bond_net *bn =
 105                 container_of(attr, struct bond_net, class_attr_bonding_masters);
 106         char command[IFNAMSIZ + 1] = {0, };
 107         char *ifname;
 108         int rv, res = count;
 109
 110         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
 111         ifname = command + 1;
 112         if ((strlen(command) <= 1) ||
 113             !dev_valid_name(ifname))
 114                 goto err_no_cmd;
 115
 116         if (command[0] == '+') {
 117                 pr_info("%s is being created...\n", ifname);
 118                 rv = bond_create(bn->net, ifname);
 119                 if (rv) {
 120                         if (rv == -EEXIST)
 121                                 pr_info("%s already exists.\n", ifname);
 122                         else
 123                                 pr_info("%s creation failed.\n", ifname);
 124                         res = rv;
 125                 }
 126         } else if (command[0] == '-') {
 127                 struct net_device *bond_dev;
 128
 129                 rtnl_lock();
 130                 bond_dev = bond_get_by_name(bn, ifname);
 131                 if (bond_dev) {
 132                         pr_info("%s is being deleted...\n", ifname);
 133                         unregister_netdevice(bond_dev);
 134                 } else {
 135                         pr_err("unable to delete non-existent %s\n", ifname);
 136                         res = -ENODEV;
 137                 }
 138                 rtnl_unlock();
 139         } else
 140                 goto err_no_cmd;
 141
 142         /* Always return either count or an error.  If you return 0, you'll
 143          * get called forever, which is bad.
 144          */
 145         return res;
 146
 147 err_no_cmd:
 148         pr_err("no command found in bonding_masters. Use +ifname or -ifname.\n");
 149         return -EPERM;
 150 }
 151
 152 /* class attribute for bond_masters file.  This ends up in /sys/class/net */
 153 static const struct class_attribute class_attr_bonding_masters = {
 154         .attr = {
 155                 .name = "bonding_masters",
 156                 .mode = S_IWUSR | S_IRUGO,
 157         },
 158         .show = bonding_show_bonds,
 159         .store = bonding_store_bonds,
 160 };
 161
 162 /*
 163  * Show the slaves in the current bond.
 164  */
 165 static ssize_t bonding_show_slaves(struct device *d,
 166                                    struct device_attribute *attr, char *buf)
 167 {
 168         struct bonding *bond = to_bond(d);
 169         struct list_head *iter;
 170         struct slave *slave;
 171         int res = 0;
 172
 173         if (!rtnl_trylock())
 174                 return restart_syscall();
 175
 176         bond_for_each_slave(bond, slave, iter) {
 177                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
 178                         /* not enough space for another interface name */
 179                         if ((PAGE_SIZE - res) > 10)
 180                                 res = PAGE_SIZE - 10;
 181                         res += sprintf(buf + res, "++more++ ");
 182                         break;
 183                 }
 184                 res += sprintf(buf + res, "%s ", slave->dev->name);
 185         }
 186
 187         rtnl_unlock();
 188
 189         if (res)
 190                 buf[res-1] = '\n'; /* eat the leftover space */
 191
 192         return res;
 193 }
 194
 195 /*
 196  * Set the slaves in the current bond.
 197  * This is supposed to be only thin wrapper for bond_enslave and bond_release.
 198  * All hard work should be done there.
 199  */
 200 static ssize_t bonding_store_slaves(struct device *d,
 201                                     struct device_attribute *attr,
 202                                     const char *buffer, size_t count)
 203 {
 204         char command[IFNAMSIZ + 1] = { 0, };
 205         char *ifname;
 206         int res, ret = count;
 207         struct net_device *dev;
 208         struct bonding *bond = to_bond(d);
 209
 210         if (!rtnl_trylock())
 211                 return restart_syscall();
 212
 213         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
 214         ifname = command + 1;
 215         if ((strlen(command) <= 1) ||
 216             !dev_valid_name(ifname))
 217                 goto err_no_cmd;
 218
 219         dev = __dev_get_by_name(dev_net(bond->dev), ifname);
 220         if (!dev) {
 221                 pr_info("%s: Interface %s does not exist!\n",
 222                         bond->dev->name, ifname);
 223                 ret = -ENODEV;
 224                 goto out;
 225         }
 226
 227         switch (command[0]) {
 228         case '+':
 229                 pr_info("%s: Adding slave %s.\n", bond->dev->name, dev->name);
 230                 res = bond_enslave(bond->dev, dev);
 231                 break;
 232
 233         case '-':
 234                 pr_info("%s: Removing slave %s.\n", bond->dev->name, dev->name);
 235                 res = bond_release(bond->dev, dev);
 236                 break;
 237
 238         default:
 239                 goto err_no_cmd;
 240         }
 241
 242         if (res)
 243                 ret = res;
 244         goto out;
 245
 246 err_no_cmd:
 247         pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n",
 248                bond->dev->name);
 249         ret = -EPERM;
 250
 251 out:
 252         rtnl_unlock();
 253         return ret;
 254 }
 255
 256 static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves,
 257                    bonding_store_slaves);
 258
 259 /*
 260  * Show and set the bonding mode.  The bond interface must be down to
 261  * change the mode.
 262  */
 263 static ssize_t bonding_show_mode(struct device *d,
 264                                  struct device_attribute *attr, char *buf)
 265 {
 266         struct bonding *bond = to_bond(d);
 267
 268         return sprintf(buf, "%s %d\n",
 269                         bond_mode_tbl[bond->params.mode].modename,
 270                         bond->params.mode);
 271 }
 272
 273 static ssize_t bonding_store_mode(struct device *d,
 274                                   struct device_attribute *attr,
 275                                   const char *buf, size_t count)
 276 {
 277         int new_value, ret;
 278         struct bonding *bond = to_bond(d);
 279
 280         new_value = bond_parse_parm(buf, bond_mode_tbl);
 281         if (new_value < 0)  {
 282                 pr_err("%s: Ignoring invalid mode value %.*s.\n",
 283                        bond->dev->name, (int)strlen(buf) - 1, buf);
 284                 return -EINVAL;
 285         }
 286         if (!rtnl_trylock())
 287                 return restart_syscall();
 288
 289         ret = bond_option_mode_set(bond, new_value);
 290         if (!ret) {
 291                 pr_info("%s: setting mode to %s (%d).\n",
 292                         bond->dev->name, bond_mode_tbl[new_value].modename,
 293                         new_value);
 294                 ret = count;
 295         }
 296
 297         rtnl_unlock();
 298         return ret;
 299 }
 300 static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 301                    bonding_show_mode, bonding_store_mode);
 302
 303 /*
 304  * Show and set the bonding transmit hash method.
 305  */
 306 static ssize_t bonding_show_xmit_hash(struct device *d,
 307                                       struct device_attribute *attr,
 308                                       char *buf)
 309 {
 310         struct bonding *bond = to_bond(d);
 311
 312         return sprintf(buf, "%s %d\n",
 313                        xmit_hashtype_tbl[bond->params.xmit_policy].modename,
 314                        bond->params.xmit_policy);
 315 }
 316
 317 static ssize_t bonding_store_xmit_hash(struct device *d,
 318                                        struct device_attribute *attr,
 319                                        const char *buf, size_t count)
 320 {
 321         int new_value, ret;
 322         struct bonding *bond = to_bond(d);
 323
 324         new_value = bond_parse_parm(buf, xmit_hashtype_tbl);
 325         if (new_value < 0)  {
 326                 pr_err("%s: Ignoring invalid xmit hash policy value %.*s.\n",
 327                        bond->dev->name,
 328                        (int)strlen(buf) - 1, buf);
 329                 return -EINVAL;
 330         }
 331
 332         if (!rtnl_trylock())
 333                 return restart_syscall();
 334
 335         ret = bond_option_xmit_hash_policy_set(bond, new_value);
 336         if (!ret)
 337                 ret = count;
 338
 339         rtnl_unlock();
 340         return ret;
 341 }
 342 static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR,
 343                    bonding_show_xmit_hash, bonding_store_xmit_hash);
 344
 345 /*
 346  * Show and set arp_validate.
 347  */
 348 static ssize_t bonding_show_arp_validate(struct device *d,
 349                                          struct device_attribute *attr,
 350                                          char *buf)
 351 {
 352         struct bonding *bond = to_bond(d);
 353
 354         return sprintf(buf, "%s %d\n",
 355                        arp_validate_tbl[bond->params.arp_validate].modename,
 356                        bond->params.arp_validate);
 357 }
 358
 359 static ssize_t bonding_store_arp_validate(struct device *d,
 360                                           struct device_attribute *attr,
 361                                           const char *buf, size_t count)
 362 {
 363         struct bonding *bond = to_bond(d);
 364         int new_value, ret;
 365
 366         new_value = bond_parse_parm(buf, arp_validate_tbl);
 367         if (new_value < 0) {
 368                 pr_err("%s: Ignoring invalid arp_validate value %s\n",
 369                        bond->dev->name, buf);
 370                 return -EINVAL;
 371         }
 372         if (!rtnl_trylock())
 373                 return restart_syscall();
 374
 375         ret = bond_option_arp_validate_set(bond, new_value);
 376         if (!ret)
 377                 ret = count;
 378
 379         rtnl_unlock();
 380
 381         return ret;
 382 }
 383
 384 static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate,
 385                    bonding_store_arp_validate);
 386 /*
 387  * Show and set arp_all_targets.
 388  */
 389 static ssize_t bonding_show_arp_all_targets(struct device *d,
 390                                          struct device_attribute *attr,
 391                                          char *buf)
 392 {
 393         struct bonding *bond = to_bond(d);
 394         int value = bond->params.arp_all_targets;
 395
 396         return sprintf(buf, "%s %d\n", arp_all_targets_tbl[value].modename,
 397                        value);
 398 }
 399
 400 static ssize_t bonding_store_arp_all_targets(struct device *d,
 401                                           struct device_attribute *attr,
 402                                           const char *buf, size_t count)
 403 {
 404         struct bonding *bond = to_bond(d);
 405         int new_value, ret;
 406
 407         new_value = bond_parse_parm(buf, arp_all_targets_tbl);
 408         if (new_value < 0) {
 409                 pr_err("%s: Ignoring invalid arp_all_targets value %s\n",
 410                        bond->dev->name, buf);
 411                 return -EINVAL;
 412         }
 413
 414         if (!rtnl_trylock())
 415                 return restart_syscall();
 416
 417         ret = bond_option_arp_all_targets_set(bond, new_value);
 418         if (!ret)
 419                 ret = count;
 420
 421         rtnl_unlock();
 422
 423         return ret;
 424 }
 425
 426 static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR,
 427                    bonding_show_arp_all_targets, bonding_store_arp_all_targets);
 428
 429 /*
 430  * Show and store fail_over_mac.  User only allowed to change the
 431  * value when there are no slaves.
 432  */
 433 static ssize_t bonding_show_fail_over_mac(struct device *d,
 434                                           struct device_attribute *attr,
 435                                           char *buf)
 436 {
 437         struct bonding *bond = to_bond(d);
 438
 439         return sprintf(buf, "%s %d\n",
 440                        fail_over_mac_tbl[bond->params.fail_over_mac].modename,
 441                        bond->params.fail_over_mac);
 442 }
 443
 444 static ssize_t bonding_store_fail_over_mac(struct device *d,
 445                                            struct device_attribute *attr,
 446                                            const char *buf, size_t count)
 447 {
 448         int new_value, ret;
 449         struct bonding *bond = to_bond(d);
 450
 451         new_value = bond_parse_parm(buf, fail_over_mac_tbl);
 452         if (new_value < 0) {
 453                 pr_err("%s: Ignoring invalid fail_over_mac value %s.\n",
 454                        bond->dev->name, buf);
 455                 return -EINVAL;
 456         }
 457
 458         if (!rtnl_trylock())
 459                 return restart_syscall();
 460
 461         ret = bond_option_fail_over_mac_set(bond, new_value);
 462         if (!ret)
 463                 ret = count;
 464
 465         rtnl_unlock();
 466         return ret;
 467 }
 468
 469 static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR,
 470                    bonding_show_fail_over_mac, bonding_store_fail_over_mac);
 471
 472 /*
 473  * Show and set the arp timer interval.  There are two tricky bits
 474  * here.  First, if ARP monitoring is activated, then we must disable
 475  * MII monitoring.  Second, if the ARP timer isn't running, we must
 476  * start it.
 477  */
 478 static ssize_t bonding_show_arp_interval(struct device *d,
 479                                          struct device_attribute *attr,
 480                                          char *buf)
 481 {
 482         struct bonding *bond = to_bond(d);
 483
 484         return sprintf(buf, "%d\n", bond->params.arp_interval);
 485 }
 486
 487 static ssize_t bonding_store_arp_interval(struct device *d,
 488                                           struct device_attribute *attr,
 489                                           const char *buf, size_t count)
 490 {
 491         struct bonding *bond = to_bond(d);
 492         int new_value, ret;
 493
 494         if (sscanf(buf, "%d", &new_value) != 1) {
 495                 pr_err("%s: no arp_interval value specified.\n",
 496                 bond->dev->name);
 497                 return -EINVAL;
 498         }
 499
 500         if (!rtnl_trylock())
 501                 return restart_syscall();
 502
 503         ret = bond_option_arp_interval_set(bond, new_value);
 504         if (!ret)
 505                 ret = count;
 506
 507         rtnl_unlock();
 508         return ret;
 509 }
 510 static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR,
 511                    bonding_show_arp_interval, bonding_store_arp_interval);
 512
 513 /*
 514  * Show and set the arp targets.
 515  */
 516 static ssize_t bonding_show_arp_targets(struct device *d,
 517                                         struct device_attribute *attr,
 518                                         char *buf)
 519 {
 520         int i, res = 0;
 521         struct bonding *bond = to_bond(d);
 522
 523         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 524                 if (bond->params.arp_targets[i])
 525                         res += sprintf(buf + res, "%pI4 ",
 526                                        &bond->params.arp_targets[i]);
 527         }
 528         if (res)
 529                 buf[res-1] = '\n'; /* eat the leftover space */
 530         return res;
 531 }
 532
 533 static ssize_t bonding_store_arp_targets(struct device *d,
 534                                          struct device_attribute *attr,
 535                                          const char *buf, size_t count)
 536 {
 537         struct bonding *bond = to_bond(d);
 538         __be32 target;
 539         int ret = -EPERM;
 540
 541         if (!in4_pton(buf + 1, -1, (u8 *)&target, -1, NULL)) {
 542                 pr_err("%s: invalid ARP target %pI4 specified\n",
 543                        bond->dev->name, &target);
 544                 return -EPERM;
 545         }
 546
 547         if (!rtnl_trylock())
 548                 return restart_syscall();
 549
 550         if (buf[0] == '+')
 551                 ret = bond_option_arp_ip_target_add(bond, target);
 552         else if (buf[0] == '-')
 553                 ret = bond_option_arp_ip_target_rem(bond, target);
 554         else
 555                 pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
 556                        bond->dev->name);
 557
 558         if (!ret)
 559                 ret = count;
 560
 561         rtnl_unlock();
 562         return ret;
 563 }
 564 static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
 565
 566 /*
 567  * Show and set the up and down delays.  These must be multiples of the
 568  * MII monitoring value, and are stored internally as the multiplier.
 569  * Thus, we must translate to MS for the real world.
 570  */
 571 static ssize_t bonding_show_downdelay(struct device *d,
 572                                       struct device_attribute *attr,
 573                                       char *buf)
 574 {
 575         struct bonding *bond = to_bond(d);
 576
 577         return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
 578 }
 579
 580 static ssize_t bonding_store_downdelay(struct device *d,
 581                                        struct device_attribute *attr,
 582                                        const char *buf, size_t count)
 583 {
 584         int new_value, ret;
 585         struct bonding *bond = to_bond(d);
 586
 587         if (sscanf(buf, "%d", &new_value) != 1) {
 588                 pr_err("%s: no down delay value specified.\n", bond->dev->name);
 589                 return -EINVAL;
 590         }
 591
 592         if (!rtnl_trylock())
 593                 return restart_syscall();
 594
 595         ret = bond_option_downdelay_set(bond, new_value);
 596         if (!ret)
 597                 ret = count;
 598
 599         rtnl_unlock();
 600         return ret;
 601 }
 602 static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR,
 603                    bonding_show_downdelay, bonding_store_downdelay);
 604
 605 static ssize_t bonding_show_updelay(struct device *d,
 606                                     struct device_attribute *attr,
 607                                     char *buf)
 608 {
 609         struct bonding *bond = to_bond(d);
 610
 611         return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon);
 612
 613 }
 614
 615 static ssize_t bonding_store_updelay(struct device *d,
 616                                      struct device_attribute *attr,
 617                                      const char *buf, size_t count)
 618 {
 619         int new_value, ret;
 620         struct bonding *bond = to_bond(d);
 621
 622         if (sscanf(buf, "%d", &new_value) != 1) {
 623                 pr_err("%s: no up delay value specified.\n",
 624                 bond->dev->name);
 625                 return -EINVAL;
 626         }
 627
 628         if (!rtnl_trylock())
 629                 return restart_syscall();
 630
 631         ret = bond_option_updelay_set(bond, new_value);
 632         if (!ret)
 633                 ret = count;
 634
 635         rtnl_unlock();
 636         return ret;
 637 }
 638 static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR,
 639                    bonding_show_updelay, bonding_store_updelay);
 640
 641 /*
 642  * Show and set the LACP interval.  Interface must be down, and the mode
 643  * must be set to 802.3ad mode.
 644  */
 645 static ssize_t bonding_show_lacp(struct device *d,
 646                                  struct device_attribute *attr,
 647                                  char *buf)
 648 {
 649         struct bonding *bond = to_bond(d);
 650
 651         return sprintf(buf, "%s %d\n",
 652                 bond_lacp_tbl[bond->params.lacp_fast].modename,
 653                 bond->params.lacp_fast);
 654 }
 655
 656 static ssize_t bonding_store_lacp(struct device *d,
 657                                   struct device_attribute *attr,
 658                                   const char *buf, size_t count)
 659 {
 660         struct bonding *bond = to_bond(d);
 661         int new_value, ret;
 662
 663         new_value = bond_parse_parm(buf, bond_lacp_tbl);
 664         if (new_value < 0) {
 665                 pr_err("%s: Ignoring invalid LACP rate value %.*s.\n",
 666                        bond->dev->name, (int)strlen(buf) - 1, buf);
 667                 return -EINVAL;
 668         }
 669
 670         if (!rtnl_trylock())
 671                 return restart_syscall();
 672
 673         ret = bond_option_lacp_rate_set(bond, new_value);
 674         if (!ret)
 675                 ret = count;
 676
 677         rtnl_unlock();
 678         return ret;
 679 }
 680 static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR,
 681                    bonding_show_lacp, bonding_store_lacp);
 682
 683 static ssize_t bonding_show_min_links(struct device *d,
 684                                       struct device_attribute *attr,
 685                                       char *buf)
 686 {
 687         struct bonding *bond = to_bond(d);
 688
 689         return sprintf(buf, "%d\n", bond->params.min_links);
 690 }
 691
 692 static ssize_t bonding_store_min_links(struct device *d,
 693                                        struct device_attribute *attr,
 694                                        const char *buf, size_t count)
 695 {
 696         struct bonding *bond = to_bond(d);
 697         int ret;
 698         unsigned int new_value;
 699
 700         ret = kstrtouint(buf, 0, &new_value);
 701         if (ret < 0) {
 702                 pr_err("%s: Ignoring invalid min links value %s.\n",
 703                        bond->dev->name, buf);
 704                 return ret;
 705         }
 706
 707         if (!rtnl_trylock())
 708                 return restart_syscall();
 709
 710         ret = bond_option_min_links_set(bond, new_value);
 711         if (!ret)
 712                 ret = count;
 713
 714         rtnl_unlock();
 715         return ret;
 716 }
 717 static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR,
 718                    bonding_show_min_links, bonding_store_min_links);
 719
 720 static ssize_t bonding_show_ad_select(struct device *d,
 721                                       struct device_attribute *attr,
 722                                       char *buf)
 723 {
 724         struct bonding *bond = to_bond(d);
 725
 726         return sprintf(buf, "%s %d\n",
 727                 ad_select_tbl[bond->params.ad_select].modename,
 728                 bond->params.ad_select);
 729 }
 730
 731
 732 static ssize_t bonding_store_ad_select(struct device *d,
 733                                        struct device_attribute *attr,
 734                                        const char *buf, size_t count)
 735 {
 736         int new_value, ret;
 737         struct bonding *bond = to_bond(d);
 738
 739         new_value = bond_parse_parm(buf, ad_select_tbl);
 740         if (new_value < 0) {
 741                 pr_err("%s: Ignoring invalid ad_select value %.*s.\n",
 742                        bond->dev->name, (int)strlen(buf) - 1, buf);
 743                 return -EINVAL;
 744         }
 745
 746         if (!rtnl_trylock())
 747                 return restart_syscall();
 748
 749         ret = bond_option_ad_select_set(bond, new_value);
 750         if (!ret)
 751                 ret = count;
 752
 753         rtnl_unlock();
 754         return ret;
 755 }
 756 static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR,
 757                    bonding_show_ad_select, bonding_store_ad_select);
 758
 759 /*
 760  * Show and set the number of peer notifications to send after a failover event.
 761  */
 762 static ssize_t bonding_show_num_peer_notif(struct device *d,
 763                                            struct device_attribute *attr,
 764                                            char *buf)
 765 {
 766         struct bonding *bond = to_bond(d);
 767         return sprintf(buf, "%d\n", bond->params.num_peer_notif);
 768 }
 769
 770 static ssize_t bonding_store_num_peer_notif(struct device *d,
 771                                             struct device_attribute *attr,
 772                                             const char *buf, size_t count)
 773 {
 774         struct bonding *bond = to_bond(d);
 775         u8 new_value;
 776         int ret;
 777
 778         ret = kstrtou8(buf, 10, &new_value);
 779         if (!ret) {
 780                 pr_err("%s: invalid value %s specified.\n",
 781                        bond->dev->name, buf);
 782                 return ret;
 783         }
 784
 785         if (!rtnl_trylock())
 786                 return restart_syscall();
 787
 788         ret = bond_option_num_peer_notif_set(bond, new_value);
 789         if (!ret)
 790                 ret = count;
 791
 792         rtnl_unlock();
 793         return ret;
 794 }
 795 static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR,
 796                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 797 static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR,
 798                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 799
 800 /*
 801  * Show and set the MII monitor interval.  There are two tricky bits
 802  * here.  First, if MII monitoring is activated, then we must disable
 803  * ARP monitoring.  Second, if the timer isn't running, we must
 804  * start it.
 805  */
 806 static ssize_t bonding_show_miimon(struct device *d,
 807                                    struct device_attribute *attr,
 808                                    char *buf)
 809 {
 810         struct bonding *bond = to_bond(d);
 811
 812         return sprintf(buf, "%d\n", bond->params.miimon);
 813 }
 814
 815 static ssize_t bonding_store_miimon(struct device *d,
 816                                     struct device_attribute *attr,
 817                                     const char *buf, size_t count)
 818 {
 819         int new_value, ret;
 820         struct bonding *bond = to_bond(d);
 821
 822         if (sscanf(buf, "%d", &new_value) != 1) {
 823                 pr_err("%s: no miimon value specified.\n",
 824                        bond->dev->name);
 825                 return -EINVAL;
 826         }
 827
 828         if (!rtnl_trylock())
 829                 return restart_syscall();
 830
 831         ret = bond_option_miimon_set(bond, new_value);
 832         if (!ret)
 833                 ret = count;
 834
 835         rtnl_unlock();
 836         return ret;
 837 }
 838 static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
 839                    bonding_show_miimon, bonding_store_miimon);
 840
 841 /*
 842  * Show and set the primary slave.  The store function is much
 843  * simpler than bonding_store_slaves function because it only needs to
 844  * handle one interface name.
 845  * The bond must be a mode that supports a primary for this be
 846  * set.
 847  */
 848 static ssize_t bonding_show_primary(struct device *d,
 849                                     struct device_attribute *attr,
 850                                     char *buf)
 851 {
 852         int count = 0;
 853         struct bonding *bond = to_bond(d);
 854
 855         if (bond->primary_slave)
 856                 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
 857
 858         return count;
 859 }
 860
 861 static ssize_t bonding_store_primary(struct device *d,
 862                                      struct device_attribute *attr,
 863                                      const char *buf, size_t count)
 864 {
 865         struct bonding *bond = to_bond(d);
 866         char ifname[IFNAMSIZ];
 867         int ret;
 868
 869         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
 870         if (ifname[0] == '\n')
 871                 ifname[0] = '\0';
 872
 873         if (!rtnl_trylock())
 874                 return restart_syscall();
 875
 876         ret = bond_option_primary_set(bond, ifname);
 877         if (!ret)
 878                 ret = count;
 879
 880         rtnl_unlock();
 881         return ret;
 882 }
 883 static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR,
 884                    bonding_show_primary, bonding_store_primary);
 885
 886 /*
 887  * Show and set the primary_reselect flag.
 888  */
 889 static ssize_t bonding_show_primary_reselect(struct device *d,
 890                                              struct device_attribute *attr,
 891                                              char *buf)
 892 {
 893         struct bonding *bond = to_bond(d);
 894
 895         return sprintf(buf, "%s %d\n",
 896                        pri_reselect_tbl[bond->params.primary_reselect].modename,
 897                        bond->params.primary_reselect);
 898 }
 899
 900 static ssize_t bonding_store_primary_reselect(struct device *d,
 901                                               struct device_attribute *attr,
 902                                               const char *buf, size_t count)
 903 {
 904         int new_value, ret;
 905         struct bonding *bond = to_bond(d);
 906
 907         new_value = bond_parse_parm(buf, pri_reselect_tbl);
 908         if (new_value < 0)  {
 909                 pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n",
 910                        bond->dev->name,
 911                        (int) strlen(buf) - 1, buf);
 912                 return -EINVAL;
 913         }
 914
 915         if (!rtnl_trylock())
 916                 return restart_syscall();
 917
 918         ret = bond_option_primary_reselect_set(bond, new_value);
 919         if (!ret)
 920                 ret = count;
 921
 922         rtnl_unlock();
 923         return ret;
 924 }
 925 static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR,
 926                    bonding_show_primary_reselect,
 927                    bonding_store_primary_reselect);
 928
 929 /*
 930  * Show and set the use_carrier flag.
 931  */
 932 static ssize_t bonding_show_carrier(struct device *d,
 933                                     struct device_attribute *attr,
 934                                     char *buf)
 935 {
 936         struct bonding *bond = to_bond(d);
 937
 938         return sprintf(buf, "%d\n", bond->params.use_carrier);
 939 }
 940
 941 static ssize_t bonding_store_carrier(struct device *d,
 942                                      struct device_attribute *attr,
 943                                      const char *buf, size_t count)
 944 {
 945         int new_value, ret;
 946         struct bonding *bond = to_bond(d);
 947
 948         if (sscanf(buf, "%d", &new_value) != 1) {
 949                 pr_err("%s: no use_carrier value specified.\n",
 950                        bond->dev->name);
 951                 return -EINVAL;
 952         }
 953
 954         if (!rtnl_trylock())
 955                 return restart_syscall();
 956
 957         ret = bond_option_use_carrier_set(bond, new_value);
 958         if (!ret)
 959                 ret = count;
 960
 961         rtnl_unlock();
 962         return ret;
 963 }
 964 static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR,
 965                    bonding_show_carrier, bonding_store_carrier);
 966
 967
 968 /*
 969  * Show and set currently active_slave.
 970  */
 971 static ssize_t bonding_show_active_slave(struct device *d,
 972                                          struct device_attribute *attr,
 973                                          char *buf)
 974 {
 975         struct bonding *bond = to_bond(d);
 976         struct net_device *slave_dev;
 977         int count = 0;
 978
 979         rcu_read_lock();
 980         slave_dev = bond_option_active_slave_get_rcu(bond);
 981         if (slave_dev)
 982                 count = sprintf(buf, "%s\n", slave_dev->name);
 983         rcu_read_unlock();
 984
 985         return count;
 986 }
 987
 988 static ssize_t bonding_store_active_slave(struct device *d,
 989                                           struct device_attribute *attr,
 990                                           const char *buf, size_t count)
 991 {
 992         int ret;
 993         struct bonding *bond = to_bond(d);
 994         char ifname[IFNAMSIZ];
 995         struct net_device *dev;
 996
 997         if (!rtnl_trylock())
 998                 return restart_syscall();
 999
1000         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
1001         if (!strlen(ifname) || buf[0] == '\n') {
1002                 dev = NULL;
1003         } else {
1004                 dev = __dev_get_by_name(dev_net(bond->dev), ifname);
1005                 if (!dev) {
1006                         ret = -ENODEV;
1007                         goto out;
1008                 }
1009         }
1010
1011         ret = bond_option_active_slave_set(bond, dev);
1012         if (!ret)
1013                 ret = count;
1014
1015  out:
1016         rtnl_unlock();
1017
1018         return ret;
1019
1020 }
1021 static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR,
1022                    bonding_show_active_slave, bonding_store_active_slave);
1023
1024
1025 /*
1026  * Show link status of the bond interface.
1027  */
1028 static ssize_t bonding_show_mii_status(struct device *d,
1029                                        struct device_attribute *attr,
1030                                        char *buf)
1031 {
1032         struct bonding *bond = to_bond(d);
1033
1034         return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down");
1035 }
1036 static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
1037
1038 /*
1039  * Show current 802.3ad aggregator ID.
1040  */
1041 static ssize_t bonding_show_ad_aggregator(struct device *d,
1042                                           struct device_attribute *attr,
1043                                           char *buf)
1044 {
1045         int count = 0;
1046         struct bonding *bond = to_bond(d);
1047
1048         if (bond->params.mode == BOND_MODE_8023AD) {
1049                 struct ad_info ad_info;
1050                 count = sprintf(buf, "%d\n",
1051                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1052                                 ?  0 : ad_info.aggregator_id);
1053         }
1054
1055         return count;
1056 }
1057 static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
1058
1059
1060 /*
1061  * Show number of active 802.3ad ports.
1062  */
1063 static ssize_t bonding_show_ad_num_ports(struct device *d,
1064                                          struct device_attribute *attr,
1065                                          char *buf)
1066 {
1067         int count = 0;
1068         struct bonding *bond = to_bond(d);
1069
1070         if (bond->params.mode == BOND_MODE_8023AD) {
1071                 struct ad_info ad_info;
1072                 count = sprintf(buf, "%d\n",
1073                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1074                                 ?  0 : ad_info.ports);
1075         }
1076
1077         return count;
1078 }
1079 static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
1080
1081
1082 /*
1083  * Show current 802.3ad actor key.
1084  */
1085 static ssize_t bonding_show_ad_actor_key(struct device *d,
1086                                          struct device_attribute *attr,
1087                                          char *buf)
1088 {
1089         int count = 0;
1090         struct bonding *bond = to_bond(d);
1091
1092         if (bond->params.mode == BOND_MODE_8023AD) {
1093                 struct ad_info ad_info;
1094                 count = sprintf(buf, "%d\n",
1095                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1096                                 ?  0 : ad_info.actor_key);
1097         }
1098
1099         return count;
1100 }
1101 static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
1102
1103
1104 /*
1105  * Show current 802.3ad partner key.
1106  */
1107 static ssize_t bonding_show_ad_partner_key(struct device *d,
1108                                            struct device_attribute *attr,
1109                                            char *buf)
1110 {
1111         int count = 0;
1112         struct bonding *bond = to_bond(d);
1113
1114         if (bond->params.mode == BOND_MODE_8023AD) {
1115                 struct ad_info ad_info;
1116                 count = sprintf(buf, "%d\n",
1117                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1118                                 ?  0 : ad_info.partner_key);
1119         }
1120
1121         return count;
1122 }
1123 static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1124
1125
1126 /*
1127  * Show current 802.3ad partner mac.
1128  */
1129 static ssize_t bonding_show_ad_partner_mac(struct device *d,
1130                                            struct device_attribute *attr,
1131                                            char *buf)
1132 {
1133         int count = 0;
1134         struct bonding *bond = to_bond(d);
1135
1136         if (bond->params.mode == BOND_MODE_8023AD) {
1137                 struct ad_info ad_info;
1138                 if (!bond_3ad_get_active_agg_info(bond, &ad_info))
1139                         count = sprintf(buf, "%pM\n", ad_info.partner_system);
1140         }
1141
1142         return count;
1143 }
1144 static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1145
1146 /*
1147  * Show the queue_ids of the slaves in the current bond.
1148  */
1149 static ssize_t bonding_show_queue_id(struct device *d,
1150                                      struct device_attribute *attr,
1151                                      char *buf)
1152 {
1153         struct bonding *bond = to_bond(d);
1154         struct list_head *iter;
1155         struct slave *slave;
1156         int res = 0;
1157
1158         if (!rtnl_trylock())
1159                 return restart_syscall();
1160
1161         bond_for_each_slave(bond, slave, iter) {
1162                 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
1163                         /* not enough space for another interface_name:queue_id pair */
1164                         if ((PAGE_SIZE - res) > 10)
1165                                 res = PAGE_SIZE - 10;
1166                         res += sprintf(buf + res, "++more++ ");
1167                         break;
1168                 }
1169                 res += sprintf(buf + res, "%s:%d ",
1170                                slave->dev->name, slave->queue_id);
1171         }
1172         if (res)
1173                 buf[res-1] = '\n'; /* eat the leftover space */
1174
1175         rtnl_unlock();
1176
1177         return res;
1178 }
1179
1180 /*
1181  * Set the queue_ids of the  slaves in the current bond.  The bond
1182  * interface must be enslaved for this to work.
1183  */
1184 static ssize_t bonding_store_queue_id(struct device *d,
1185                                       struct device_attribute *attr,
1186                                       const char *buffer, size_t count)
1187 {
1188         struct slave *slave, *update_slave;
1189         struct bonding *bond = to_bond(d);
1190         struct list_head *iter;
1191         u16 qid;
1192         int ret = count;
1193         char *delim;
1194         struct net_device *sdev = NULL;
1195
1196         if (!rtnl_trylock())
1197                 return restart_syscall();
1198
1199         /* delim will point to queue id if successful */
1200         delim = strchr(buffer, ':');
1201         if (!delim)
1202                 goto err_no_cmd;
1203
1204         /*
1205          * Terminate string that points to device name and bump it
1206          * up one, so we can read the queue id there.
1207          */
1208         *delim = '\0';
1209         if (sscanf(++delim, "%hd\n", &qid) != 1)
1210                 goto err_no_cmd;
1211
1212         /* Check buffer length, valid ifname and queue id */
1213         if (strlen(buffer) > IFNAMSIZ ||
1214             !dev_valid_name(buffer) ||
1215             qid > bond->dev->real_num_tx_queues)
1216                 goto err_no_cmd;
1217
1218         /* Get the pointer to that interface if it exists */
1219         sdev = __dev_get_by_name(dev_net(bond->dev), buffer);
1220         if (!sdev)
1221                 goto err_no_cmd;
1222
1223         /* Search for thes slave and check for duplicate qids */
1224         update_slave = NULL;
1225         bond_for_each_slave(bond, slave, iter) {
1226                 if (sdev == slave->dev)
1227                         /*
1228                          * We don't need to check the matching
1229                          * slave for dups, since we're overwriting it
1230                          */
1231                         update_slave = slave;
1232                 else if (qid && qid == slave->queue_id) {
1233                         goto err_no_cmd;
1234                 }
1235         }
1236
1237         if (!update_slave)
1238                 goto err_no_cmd;
1239
1240         /* Actually set the qids for the slave */
1241         update_slave->queue_id = qid;
1242
1243 out:
1244         rtnl_unlock();
1245         return ret;
1246
1247 err_no_cmd:
1248         pr_info("invalid input for queue_id set for %s.\n",
1249                 bond->dev->name);
1250         ret = -EPERM;
1251         goto out;
1252 }
1253
1254 static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id,
1255                    bonding_store_queue_id);
1256
1257
1258 /*
1259  * Show and set the all_slaves_active flag.
1260  */
1261 static ssize_t bonding_show_slaves_active(struct device *d,
1262                                           struct device_attribute *attr,
1263                                           char *buf)
1264 {
1265         struct bonding *bond = to_bond(d);
1266
1267         return sprintf(buf, "%d\n", bond->params.all_slaves_active);
1268 }
1269
1270 static ssize_t bonding_store_slaves_active(struct device *d,
1271                                            struct device_attribute *attr,
1272                                            const char *buf, size_t count)
1273 {
1274         struct bonding *bond = to_bond(d);
1275         int new_value, ret;
1276
1277         if (sscanf(buf, "%d", &new_value) != 1) {
1278                 pr_err("%s: no all_slaves_active value specified.\n",
1279                        bond->dev->name);
1280                 return -EINVAL;
1281         }
1282
1283         if (!rtnl_trylock())
1284                 return restart_syscall();
1285
1286         ret = bond_option_all_slaves_active_set(bond, new_value);
1287         if (!ret)
1288                 ret = count;
1289
1290         rtnl_unlock();
1291         return ret;
1292 }
1293 static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR,
1294                    bonding_show_slaves_active, bonding_store_slaves_active);
1295
1296 /*
1297  * Show and set the number of IGMP membership reports to send on link failure
1298  */
1299 static ssize_t bonding_show_resend_igmp(struct device *d,
1300                                         struct device_attribute *attr,
1301                                         char *buf)
1302 {
1303         struct bonding *bond = to_bond(d);
1304
1305         return sprintf(buf, "%d\n", bond->params.resend_igmp);
1306 }
1307
1308 static ssize_t bonding_store_resend_igmp(struct device *d,
1309                                          struct device_attribute *attr,
1310                                          const char *buf, size_t count)
1311 {
1312         int new_value, ret = count;
1313         struct bonding *bond = to_bond(d);
1314
1315         if (sscanf(buf, "%d", &new_value) != 1) {
1316                 pr_err("%s: no resend_igmp value specified.\n",
1317                        bond->dev->name);
1318                 return -EINVAL;
1319         }
1320
1321         if (!rtnl_trylock())
1322                 return restart_syscall();
1323
1324         ret = bond_option_resend_igmp_set(bond, new_value);
1325         if (!ret)
1326                 ret = count;
1327
1328         rtnl_unlock();
1329         return ret;
1330 }
1331
1332 static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR,
1333                    bonding_show_resend_igmp, bonding_store_resend_igmp);
1334
1335
1336 static ssize_t bonding_show_lp_interval(struct device *d,
1337                                         struct device_attribute *attr,
1338                                         char *buf)
1339 {
1340         struct bonding *bond = to_bond(d);
1341         return sprintf(buf, "%d\n", bond->params.lp_interval);
1342 }
1343
1344 static ssize_t bonding_store_lp_interval(struct device *d,
1345                                          struct device_attribute *attr,
1346                                          const char *buf, size_t count)
1347 {
1348         struct bonding *bond = to_bond(d);
1349         int new_value, ret;
1350
1351         if (sscanf(buf, "%d", &new_value) != 1) {
1352                 pr_err("%s: no lp interval value specified.\n",
1353                         bond->dev->name);
1354                 return -EINVAL;
1355         }
1356
1357         if (!rtnl_trylock())
1358                 return restart_syscall();
1359
1360         ret = bond_option_lp_interval_set(bond, new_value);
1361         if (!ret)
1362                 ret = count;
1363
1364         rtnl_unlock();
1365         return ret;
1366 }
1367
1368 static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR,
1369                    bonding_show_lp_interval, bonding_store_lp_interval);
1370
1371 static ssize_t bonding_show_packets_per_slave(struct device *d,
1372                                               struct device_attribute *attr,
1373                                               char *buf)
1374 {
1375         struct bonding *bond = to_bond(d);
1376         unsigned int packets_per_slave = bond->params.packets_per_slave;
1377
1378         if (packets_per_slave > 1)
1379                 packets_per_slave = reciprocal_value(packets_per_slave);
1380
1381         return sprintf(buf, "%u\n", packets_per_slave);
1382 }
1383
1384 static ssize_t bonding_store_packets_per_slave(struct device *d,
1385                                                struct device_attribute *attr,
1386                                                const char *buf, size_t count)
1387 {
1388         struct bonding *bond = to_bond(d);
1389         int new_value, ret;
1390
1391         if (sscanf(buf, "%d", &new_value) != 1) {
1392                 pr_err("%s: no packets_per_slave value specified.\n",
1393                        bond->dev->name);
1394                 return -EINVAL;
1395         }
1396
1397         if (!rtnl_trylock())
1398                 return restart_syscall();
1399
1400         ret = bond_option_packets_per_slave_set(bond, new_value);
1401         if (!ret)
1402                 ret = count;
1403
1404         rtnl_unlock();
1405         return ret;
1406 }
1407
1408 static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR,
1409                    bonding_show_packets_per_slave,
1410                    bonding_store_packets_per_slave);
1411
1412 static struct attribute *per_bond_attrs[] = {
1413         &dev_attr_slaves.attr,
1414         &dev_attr_mode.attr,
1415         &dev_attr_fail_over_mac.attr,
1416         &dev_attr_arp_validate.attr,
1417         &dev_attr_arp_all_targets.attr,
1418         &dev_attr_arp_interval.attr,
1419         &dev_attr_arp_ip_target.attr,
1420         &dev_attr_downdelay.attr,
1421         &dev_attr_updelay.attr,
1422         &dev_attr_lacp_rate.attr,
1423         &dev_attr_ad_select.attr,
1424         &dev_attr_xmit_hash_policy.attr,
1425         &dev_attr_num_grat_arp.attr,
1426         &dev_attr_num_unsol_na.attr,
1427         &dev_attr_miimon.attr,
1428         &dev_attr_primary.attr,
1429         &dev_attr_primary_reselect.attr,
1430         &dev_attr_use_carrier.attr,
1431         &dev_attr_active_slave.attr,
1432         &dev_attr_mii_status.attr,
1433         &dev_attr_ad_aggregator.attr,
1434         &dev_attr_ad_num_ports.attr,
1435         &dev_attr_ad_actor_key.attr,
1436         &dev_attr_ad_partner_key.attr,
1437         &dev_attr_ad_partner_mac.attr,
1438         &dev_attr_queue_id.attr,
1439         &dev_attr_all_slaves_active.attr,
1440         &dev_attr_resend_igmp.attr,
1441         &dev_attr_min_links.attr,
1442         &dev_attr_lp_interval.attr,
1443         &dev_attr_packets_per_slave.attr,
1444         NULL,
1445 };
1446
1447 static struct attribute_group bonding_group = {
1448         .name = "bonding",
1449         .attrs = per_bond_attrs,
1450 };
1451
1452 /*
1453  * Initialize sysfs.  This sets up the bonding_masters file in
1454  * /sys/class/net.
1455  */
1456 int bond_create_sysfs(struct bond_net *bn)
1457 {
1458         int ret;
1459
1460         bn->class_attr_bonding_masters = class_attr_bonding_masters;
1461         sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
1462
1463         ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
1464                                           bn->net);
1465         /*
1466          * Permit multiple loads of the module by ignoring failures to
1467          * create the bonding_masters sysfs file.  Bonding devices
1468          * created by second or subsequent loads of the module will
1469          * not be listed in, or controllable by, bonding_masters, but
1470          * will have the usual "bonding" sysfs directory.
1471          *
1472          * This is done to preserve backwards compatibility for
1473          * initscripts/sysconfig, which load bonding multiple times to
1474          * configure multiple bonding devices.
1475          */
1476         if (ret == -EEXIST) {
1477                 /* Is someone being kinky and naming a device bonding_master? */
1478                 if (__dev_get_by_name(bn->net,
1479                                       class_attr_bonding_masters.attr.name))
1480                         pr_err("network device named %s already exists in sysfs",
1481                                class_attr_bonding_masters.attr.name);
1482                 ret = 0;
1483         }
1484
1485         return ret;
1486
1487 }
1488
1489 /*
1490  * Remove /sys/class/net/bonding_masters.
1491  */
1492 void bond_destroy_sysfs(struct bond_net *bn)
1493 {
1494         netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
1495 }
1496
1497 /*
1498  * Initialize sysfs for each bond.  This sets up and registers
1499  * the 'bondctl' directory for each individual bond under /sys/class/net.
1500  */
1501 void bond_prepare_sysfs_group(struct bonding *bond)
1502 {
1503         bond->dev->sysfs_groups[0] = &bonding_group;
1504 }
1505