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