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 = count;
 662
 663         if (!rtnl_trylock())
 664                 return restart_syscall();
 665
 666         if (bond->dev->flags & IFF_UP) {
 667                 pr_err("%s: Unable to update LACP rate because interface is up.\n",
 668                        bond->dev->name);
 669                 ret = -EPERM;
 670                 goto out;
 671         }
 672
 673         if (bond->params.mode != BOND_MODE_8023AD) {
 674                 pr_err("%s: Unable to update LACP rate because bond is not in 802.3ad mode.\n",
 675                        bond->dev->name);
 676                 ret = -EPERM;
 677                 goto out;
 678         }
 679
 680         new_value = bond_parse_parm(buf, bond_lacp_tbl);
 681
 682         if ((new_value == 1) || (new_value == 0)) {
 683                 bond->params.lacp_fast = new_value;
 684                 bond_3ad_update_lacp_rate(bond);
 685                 pr_info("%s: Setting LACP rate to %s (%d).\n",
 686                         bond->dev->name, bond_lacp_tbl[new_value].modename,
 687                         new_value);
 688         } else {
 689                 pr_err("%s: Ignoring invalid LACP rate value %.*s.\n",
 690                        bond->dev->name, (int)strlen(buf) - 1, buf);
 691                 ret = -EINVAL;
 692         }
 693 out:
 694         rtnl_unlock();
 695
 696         return ret;
 697 }
 698 static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR,
 699                    bonding_show_lacp, bonding_store_lacp);
 700
 701 static ssize_t bonding_show_min_links(struct device *d,
 702                                       struct device_attribute *attr,
 703                                       char *buf)
 704 {
 705         struct bonding *bond = to_bond(d);
 706
 707         return sprintf(buf, "%d\n", bond->params.min_links);
 708 }
 709
 710 static ssize_t bonding_store_min_links(struct device *d,
 711                                        struct device_attribute *attr,
 712                                        const char *buf, size_t count)
 713 {
 714         struct bonding *bond = to_bond(d);
 715         int ret;
 716         unsigned int new_value;
 717
 718         ret = kstrtouint(buf, 0, &new_value);
 719         if (ret < 0) {
 720                 pr_err("%s: Ignoring invalid min links value %s.\n",
 721                        bond->dev->name, buf);
 722                 return ret;
 723         }
 724
 725         if (!rtnl_trylock())
 726                 return restart_syscall();
 727
 728         ret = bond_option_min_links_set(bond, new_value);
 729         if (!ret)
 730                 ret = count;
 731
 732         rtnl_unlock();
 733         return ret;
 734 }
 735 static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR,
 736                    bonding_show_min_links, bonding_store_min_links);
 737
 738 static ssize_t bonding_show_ad_select(struct device *d,
 739                                       struct device_attribute *attr,
 740                                       char *buf)
 741 {
 742         struct bonding *bond = to_bond(d);
 743
 744         return sprintf(buf, "%s %d\n",
 745                 ad_select_tbl[bond->params.ad_select].modename,
 746                 bond->params.ad_select);
 747 }
 748
 749
 750 static ssize_t bonding_store_ad_select(struct device *d,
 751                                        struct device_attribute *attr,
 752                                        const char *buf, size_t count)
 753 {
 754         int new_value, ret = count;
 755         struct bonding *bond = to_bond(d);
 756
 757         if (bond->dev->flags & IFF_UP) {
 758                 pr_err("%s: Unable to update ad_select because interface is up.\n",
 759                        bond->dev->name);
 760                 ret = -EPERM;
 761                 goto out;
 762         }
 763
 764         new_value = bond_parse_parm(buf, ad_select_tbl);
 765
 766         if (new_value != -1) {
 767                 bond->params.ad_select = new_value;
 768                 pr_info("%s: Setting ad_select to %s (%d).\n",
 769                         bond->dev->name, ad_select_tbl[new_value].modename,
 770                         new_value);
 771         } else {
 772                 pr_err("%s: Ignoring invalid ad_select value %.*s.\n",
 773                        bond->dev->name, (int)strlen(buf) - 1, buf);
 774                 ret = -EINVAL;
 775         }
 776 out:
 777         return ret;
 778 }
 779 static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR,
 780                    bonding_show_ad_select, bonding_store_ad_select);
 781
 782 /*
 783  * Show and set the number of peer notifications to send after a failover event.
 784  */
 785 static ssize_t bonding_show_num_peer_notif(struct device *d,
 786                                            struct device_attribute *attr,
 787                                            char *buf)
 788 {
 789         struct bonding *bond = to_bond(d);
 790         return sprintf(buf, "%d\n", bond->params.num_peer_notif);
 791 }
 792
 793 static ssize_t bonding_store_num_peer_notif(struct device *d,
 794                                             struct device_attribute *attr,
 795                                             const char *buf, size_t count)
 796 {
 797         struct bonding *bond = to_bond(d);
 798         u8 new_value;
 799         int ret;
 800
 801         ret = kstrtou8(buf, 10, &new_value);
 802         if (!ret) {
 803                 pr_err("%s: invalid value %s specified.\n",
 804                        bond->dev->name, buf);
 805                 return ret;
 806         }
 807
 808         if (!rtnl_trylock())
 809                 return restart_syscall();
 810
 811         ret = bond_option_num_peer_notif_set(bond, new_value);
 812         if (!ret)
 813                 ret = count;
 814
 815         rtnl_unlock();
 816         return ret;
 817 }
 818 static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR,
 819                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 820 static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR,
 821                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 822
 823 /*
 824  * Show and set the MII monitor interval.  There are two tricky bits
 825  * here.  First, if MII monitoring is activated, then we must disable
 826  * ARP monitoring.  Second, if the timer isn't running, we must
 827  * start it.
 828  */
 829 static ssize_t bonding_show_miimon(struct device *d,
 830                                    struct device_attribute *attr,
 831                                    char *buf)
 832 {
 833         struct bonding *bond = to_bond(d);
 834
 835         return sprintf(buf, "%d\n", bond->params.miimon);
 836 }
 837
 838 static ssize_t bonding_store_miimon(struct device *d,
 839                                     struct device_attribute *attr,
 840                                     const char *buf, size_t count)
 841 {
 842         int new_value, ret;
 843         struct bonding *bond = to_bond(d);
 844
 845         if (sscanf(buf, "%d", &new_value) != 1) {
 846                 pr_err("%s: no miimon value specified.\n",
 847                        bond->dev->name);
 848                 return -EINVAL;
 849         }
 850
 851         if (!rtnl_trylock())
 852                 return restart_syscall();
 853
 854         ret = bond_option_miimon_set(bond, new_value);
 855         if (!ret)
 856                 ret = count;
 857
 858         rtnl_unlock();
 859         return ret;
 860 }
 861 static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
 862                    bonding_show_miimon, bonding_store_miimon);
 863
 864 /*
 865  * Show and set the primary slave.  The store function is much
 866  * simpler than bonding_store_slaves function because it only needs to
 867  * handle one interface name.
 868  * The bond must be a mode that supports a primary for this be
 869  * set.
 870  */
 871 static ssize_t bonding_show_primary(struct device *d,
 872                                     struct device_attribute *attr,
 873                                     char *buf)
 874 {
 875         int count = 0;
 876         struct bonding *bond = to_bond(d);
 877
 878         if (bond->primary_slave)
 879                 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
 880
 881         return count;
 882 }
 883
 884 static ssize_t bonding_store_primary(struct device *d,
 885                                      struct device_attribute *attr,
 886                                      const char *buf, size_t count)
 887 {
 888         struct bonding *bond = to_bond(d);
 889         char ifname[IFNAMSIZ];
 890         int ret;
 891
 892         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
 893         if (ifname[0] == '\n')
 894                 ifname[0] = '\0';
 895
 896         if (!rtnl_trylock())
 897                 return restart_syscall();
 898
 899         ret = bond_option_primary_set(bond, ifname);
 900         if (!ret)
 901                 ret = count;
 902
 903         rtnl_unlock();
 904         return ret;
 905 }
 906 static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR,
 907                    bonding_show_primary, bonding_store_primary);
 908
 909 /*
 910  * Show and set the primary_reselect flag.
 911  */
 912 static ssize_t bonding_show_primary_reselect(struct device *d,
 913                                              struct device_attribute *attr,
 914                                              char *buf)
 915 {
 916         struct bonding *bond = to_bond(d);
 917
 918         return sprintf(buf, "%s %d\n",
 919                        pri_reselect_tbl[bond->params.primary_reselect].modename,
 920                        bond->params.primary_reselect);
 921 }
 922
 923 static ssize_t bonding_store_primary_reselect(struct device *d,
 924                                               struct device_attribute *attr,
 925                                               const char *buf, size_t count)
 926 {
 927         int new_value, ret;
 928         struct bonding *bond = to_bond(d);
 929
 930         new_value = bond_parse_parm(buf, pri_reselect_tbl);
 931         if (new_value < 0)  {
 932                 pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n",
 933                        bond->dev->name,
 934                        (int) strlen(buf) - 1, buf);
 935                 return -EINVAL;
 936         }
 937
 938         if (!rtnl_trylock())
 939                 return restart_syscall();
 940
 941         ret = bond_option_primary_reselect_set(bond, new_value);
 942         if (!ret)
 943                 ret = count;
 944
 945         rtnl_unlock();
 946         return ret;
 947 }
 948 static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR,
 949                    bonding_show_primary_reselect,
 950                    bonding_store_primary_reselect);
 951
 952 /*
 953  * Show and set the use_carrier flag.
 954  */
 955 static ssize_t bonding_show_carrier(struct device *d,
 956                                     struct device_attribute *attr,
 957                                     char *buf)
 958 {
 959         struct bonding *bond = to_bond(d);
 960
 961         return sprintf(buf, "%d\n", bond->params.use_carrier);
 962 }
 963
 964 static ssize_t bonding_store_carrier(struct device *d,
 965                                      struct device_attribute *attr,
 966                                      const char *buf, size_t count)
 967 {
 968         int new_value, ret;
 969         struct bonding *bond = to_bond(d);
 970
 971         if (sscanf(buf, "%d", &new_value) != 1) {
 972                 pr_err("%s: no use_carrier value specified.\n",
 973                        bond->dev->name);
 974                 return -EINVAL;
 975         }
 976
 977         if (!rtnl_trylock())
 978                 return restart_syscall();
 979
 980         ret = bond_option_use_carrier_set(bond, new_value);
 981         if (!ret)
 982                 ret = count;
 983
 984         rtnl_unlock();
 985         return ret;
 986 }
 987 static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR,
 988                    bonding_show_carrier, bonding_store_carrier);
 989
 990
 991 /*
 992  * Show and set currently active_slave.
 993  */
 994 static ssize_t bonding_show_active_slave(struct device *d,
 995                                          struct device_attribute *attr,
 996                                          char *buf)
 997 {
 998         struct bonding *bond = to_bond(d);
 999         struct net_device *slave_dev;
1000         int count = 0;
1001
1002         rcu_read_lock();
1003         slave_dev = bond_option_active_slave_get_rcu(bond);
1004         if (slave_dev)
1005                 count = sprintf(buf, "%s\n", slave_dev->name);
1006         rcu_read_unlock();
1007
1008         return count;
1009 }
1010
1011 static ssize_t bonding_store_active_slave(struct device *d,
1012                                           struct device_attribute *attr,
1013                                           const char *buf, size_t count)
1014 {
1015         int ret;
1016         struct bonding *bond = to_bond(d);
1017         char ifname[IFNAMSIZ];
1018         struct net_device *dev;
1019
1020         if (!rtnl_trylock())
1021                 return restart_syscall();
1022
1023         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
1024         if (!strlen(ifname) || buf[0] == '\n') {
1025                 dev = NULL;
1026         } else {
1027                 dev = __dev_get_by_name(dev_net(bond->dev), ifname);
1028                 if (!dev) {
1029                         ret = -ENODEV;
1030                         goto out;
1031                 }
1032         }
1033
1034         ret = bond_option_active_slave_set(bond, dev);
1035         if (!ret)
1036                 ret = count;
1037
1038  out:
1039         rtnl_unlock();
1040
1041         return ret;
1042
1043 }
1044 static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR,
1045                    bonding_show_active_slave, bonding_store_active_slave);
1046
1047
1048 /*
1049  * Show link status of the bond interface.
1050  */
1051 static ssize_t bonding_show_mii_status(struct device *d,
1052                                        struct device_attribute *attr,
1053                                        char *buf)
1054 {
1055         struct bonding *bond = to_bond(d);
1056
1057         return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down");
1058 }
1059 static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
1060
1061 /*
1062  * Show current 802.3ad aggregator ID.
1063  */
1064 static ssize_t bonding_show_ad_aggregator(struct device *d,
1065                                           struct device_attribute *attr,
1066                                           char *buf)
1067 {
1068         int count = 0;
1069         struct bonding *bond = to_bond(d);
1070
1071         if (bond->params.mode == BOND_MODE_8023AD) {
1072                 struct ad_info ad_info;
1073                 count = sprintf(buf, "%d\n",
1074                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1075                                 ?  0 : ad_info.aggregator_id);
1076         }
1077
1078         return count;
1079 }
1080 static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
1081
1082
1083 /*
1084  * Show number of active 802.3ad ports.
1085  */
1086 static ssize_t bonding_show_ad_num_ports(struct device *d,
1087                                          struct device_attribute *attr,
1088                                          char *buf)
1089 {
1090         int count = 0;
1091         struct bonding *bond = to_bond(d);
1092
1093         if (bond->params.mode == BOND_MODE_8023AD) {
1094                 struct ad_info ad_info;
1095                 count = sprintf(buf, "%d\n",
1096                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1097                                 ?  0 : ad_info.ports);
1098         }
1099
1100         return count;
1101 }
1102 static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
1103
1104
1105 /*
1106  * Show current 802.3ad actor key.
1107  */
1108 static ssize_t bonding_show_ad_actor_key(struct device *d,
1109                                          struct device_attribute *attr,
1110                                          char *buf)
1111 {
1112         int count = 0;
1113         struct bonding *bond = to_bond(d);
1114
1115         if (bond->params.mode == BOND_MODE_8023AD) {
1116                 struct ad_info ad_info;
1117                 count = sprintf(buf, "%d\n",
1118                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1119                                 ?  0 : ad_info.actor_key);
1120         }
1121
1122         return count;
1123 }
1124 static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
1125
1126
1127 /*
1128  * Show current 802.3ad partner key.
1129  */
1130 static ssize_t bonding_show_ad_partner_key(struct device *d,
1131                                            struct device_attribute *attr,
1132                                            char *buf)
1133 {
1134         int count = 0;
1135         struct bonding *bond = to_bond(d);
1136
1137         if (bond->params.mode == BOND_MODE_8023AD) {
1138                 struct ad_info ad_info;
1139                 count = sprintf(buf, "%d\n",
1140                                 bond_3ad_get_active_agg_info(bond, &ad_info)
1141                                 ?  0 : ad_info.partner_key);
1142         }
1143
1144         return count;
1145 }
1146 static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1147
1148
1149 /*
1150  * Show current 802.3ad partner mac.
1151  */
1152 static ssize_t bonding_show_ad_partner_mac(struct device *d,
1153                                            struct device_attribute *attr,
1154                                            char *buf)
1155 {
1156         int count = 0;
1157         struct bonding *bond = to_bond(d);
1158
1159         if (bond->params.mode == BOND_MODE_8023AD) {
1160                 struct ad_info ad_info;
1161                 if (!bond_3ad_get_active_agg_info(bond, &ad_info))
1162                         count = sprintf(buf, "%pM\n", ad_info.partner_system);
1163         }
1164
1165         return count;
1166 }
1167 static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1168
1169 /*
1170  * Show the queue_ids of the slaves in the current bond.
1171  */
1172 static ssize_t bonding_show_queue_id(struct device *d,
1173                                      struct device_attribute *attr,
1174                                      char *buf)
1175 {
1176         struct bonding *bond = to_bond(d);
1177         struct list_head *iter;
1178         struct slave *slave;
1179         int res = 0;
1180
1181         if (!rtnl_trylock())
1182                 return restart_syscall();
1183
1184         bond_for_each_slave(bond, slave, iter) {
1185                 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
1186                         /* not enough space for another interface_name:queue_id pair */
1187                         if ((PAGE_SIZE - res) > 10)
1188                                 res = PAGE_SIZE - 10;
1189                         res += sprintf(buf + res, "++more++ ");
1190                         break;
1191                 }
1192                 res += sprintf(buf + res, "%s:%d ",
1193                                slave->dev->name, slave->queue_id);
1194         }
1195         if (res)
1196                 buf[res-1] = '\n'; /* eat the leftover space */
1197
1198         rtnl_unlock();
1199
1200         return res;
1201 }
1202
1203 /*
1204  * Set the queue_ids of the  slaves in the current bond.  The bond
1205  * interface must be enslaved for this to work.
1206  */
1207 static ssize_t bonding_store_queue_id(struct device *d,
1208                                       struct device_attribute *attr,
1209                                       const char *buffer, size_t count)
1210 {
1211         struct slave *slave, *update_slave;
1212         struct bonding *bond = to_bond(d);
1213         struct list_head *iter;
1214         u16 qid;
1215         int ret = count;
1216         char *delim;
1217         struct net_device *sdev = NULL;
1218
1219         if (!rtnl_trylock())
1220                 return restart_syscall();
1221
1222         /* delim will point to queue id if successful */
1223         delim = strchr(buffer, ':');
1224         if (!delim)
1225                 goto err_no_cmd;
1226
1227         /*
1228          * Terminate string that points to device name and bump it
1229          * up one, so we can read the queue id there.
1230          */
1231         *delim = '\0';
1232         if (sscanf(++delim, "%hd\n", &qid) != 1)
1233                 goto err_no_cmd;
1234
1235         /* Check buffer length, valid ifname and queue id */
1236         if (strlen(buffer) > IFNAMSIZ ||
1237             !dev_valid_name(buffer) ||
1238             qid > bond->dev->real_num_tx_queues)
1239                 goto err_no_cmd;
1240
1241         /* Get the pointer to that interface if it exists */
1242         sdev = __dev_get_by_name(dev_net(bond->dev), buffer);
1243         if (!sdev)
1244                 goto err_no_cmd;
1245
1246         /* Search for thes slave and check for duplicate qids */
1247         update_slave = NULL;
1248         bond_for_each_slave(bond, slave, iter) {
1249                 if (sdev == slave->dev)
1250                         /*
1251                          * We don't need to check the matching
1252                          * slave for dups, since we're overwriting it
1253                          */
1254                         update_slave = slave;
1255                 else if (qid && qid == slave->queue_id) {
1256                         goto err_no_cmd;
1257                 }
1258         }
1259
1260         if (!update_slave)
1261                 goto err_no_cmd;
1262
1263         /* Actually set the qids for the slave */
1264         update_slave->queue_id = qid;
1265
1266 out:
1267         rtnl_unlock();
1268         return ret;
1269
1270 err_no_cmd:
1271         pr_info("invalid input for queue_id set for %s.\n",
1272                 bond->dev->name);
1273         ret = -EPERM;
1274         goto out;
1275 }
1276
1277 static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id,
1278                    bonding_store_queue_id);
1279
1280
1281 /*
1282  * Show and set the all_slaves_active flag.
1283  */
1284 static ssize_t bonding_show_slaves_active(struct device *d,
1285                                           struct device_attribute *attr,
1286                                           char *buf)
1287 {
1288         struct bonding *bond = to_bond(d);
1289
1290         return sprintf(buf, "%d\n", bond->params.all_slaves_active);
1291 }
1292
1293 static ssize_t bonding_store_slaves_active(struct device *d,
1294                                            struct device_attribute *attr,
1295                                            const char *buf, size_t count)
1296 {
1297         struct bonding *bond = to_bond(d);
1298         int new_value, ret;
1299
1300         if (sscanf(buf, "%d", &new_value) != 1) {
1301                 pr_err("%s: no all_slaves_active value specified.\n",
1302                        bond->dev->name);
1303                 return -EINVAL;
1304         }
1305
1306         if (!rtnl_trylock())
1307                 return restart_syscall();
1308
1309         ret = bond_option_all_slaves_active_set(bond, new_value);
1310         if (!ret)
1311                 ret = count;
1312
1313         rtnl_unlock();
1314         return ret;
1315 }
1316 static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR,
1317                    bonding_show_slaves_active, bonding_store_slaves_active);
1318
1319 /*
1320  * Show and set the number of IGMP membership reports to send on link failure
1321  */
1322 static ssize_t bonding_show_resend_igmp(struct device *d,
1323                                         struct device_attribute *attr,
1324                                         char *buf)
1325 {
1326         struct bonding *bond = to_bond(d);
1327
1328         return sprintf(buf, "%d\n", bond->params.resend_igmp);
1329 }
1330
1331 static ssize_t bonding_store_resend_igmp(struct device *d,
1332                                          struct device_attribute *attr,
1333                                          const char *buf, size_t count)
1334 {
1335         int new_value, ret = count;
1336         struct bonding *bond = to_bond(d);
1337
1338         if (sscanf(buf, "%d", &new_value) != 1) {
1339                 pr_err("%s: no resend_igmp value specified.\n",
1340                        bond->dev->name);
1341                 return -EINVAL;
1342         }
1343
1344         if (!rtnl_trylock())
1345                 return restart_syscall();
1346
1347         ret = bond_option_resend_igmp_set(bond, new_value);
1348         if (!ret)
1349                 ret = count;
1350
1351         rtnl_unlock();
1352         return ret;
1353 }
1354
1355 static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR,
1356                    bonding_show_resend_igmp, bonding_store_resend_igmp);
1357
1358
1359 static ssize_t bonding_show_lp_interval(struct device *d,
1360                                         struct device_attribute *attr,
1361                                         char *buf)
1362 {
1363         struct bonding *bond = to_bond(d);
1364         return sprintf(buf, "%d\n", bond->params.lp_interval);
1365 }
1366
1367 static ssize_t bonding_store_lp_interval(struct device *d,
1368                                          struct device_attribute *attr,
1369                                          const char *buf, size_t count)
1370 {
1371         struct bonding *bond = to_bond(d);
1372         int new_value, ret = count;
1373
1374         if (sscanf(buf, "%d", &new_value) != 1) {
1375                 pr_err("%s: no lp interval value specified.\n",
1376                         bond->dev->name);
1377                 ret = -EINVAL;
1378                 goto out;
1379         }
1380
1381         if (new_value <= 0) {
1382                 pr_err ("%s: lp_interval must be between 1 and %d\n",
1383                         bond->dev->name, INT_MAX);
1384                 ret = -EINVAL;
1385                 goto out;
1386         }
1387
1388         bond->params.lp_interval = new_value;
1389 out:
1390         return ret;
1391 }
1392
1393 static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR,
1394                    bonding_show_lp_interval, bonding_store_lp_interval);
1395
1396 static ssize_t bonding_show_packets_per_slave(struct device *d,
1397                                               struct device_attribute *attr,
1398                                               char *buf)
1399 {
1400         struct bonding *bond = to_bond(d);
1401         unsigned int packets_per_slave = bond->params.packets_per_slave;
1402
1403         if (packets_per_slave > 1)
1404                 packets_per_slave = reciprocal_value(packets_per_slave);
1405
1406         return sprintf(buf, "%u\n", packets_per_slave);
1407 }
1408
1409 static ssize_t bonding_store_packets_per_slave(struct device *d,
1410                                                struct device_attribute *attr,
1411                                                const char *buf, size_t count)
1412 {
1413         struct bonding *bond = to_bond(d);
1414         int new_value, ret = count;
1415
1416         if (sscanf(buf, "%d", &new_value) != 1) {
1417                 pr_err("%s: no packets_per_slave value specified.\n",
1418                        bond->dev->name);
1419                 ret = -EINVAL;
1420                 goto out;
1421         }
1422         if (new_value < 0 || new_value > USHRT_MAX) {
1423                 pr_err("%s: packets_per_slave must be between 0 and %u\n",
1424                        bond->dev->name, USHRT_MAX);
1425                 ret = -EINVAL;
1426                 goto out;
1427         }
1428         if (bond->params.mode != BOND_MODE_ROUNDROBIN)
1429                 pr_warn("%s: Warning: packets_per_slave has effect only in balance-rr mode\n",
1430                         bond->dev->name);
1431         if (new_value > 1)
1432                 bond->params.packets_per_slave = reciprocal_value(new_value);
1433         else
1434                 bond->params.packets_per_slave = new_value;
1435 out:
1436         return ret;
1437 }
1438
1439 static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR,
1440                    bonding_show_packets_per_slave,
1441                    bonding_store_packets_per_slave);
1442
1443 static struct attribute *per_bond_attrs[] = {
1444         &dev_attr_slaves.attr,
1445         &dev_attr_mode.attr,
1446         &dev_attr_fail_over_mac.attr,
1447         &dev_attr_arp_validate.attr,
1448         &dev_attr_arp_all_targets.attr,
1449         &dev_attr_arp_interval.attr,
1450         &dev_attr_arp_ip_target.attr,
1451         &dev_attr_downdelay.attr,
1452         &dev_attr_updelay.attr,
1453         &dev_attr_lacp_rate.attr,
1454         &dev_attr_ad_select.attr,
1455         &dev_attr_xmit_hash_policy.attr,
1456         &dev_attr_num_grat_arp.attr,
1457         &dev_attr_num_unsol_na.attr,
1458         &dev_attr_miimon.attr,
1459         &dev_attr_primary.attr,
1460         &dev_attr_primary_reselect.attr,
1461         &dev_attr_use_carrier.attr,
1462         &dev_attr_active_slave.attr,
1463         &dev_attr_mii_status.attr,
1464         &dev_attr_ad_aggregator.attr,
1465         &dev_attr_ad_num_ports.attr,
1466         &dev_attr_ad_actor_key.attr,
1467         &dev_attr_ad_partner_key.attr,
1468         &dev_attr_ad_partner_mac.attr,
1469         &dev_attr_queue_id.attr,
1470         &dev_attr_all_slaves_active.attr,
1471         &dev_attr_resend_igmp.attr,
1472         &dev_attr_min_links.attr,
1473         &dev_attr_lp_interval.attr,
1474         &dev_attr_packets_per_slave.attr,
1475         NULL,
1476 };
1477
1478 static struct attribute_group bonding_group = {
1479         .name = "bonding",
1480         .attrs = per_bond_attrs,
1481 };
1482
1483 /*
1484  * Initialize sysfs.  This sets up the bonding_masters file in
1485  * /sys/class/net.
1486  */
1487 int bond_create_sysfs(struct bond_net *bn)
1488 {
1489         int ret;
1490
1491         bn->class_attr_bonding_masters = class_attr_bonding_masters;
1492         sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
1493
1494         ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
1495                                           bn->net);
1496         /*
1497          * Permit multiple loads of the module by ignoring failures to
1498          * create the bonding_masters sysfs file.  Bonding devices
1499          * created by second or subsequent loads of the module will
1500          * not be listed in, or controllable by, bonding_masters, but
1501          * will have the usual "bonding" sysfs directory.
1502          *
1503          * This is done to preserve backwards compatibility for
1504          * initscripts/sysconfig, which load bonding multiple times to
1505          * configure multiple bonding devices.
1506          */
1507         if (ret == -EEXIST) {
1508                 /* Is someone being kinky and naming a device bonding_master? */
1509                 if (__dev_get_by_name(bn->net,
1510                                       class_attr_bonding_masters.attr.name))
1511                         pr_err("network device named %s already exists in sysfs",
1512                                class_attr_bonding_masters.attr.name);
1513                 ret = 0;
1514         }
1515
1516         return ret;
1517
1518 }
1519
1520 /*
1521  * Remove /sys/class/net/bonding_masters.
1522  */
1523 void bond_destroy_sysfs(struct bond_net *bn)
1524 {
1525         netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
1526 }
1527
1528 /*
1529  * Initialize sysfs for each bond.  This sets up and registers
1530  * the 'bondctl' directory for each individual bond under /sys/class/net.
1531  */
1532 void bond_prepare_sysfs_group(struct bonding *bond)
1533 {
1534         bond->dev->sysfs_groups[0] = &bonding_group;
1535 }
1536