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