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