SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/bonding/bond_sysfs.c

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