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

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