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