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