drivers/net/bonding/bond_sysfs.c

   1 /*
   2  * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * The full GNU General Public License is included in this distribution in the
  18  * file called LICENSE.
  19  *
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/device.h>
  27 #include <linux/sched.h>
  28 #include <linux/fs.h>
  29 #include <linux/types.h>
  30 #include <linux/string.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/inetdevice.h>
  33 #include <linux/in.h>
  34 #include <linux/sysfs.h>
  35 #include <linux/ctype.h>
  36 #include <linux/inet.h>
  37 #include <linux/rtnetlink.h>
  38 #include <linux/etherdevice.h>
  39 #include <net/net_namespace.h>
  40 #include <net/netns/generic.h>
  41 #include <linux/nsproxy.h>
  42
  43 #include "bonding.h"
  44
  45 #define to_dev(obj)     container_of(obj, struct device, kobj)
  46 #define to_bond(cd)     ((struct bonding *)(netdev_priv(to_net_dev(cd))))
  47
  48 /*
  49  * "show" function for the bond_masters attribute.
  50  * The class parameter is ignored.
  51  */
  52 static ssize_t bonding_show_bonds(struct class *cls,
  53                                   struct class_attribute *attr,
  54                                   char *buf)
  55 {
  56         struct bond_net *bn =
  57                 container_of(attr, struct bond_net, class_attr_bonding_masters);
  58         int res = 0;
  59         struct bonding *bond;
  60
  61         rtnl_lock();
  62
  63         list_for_each_entry(bond, &bn->dev_list, bond_list) {
  64                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
  65                         /* not enough space for another interface name */
  66                         if ((PAGE_SIZE - res) > 10)
  67                                 res = PAGE_SIZE - 10;
  68                         res += sprintf(buf + res, "++more++ ");
  69                         break;
  70                 }
  71                 res += sprintf(buf + res, "%s ", bond->dev->name);
  72         }
  73         if (res)
  74                 buf[res-1] = '\n'; /* eat the leftover space */
  75
  76         rtnl_unlock();
  77         return res;
  78 }
  79
  80 static struct net_device *bond_get_by_name(struct bond_net *bn, const char *ifname)
  81 {
  82         struct bonding *bond;
  83
  84         list_for_each_entry(bond, &bn->dev_list, bond_list) {
  85                 if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0)
  86                         return bond->dev;
  87         }
  88         return NULL;
  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,
 100                                    struct class_attribute *attr,
 101                                    const char *buffer, size_t count)
 102 {
 103         struct bond_net *bn =
 104                 container_of(attr, struct bond_net, class_attr_bonding_masters);
 105         char command[IFNAMSIZ + 1] = {0, };
 106         char *ifname;
 107         int rv, res = count;
 108
 109         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
 110         ifname = command + 1;
 111         if ((strlen(command) <= 1) ||
 112             !dev_valid_name(ifname))
 113                 goto err_no_cmd;
 114
 115         if (command[0] == '+') {
 116                 pr_info("%s is being created...\n", ifname);
 117                 rv = bond_create(bn->net, ifname);
 118                 if (rv) {
 119                         if (rv == -EEXIST)
 120                                 pr_info("%s already exists.\n", ifname);
 121                         else
 122                                 pr_info("%s creation failed.\n", ifname);
 123                         res = rv;
 124                 }
 125         } else if (command[0] == '-') {
 126                 struct net_device *bond_dev;
 127
 128                 rtnl_lock();
 129                 bond_dev = bond_get_by_name(bn, ifname);
 130                 if (bond_dev) {
 131                         pr_info("%s is being deleted...\n", ifname);
 132                         unregister_netdevice(bond_dev);
 133                 } else {
 134                         pr_err("unable to delete non-existent %s\n", ifname);
 135                         res = -ENODEV;
 136                 }
 137                 rtnl_unlock();
 138         } else
 139                 goto err_no_cmd;
 140
 141         /* Always return either count or an error.  If you return 0, you'll
 142          * get called forever, which is bad.
 143          */
 144         return res;
 145
 146 err_no_cmd:
 147         pr_err("no command found in bonding_masters. Use +ifname or -ifname.\n");
 148         return -EPERM;
 149 }
 150
 151 /* class attribute for bond_masters file.  This ends up in /sys/class/net */
 152 static const struct class_attribute class_attr_bonding_masters = {
 153         .attr = {
 154                 .name = "bonding_masters",
 155                 .mode = S_IWUSR | S_IRUGO,
 156         },
 157         .show = bonding_show_bonds,
 158         .store = bonding_store_bonds,
 159 };
 160
 161 /*
 162  * Show the slaves in the current bond.
 163  */
 164 static ssize_t bonding_show_slaves(struct device *d,
 165                                    struct device_attribute *attr, char *buf)
 166 {
 167         struct bonding *bond = to_bond(d);
 168         struct list_head *iter;
 169         struct slave *slave;
 170         int res = 0;
 171
 172         if (!rtnl_trylock())
 173                 return restart_syscall();
 174
 175         bond_for_each_slave(bond, slave, iter) {
 176                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
 177                         /* not enough space for another interface name */
 178                         if ((PAGE_SIZE - res) > 10)
 179                                 res = PAGE_SIZE - 10;
 180                         res += sprintf(buf + res, "++more++ ");
 181                         break;
 182                 }
 183                 res += sprintf(buf + res, "%s ", slave->dev->name);
 184         }
 185
 186         rtnl_unlock();
 187
 188         if (res)
 189                 buf[res-1] = '\n'; /* eat the leftover space */
 190
 191         return res;
 192 }
 193
 194 /*
 195  * Set the slaves in the current bond.
 196  * This is supposed to be only thin wrapper for bond_enslave and bond_release.
 197  * All hard work should be done there.
 198  */
 199 static ssize_t bonding_store_slaves(struct device *d,
 200                                     struct device_attribute *attr,
 201                                     const char *buffer, size_t count)
 202 {
 203         char command[IFNAMSIZ + 1] = { 0, };
 204         char *ifname;
 205         int res, ret = count;
 206         struct net_device *dev;
 207         struct bonding *bond = to_bond(d);
 208
 209         if (!rtnl_trylock())
 210                 return restart_syscall();
 211
 212         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
 213         ifname = command + 1;
 214         if ((strlen(command) <= 1) ||
 215             !dev_valid_name(ifname))
 216                 goto err_no_cmd;
 217
 218         dev = __dev_get_by_name(dev_net(bond->dev), ifname);
 219         if (!dev) {
 220                 pr_info("%s: Interface %s does not exist!\n",
 221                         bond->dev->name, ifname);
 222                 ret = -ENODEV;
 223                 goto out;
 224         }
 225
 226         switch (command[0]) {
 227         case '+':
 228                 pr_info("%s: Adding slave %s.\n", bond->dev->name, dev->name);
 229                 res = bond_enslave(bond->dev, dev);
 230                 break;
 231
 232         case '-':
 233                 pr_info("%s: Removing slave %s.\n", bond->dev->name, dev->name);
 234                 res = bond_release(bond->dev, dev);
 235                 break;
 236
 237         default:
 238                 goto err_no_cmd;
 239         }
 240
 241         if (res)
 242                 ret = res;
 243         goto out;
 244
 245 err_no_cmd:
 246         pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n",
 247                bond->dev->name);
 248         ret = -EPERM;
 249
 250 out:
 251         rtnl_unlock();
 252         return ret;
 253 }
 254
 255 static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves,
 256                    bonding_store_slaves);
 257
 258 /*
 259  * Show and set the bonding mode.  The bond interface must be down to
 260  * change the mode.
 261  */
 262 static ssize_t bonding_show_mode(struct device *d,
 263                                  struct device_attribute *attr, char *buf)
 264 {
 265         struct bonding *bond = to_bond(d);
 266         struct bond_opt_value *val;
 267
 268         val = bond_opt_get_val(BOND_OPT_MODE, bond->params.mode);
 269
 270         return sprintf(buf, "%s %d\n", val->string, bond->params.mode);
 271 }
 272
 273 static ssize_t bonding_store_mode(struct device *d,
 274                                   struct device_attribute *attr,
 275                                   const char *buf, size_t count)
 276 {
 277         struct bonding *bond = to_bond(d);
 278         int ret;
 279
 280         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MODE, (char *)buf);
 281         if (!ret)
 282                 ret = count;
 283
 284         return ret;
 285 }
 286 static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 287                    bonding_show_mode, bonding_store_mode);
 288
 289 /*
 290  * Show and set the bonding transmit hash method.
 291  */
 292 static ssize_t bonding_show_xmit_hash(struct device *d,
 293                                       struct device_attribute *attr,
 294                                       char *buf)
 295 {
 296         struct bonding *bond = to_bond(d);
 297         struct bond_opt_value *val;
 298
 299         val = bond_opt_get_val(BOND_OPT_XMIT_HASH, bond->params.xmit_policy);
 300
 301         return sprintf(buf, "%s %d\n", val->string, bond->params.xmit_policy);
 302 }
 303
 304 static ssize_t bonding_store_xmit_hash(struct device *d,
 305                                        struct device_attribute *attr,
 306                                        const char *buf, size_t count)
 307 {
 308         struct bonding *bond = to_bond(d);
 309         int ret;
 310
 311         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_XMIT_HASH, (char *)buf);
 312         if (!ret)
 313                 ret = count;
 314
 315         return ret;
 316 }
 317 static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR,
 318                    bonding_show_xmit_hash, bonding_store_xmit_hash);
 319
 320 /*
 321  * Show and set arp_validate.
 322  */
 323 static ssize_t bonding_show_arp_validate(struct device *d,
 324                                          struct device_attribute *attr,
 325                                          char *buf)
 326 {
 327         struct bonding *bond = to_bond(d);
 328         struct bond_opt_value *val;
 329
 330         val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE,
 331                                bond->params.arp_validate);
 332
 333         return sprintf(buf, "%s %d\n", val->string, bond->params.arp_validate);
 334 }
 335
 336 static ssize_t bonding_store_arp_validate(struct device *d,
 337                                           struct device_attribute *attr,
 338                                           const char *buf, size_t count)
 339 {
 340         struct bonding *bond = to_bond(d);
 341         int ret;
 342
 343         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_VALIDATE, (char *)buf);
 344         if (!ret)
 345                 ret = count;
 346
 347         return ret;
 348 }
 349
 350 static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate,
 351                    bonding_store_arp_validate);
 352 /*
 353  * Show and set arp_all_targets.
 354  */
 355 static ssize_t bonding_show_arp_all_targets(struct device *d,
 356                                          struct device_attribute *attr,
 357                                          char *buf)
 358 {
 359         struct bonding *bond = to_bond(d);
 360         struct bond_opt_value *val;
 361
 362         val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS,
 363                                bond->params.arp_all_targets);
 364         return sprintf(buf, "%s %d\n",
 365                        val->string, bond->params.arp_all_targets);
 366 }
 367
 368 static ssize_t bonding_store_arp_all_targets(struct device *d,
 369                                           struct device_attribute *attr,
 370                                           const char *buf, size_t count)
 371 {
 372         struct bonding *bond = to_bond(d);
 373         int ret;
 374
 375         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_ALL_TARGETS, (char *)buf);
 376         if (!ret)
 377                 ret = count;
 378
 379         return ret;
 380 }
 381
 382 static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR,
 383                    bonding_show_arp_all_targets, bonding_store_arp_all_targets);
 384
 385 /*
 386  * Show and store fail_over_mac.  User only allowed to change the
 387  * value when there are no slaves.
 388  */
 389 static ssize_t bonding_show_fail_over_mac(struct device *d,
 390                                           struct device_attribute *attr,
 391                                           char *buf)
 392 {
 393         struct bonding *bond = to_bond(d);
 394         struct bond_opt_value *val;
 395
 396         val = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC,
 397                                bond->params.fail_over_mac);
 398
 399         return sprintf(buf, "%s %d\n", val->string, bond->params.fail_over_mac);
 400 }
 401
 402 static ssize_t bonding_store_fail_over_mac(struct device *d,
 403                                            struct device_attribute *attr,
 404                                            const char *buf, size_t count)
 405 {
 406         struct bonding *bond = to_bond(d);
 407         int ret;
 408
 409         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_FAIL_OVER_MAC, (char *)buf);
 410         if (!ret)
 411                 ret = count;
 412
 413         return ret;
 414 }
 415
 416 static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR,
 417                    bonding_show_fail_over_mac, bonding_store_fail_over_mac);
 418
 419 /*
 420  * Show and set the arp timer interval.  There are two tricky bits
 421  * here.  First, if ARP monitoring is activated, then we must disable
 422  * MII monitoring.  Second, if the ARP timer isn't running, we must
 423  * start it.
 424  */
 425 static ssize_t bonding_show_arp_interval(struct device *d,
 426                                          struct device_attribute *attr,
 427                                          char *buf)
 428 {
 429         struct bonding *bond = to_bond(d);
 430
 431         return sprintf(buf, "%d\n", bond->params.arp_interval);
 432 }
 433
 434 static ssize_t bonding_store_arp_interval(struct device *d,
 435                                           struct device_attribute *attr,
 436                                           const char *buf, size_t count)
 437 {
 438         struct bonding *bond = to_bond(d);
 439         int ret;
 440
 441         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_INTERVAL, (char *)buf);
 442         if (!ret)
 443                 ret = count;
 444
 445         return ret;
 446 }
 447 static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR,
 448                    bonding_show_arp_interval, bonding_store_arp_interval);
 449
 450 /*
 451  * Show and set the arp targets.
 452  */
 453 static ssize_t bonding_show_arp_targets(struct device *d,
 454                                         struct device_attribute *attr,
 455                                         char *buf)
 456 {
 457         struct bonding *bond = to_bond(d);
 458         int i, res = 0;
 459
 460         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 461                 if (bond->params.arp_targets[i])
 462                         res += sprintf(buf + res, "%pI4 ",
 463                                        &bond->params.arp_targets[i]);
 464         }
 465         if (res)
 466                 buf[res-1] = '\n'; /* eat the leftover space */
 467
 468         return res;
 469 }
 470
 471 static ssize_t bonding_store_arp_targets(struct device *d,
 472                                          struct device_attribute *attr,
 473                                          const char *buf, size_t count)
 474 {
 475         struct bonding *bond = to_bond(d);
 476         int ret;
 477
 478         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_TARGETS, (char *)buf);
 479         if (!ret)
 480                 ret = count;
 481
 482         return ret;
 483 }
 484 static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
 485
 486 /*
 487  * Show and set the up and down delays.  These must be multiples of the
 488  * MII monitoring value, and are stored internally as the multiplier.
 489  * Thus, we must translate to MS for the real world.
 490  */
 491 static ssize_t bonding_show_downdelay(struct device *d,
 492                                       struct device_attribute *attr,
 493                                       char *buf)
 494 {
 495         struct bonding *bond = to_bond(d);
 496
 497         return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
 498 }
 499
 500 static ssize_t bonding_store_downdelay(struct device *d,
 501                                        struct device_attribute *attr,
 502                                        const char *buf, size_t count)
 503 {
 504         struct bonding *bond = to_bond(d);
 505         int ret;
 506
 507         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_DOWNDELAY, (char *)buf);
 508         if (!ret)
 509                 ret = count;
 510
 511         return ret;
 512 }
 513 static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR,
 514                    bonding_show_downdelay, bonding_store_downdelay);
 515
 516 static ssize_t bonding_show_updelay(struct device *d,
 517                                     struct device_attribute *attr,
 518                                     char *buf)
 519 {
 520         struct bonding *bond = to_bond(d);
 521
 522         return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon);
 523
 524 }
 525
 526 static ssize_t bonding_store_updelay(struct device *d,
 527                                      struct device_attribute *attr,
 528                                      const char *buf, size_t count)
 529 {
 530         struct bonding *bond = to_bond(d);
 531         int ret;
 532
 533         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_UPDELAY, (char *)buf);
 534         if (!ret)
 535                 ret = count;
 536
 537         return ret;
 538 }
 539 static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR,
 540                    bonding_show_updelay, bonding_store_updelay);
 541
 542 /*
 543  * Show and set the LACP interval.  Interface must be down, and the mode
 544  * must be set to 802.3ad mode.
 545  */
 546 static ssize_t bonding_show_lacp(struct device *d,
 547                                  struct device_attribute *attr,
 548                                  char *buf)
 549 {
 550         struct bonding *bond = to_bond(d);
 551         struct bond_opt_value *val;
 552
 553         val = bond_opt_get_val(BOND_OPT_LACP_RATE, bond->params.lacp_fast);
 554
 555         return sprintf(buf, "%s %d\n", val->string, bond->params.lacp_fast);
 556 }
 557
 558 static ssize_t bonding_store_lacp(struct device *d,
 559                                   struct device_attribute *attr,
 560                                   const char *buf, size_t count)
 561 {
 562         struct bonding *bond = to_bond(d);
 563         int ret;
 564
 565         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_LACP_RATE, (char *)buf);
 566         if (!ret)
 567                 ret = count;
 568
 569         return ret;
 570 }
 571 static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR,
 572                    bonding_show_lacp, bonding_store_lacp);
 573
 574 static ssize_t bonding_show_min_links(struct device *d,
 575                                       struct device_attribute *attr,
 576                                       char *buf)
 577 {
 578         struct bonding *bond = to_bond(d);
 579
 580         return sprintf(buf, "%d\n", bond->params.min_links);
 581 }
 582
 583 static ssize_t bonding_store_min_links(struct device *d,
 584                                        struct device_attribute *attr,
 585                                        const char *buf, size_t count)
 586 {
 587         struct bonding *bond = to_bond(d);
 588         int ret;
 589
 590         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MINLINKS, (char *)buf);
 591         if (!ret)
 592                 ret = count;
 593
 594         return ret;
 595 }
 596 static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR,
 597                    bonding_show_min_links, bonding_store_min_links);
 598
 599 static ssize_t bonding_show_ad_select(struct device *d,
 600                                       struct device_attribute *attr,
 601                                       char *buf)
 602 {
 603         struct bonding *bond = to_bond(d);
 604
 605         return sprintf(buf, "%s %d\n",
 606                 ad_select_tbl[bond->params.ad_select].modename,
 607                 bond->params.ad_select);
 608 }
 609
 610
 611 static ssize_t bonding_store_ad_select(struct device *d,
 612                                        struct device_attribute *attr,
 613                                        const char *buf, size_t count)
 614 {
 615         int new_value, ret;
 616         struct bonding *bond = to_bond(d);
 617
 618         new_value = bond_parse_parm(buf, ad_select_tbl);
 619         if (new_value < 0) {
 620                 pr_err("%s: Ignoring invalid ad_select value %.*s.\n",
 621                        bond->dev->name, (int)strlen(buf) - 1, buf);
 622                 return -EINVAL;
 623         }
 624
 625         if (!rtnl_trylock())
 626                 return restart_syscall();
 627
 628         ret = bond_option_ad_select_set(bond, new_value);
 629         if (!ret)
 630                 ret = count;
 631
 632         rtnl_unlock();
 633         return ret;
 634 }
 635 static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR,
 636                    bonding_show_ad_select, bonding_store_ad_select);
 637
 638 /*
 639  * Show and set the number of peer notifications to send after a failover event.
 640  */
 641 static ssize_t bonding_show_num_peer_notif(struct device *d,
 642                                            struct device_attribute *attr,
 643                                            char *buf)
 644 {
 645         struct bonding *bond = to_bond(d);
 646         return sprintf(buf, "%d\n", bond->params.num_peer_notif);
 647 }
 648
 649 static ssize_t bonding_store_num_peer_notif(struct device *d,
 650                                             struct device_attribute *attr,
 651                                             const char *buf, size_t count)
 652 {
 653         struct bonding *bond = to_bond(d);
 654         u8 new_value;
 655         int ret;
 656
 657         ret = kstrtou8(buf, 10, &new_value);
 658         if (ret) {
 659                 pr_err("%s: invalid value %s specified.\n",
 660                        bond->dev->name, buf);
 661                 return ret;
 662         }
 663
 664         if (!rtnl_trylock())
 665                 return restart_syscall();
 666
 667         ret = bond_option_num_peer_notif_set(bond, new_value);
 668         if (!ret)
 669                 ret = count;
 670
 671         rtnl_unlock();
 672         return ret;
 673 }
 674 static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR,
 675                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 676 static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR,
 677                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 678
 679 /*
 680  * Show and set the MII monitor interval.  There are two tricky bits
 681  * here.  First, if MII monitoring is activated, then we must disable
 682  * ARP monitoring.  Second, if the timer isn't running, we must
 683  * start it.
 684  */
 685 static ssize_t bonding_show_miimon(struct device *d,
 686                                    struct device_attribute *attr,
 687                                    char *buf)
 688 {
 689         struct bonding *bond = to_bond(d);
 690
 691         return sprintf(buf, "%d\n", bond->params.miimon);
 692 }
 693
 694 static ssize_t bonding_store_miimon(struct device *d,
 695                                     struct device_attribute *attr,
 696                                     const char *buf, size_t count)
 697 {
 698         int new_value, ret;
 699         struct bonding *bond = to_bond(d);
 700
 701         if (sscanf(buf, "%d", &new_value) != 1) {
 702                 pr_err("%s: no miimon value specified.\n",
 703                        bond->dev->name);
 704                 return -EINVAL;
 705         }
 706
 707         if (!rtnl_trylock())
 708                 return restart_syscall();
 709
 710         ret = bond_option_miimon_set(bond, new_value);
 711         if (!ret)
 712                 ret = count;
 713
 714         rtnl_unlock();
 715         return ret;
 716 }
 717 static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
 718                    bonding_show_miimon, bonding_store_miimon);
 719
 720 /*
 721  * Show and set the primary slave.  The store function is much
 722  * simpler than bonding_store_slaves function because it only needs to
 723  * handle one interface name.
 724  * The bond must be a mode that supports a primary for this be
 725  * set.
 726  */
 727 static ssize_t bonding_show_primary(struct device *d,
 728                                     struct device_attribute *attr,
 729                                     char *buf)
 730 {
 731         int count = 0;
 732         struct bonding *bond = to_bond(d);
 733
 734         if (bond->primary_slave)
 735                 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
 736
 737         return count;
 738 }
 739
 740 static ssize_t bonding_store_primary(struct device *d,
 741                                      struct device_attribute *attr,
 742                                      const char *buf, size_t count)
 743 {
 744         struct bonding *bond = to_bond(d);
 745         char ifname[IFNAMSIZ];
 746         int ret;
 747
 748         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
 749         if (ifname[0] == '\n')
 750                 ifname[0] = '\0';
 751
 752         if (!rtnl_trylock())
 753                 return restart_syscall();
 754
 755         ret = bond_option_primary_set(bond, ifname);
 756         if (!ret)
 757                 ret = count;
 758
 759         rtnl_unlock();
 760         return ret;
 761 }
 762 static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR,
 763                    bonding_show_primary, bonding_store_primary);
 764
 765 /*
 766  * Show and set the primary_reselect flag.
 767  */
 768 static ssize_t bonding_show_primary_reselect(struct device *d,
 769                                              struct device_attribute *attr,
 770                                              char *buf)
 771 {
 772         struct bonding *bond = to_bond(d);
 773
 774         return sprintf(buf, "%s %d\n",
 775                        pri_reselect_tbl[bond->params.primary_reselect].modename,
 776                        bond->params.primary_reselect);
 777 }
 778
 779 static ssize_t bonding_store_primary_reselect(struct device *d,
 780                                               struct device_attribute *attr,
 781                                               const char *buf, size_t count)
 782 {
 783         int new_value, ret;
 784         struct bonding *bond = to_bond(d);
 785
 786         new_value = bond_parse_parm(buf, pri_reselect_tbl);
 787         if (new_value < 0)  {
 788                 pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n",
 789                        bond->dev->name,
 790                        (int) strlen(buf) - 1, buf);
 791                 return -EINVAL;
 792         }
 793
 794         if (!rtnl_trylock())
 795                 return restart_syscall();
 796
 797         ret = bond_option_primary_reselect_set(bond, new_value);
 798         if (!ret)
 799                 ret = count;
 800
 801         rtnl_unlock();
 802         return ret;
 803 }
 804 static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR,
 805                    bonding_show_primary_reselect,
 806                    bonding_store_primary_reselect);
 807
 808 /*
 809  * Show and set the use_carrier flag.
 810  */
 811 static ssize_t bonding_show_carrier(struct device *d,
 812                                     struct device_attribute *attr,
 813                                     char *buf)
 814 {
 815         struct bonding *bond = to_bond(d);
 816
 817         return sprintf(buf, "%d\n", bond->params.use_carrier);
 818 }
 819
 820 static ssize_t bonding_store_carrier(struct device *d,
 821                                      struct device_attribute *attr,
 822                                      const char *buf, size_t count)
 823 {
 824         int new_value, ret;
 825         struct bonding *bond = to_bond(d);
 826
 827         if (sscanf(buf, "%d", &new_value) != 1) {
 828                 pr_err("%s: no use_carrier value specified.\n",
 829                        bond->dev->name);
 830                 return -EINVAL;
 831         }
 832
 833         if (!rtnl_trylock())
 834                 return restart_syscall();
 835
 836         ret = bond_option_use_carrier_set(bond, new_value);
 837         if (!ret)
 838                 ret = count;
 839
 840         rtnl_unlock();
 841         return ret;
 842 }
 843 static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR,
 844                    bonding_show_carrier, bonding_store_carrier);
 845
 846
 847 /*
 848  * Show and set currently active_slave.
 849  */
 850 static ssize_t bonding_show_active_slave(struct device *d,
 851                                          struct device_attribute *attr,
 852                                          char *buf)
 853 {
 854         struct bonding *bond = to_bond(d);
 855         struct net_device *slave_dev;
 856         int count = 0;
 857
 858         rcu_read_lock();
 859         slave_dev = bond_option_active_slave_get_rcu(bond);
 860         if (slave_dev)
 861                 count = sprintf(buf, "%s\n", slave_dev->name);
 862         rcu_read_unlock();
 863
 864         return count;
 865 }
 866
 867 static ssize_t bonding_store_active_slave(struct device *d,
 868                                           struct device_attribute *attr,
 869                                           const char *buf, size_t count)
 870 {
 871         int ret;
 872         struct bonding *bond = to_bond(d);
 873         char ifname[IFNAMSIZ];
 874         struct net_device *dev;
 875
 876         if (!rtnl_trylock())
 877                 return restart_syscall();
 878
 879         sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
 880         if (!strlen(ifname) || buf[0] == '\n') {
 881                 dev = NULL;
 882         } else {
 883                 dev = __dev_get_by_name(dev_net(bond->dev), ifname);
 884                 if (!dev) {
 885                         ret = -ENODEV;
 886                         goto out;
 887                 }
 888         }
 889
 890         ret = bond_option_active_slave_set(bond, dev);
 891         if (!ret)
 892                 ret = count;
 893
 894  out:
 895         rtnl_unlock();
 896
 897         return ret;
 898
 899 }
 900 static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR,
 901                    bonding_show_active_slave, bonding_store_active_slave);
 902
 903
 904 /*
 905  * Show link status of the bond interface.
 906  */
 907 static ssize_t bonding_show_mii_status(struct device *d,
 908                                        struct device_attribute *attr,
 909                                        char *buf)
 910 {
 911         struct bonding *bond = to_bond(d);
 912
 913         return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down");
 914 }
 915 static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
 916
 917 /*
 918  * Show current 802.3ad aggregator ID.
 919  */
 920 static ssize_t bonding_show_ad_aggregator(struct device *d,
 921                                           struct device_attribute *attr,
 922                                           char *buf)
 923 {
 924         int count = 0;
 925         struct bonding *bond = to_bond(d);
 926
 927         if (bond->params.mode == BOND_MODE_8023AD) {
 928                 struct ad_info ad_info;
 929                 count = sprintf(buf, "%d\n",
 930                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 931                                 ?  0 : ad_info.aggregator_id);
 932         }
 933
 934         return count;
 935 }
 936 static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
 937
 938
 939 /*
 940  * Show number of active 802.3ad ports.
 941  */
 942 static ssize_t bonding_show_ad_num_ports(struct device *d,
 943                                          struct device_attribute *attr,
 944                                          char *buf)
 945 {
 946         int count = 0;
 947         struct bonding *bond = to_bond(d);
 948
 949         if (bond->params.mode == BOND_MODE_8023AD) {
 950                 struct ad_info ad_info;
 951                 count = sprintf(buf, "%d\n",
 952                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 953                                 ?  0 : ad_info.ports);
 954         }
 955
 956         return count;
 957 }
 958 static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
 959
 960
 961 /*
 962  * Show current 802.3ad actor key.
 963  */
 964 static ssize_t bonding_show_ad_actor_key(struct device *d,
 965                                          struct device_attribute *attr,
 966                                          char *buf)
 967 {
 968         int count = 0;
 969         struct bonding *bond = to_bond(d);
 970
 971         if (bond->params.mode == BOND_MODE_8023AD) {
 972                 struct ad_info ad_info;
 973                 count = sprintf(buf, "%d\n",
 974                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 975                                 ?  0 : ad_info.actor_key);
 976         }
 977
 978         return count;
 979 }
 980 static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
 981
 982
 983 /*
 984  * Show current 802.3ad partner key.
 985  */
 986 static ssize_t bonding_show_ad_partner_key(struct device *d,
 987                                            struct device_attribute *attr,
 988                                            char *buf)
 989 {
 990         int count = 0;
 991         struct bonding *bond = to_bond(d);
 992
 993         if (bond->params.mode == BOND_MODE_8023AD) {
 994                 struct ad_info ad_info;
 995                 count = sprintf(buf, "%d\n",
 996                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 997                                 ?  0 : ad_info.partner_key);
 998         }
 999
1000         return count;
1001 }
1002 static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1003
1004
1005 /*
1006  * Show current 802.3ad partner mac.
1007  */
1008 static ssize_t bonding_show_ad_partner_mac(struct device *d,
1009                                            struct device_attribute *attr,
1010                                            char *buf)
1011 {
1012         int count = 0;
1013         struct bonding *bond = to_bond(d);
1014
1015         if (bond->params.mode == BOND_MODE_8023AD) {
1016                 struct ad_info ad_info;
1017                 if (!bond_3ad_get_active_agg_info(bond, &ad_info))
1018                         count = sprintf(buf, "%pM\n", ad_info.partner_system);
1019         }
1020
1021         return count;
1022 }
1023 static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1024
1025 /*
1026  * Show the queue_ids of the slaves in the current bond.
1027  */
1028 static ssize_t bonding_show_queue_id(struct device *d,
1029                                      struct device_attribute *attr,
1030                                      char *buf)
1031 {
1032         struct bonding *bond = to_bond(d);
1033         struct list_head *iter;
1034         struct slave *slave;
1035         int res = 0;
1036
1037         if (!rtnl_trylock())
1038                 return restart_syscall();
1039
1040         bond_for_each_slave(bond, slave, iter) {
1041                 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
1042                         /* not enough space for another interface_name:queue_id pair */
1043                         if ((PAGE_SIZE - res) > 10)
1044                                 res = PAGE_SIZE - 10;
1045                         res += sprintf(buf + res, "++more++ ");
1046                         break;
1047                 }
1048                 res += sprintf(buf + res, "%s:%d ",
1049                                slave->dev->name, slave->queue_id);
1050         }
1051         if (res)
1052                 buf[res-1] = '\n'; /* eat the leftover space */
1053
1054         rtnl_unlock();
1055
1056         return res;
1057 }
1058
1059 /*
1060  * Set the queue_ids of the  slaves in the current bond.  The bond
1061  * interface must be enslaved for this to work.
1062  */
1063 static ssize_t bonding_store_queue_id(struct device *d,
1064                                       struct device_attribute *attr,
1065                                       const char *buffer, size_t count)
1066 {
1067         struct slave *slave, *update_slave;
1068         struct bonding *bond = to_bond(d);
1069         struct list_head *iter;
1070         u16 qid;
1071         int ret = count;
1072         char *delim;
1073         struct net_device *sdev = NULL;
1074
1075         if (!rtnl_trylock())
1076                 return restart_syscall();
1077
1078         /* delim will point to queue id if successful */
1079         delim = strchr(buffer, ':');
1080         if (!delim)
1081                 goto err_no_cmd;
1082
1083         /*
1084          * Terminate string that points to device name and bump it
1085          * up one, so we can read the queue id there.
1086          */
1087         *delim = '\0';
1088         if (sscanf(++delim, "%hd\n", &qid) != 1)
1089                 goto err_no_cmd;
1090
1091         /* Check buffer length, valid ifname and queue id */
1092         if (strlen(buffer) > IFNAMSIZ ||
1093             !dev_valid_name(buffer) ||
1094             qid > bond->dev->real_num_tx_queues)
1095                 goto err_no_cmd;
1096
1097         /* Get the pointer to that interface if it exists */
1098         sdev = __dev_get_by_name(dev_net(bond->dev), buffer);
1099         if (!sdev)
1100                 goto err_no_cmd;
1101
1102         /* Search for thes slave and check for duplicate qids */
1103         update_slave = NULL;
1104         bond_for_each_slave(bond, slave, iter) {
1105                 if (sdev == slave->dev)
1106                         /*
1107                          * We don't need to check the matching
1108                          * slave for dups, since we're overwriting it
1109                          */
1110                         update_slave = slave;
1111                 else if (qid && qid == slave->queue_id) {
1112                         goto err_no_cmd;
1113                 }
1114         }
1115
1116         if (!update_slave)
1117                 goto err_no_cmd;
1118
1119         /* Actually set the qids for the slave */
1120         update_slave->queue_id = qid;
1121
1122 out:
1123         rtnl_unlock();
1124         return ret;
1125
1126 err_no_cmd:
1127         pr_info("invalid input for queue_id set for %s.\n",
1128                 bond->dev->name);
1129         ret = -EPERM;
1130         goto out;
1131 }
1132
1133 static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id,
1134                    bonding_store_queue_id);
1135
1136
1137 /*
1138  * Show and set the all_slaves_active flag.
1139  */
1140 static ssize_t bonding_show_slaves_active(struct device *d,
1141                                           struct device_attribute *attr,
1142                                           char *buf)
1143 {
1144         struct bonding *bond = to_bond(d);
1145
1146         return sprintf(buf, "%d\n", bond->params.all_slaves_active);
1147 }
1148
1149 static ssize_t bonding_store_slaves_active(struct device *d,
1150                                            struct device_attribute *attr,
1151                                            const char *buf, size_t count)
1152 {
1153         struct bonding *bond = to_bond(d);
1154         int new_value, ret;
1155
1156         if (sscanf(buf, "%d", &new_value) != 1) {
1157                 pr_err("%s: no all_slaves_active value specified.\n",
1158                        bond->dev->name);
1159                 return -EINVAL;
1160         }
1161
1162         if (!rtnl_trylock())
1163                 return restart_syscall();
1164
1165         ret = bond_option_all_slaves_active_set(bond, new_value);
1166         if (!ret)
1167                 ret = count;
1168
1169         rtnl_unlock();
1170         return ret;
1171 }
1172 static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR,
1173                    bonding_show_slaves_active, bonding_store_slaves_active);
1174
1175 /*
1176  * Show and set the number of IGMP membership reports to send on link failure
1177  */
1178 static ssize_t bonding_show_resend_igmp(struct device *d,
1179                                         struct device_attribute *attr,
1180                                         char *buf)
1181 {
1182         struct bonding *bond = to_bond(d);
1183
1184         return sprintf(buf, "%d\n", bond->params.resend_igmp);
1185 }
1186
1187 static ssize_t bonding_store_resend_igmp(struct device *d,
1188                                          struct device_attribute *attr,
1189                                          const char *buf, size_t count)
1190 {
1191         int new_value, ret = count;
1192         struct bonding *bond = to_bond(d);
1193
1194         if (sscanf(buf, "%d", &new_value) != 1) {
1195                 pr_err("%s: no resend_igmp value specified.\n",
1196                        bond->dev->name);
1197                 return -EINVAL;
1198         }
1199
1200         if (!rtnl_trylock())
1201                 return restart_syscall();
1202
1203         ret = bond_option_resend_igmp_set(bond, new_value);
1204         if (!ret)
1205                 ret = count;
1206
1207         rtnl_unlock();
1208         return ret;
1209 }
1210
1211 static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR,
1212                    bonding_show_resend_igmp, bonding_store_resend_igmp);
1213
1214
1215 static ssize_t bonding_show_lp_interval(struct device *d,
1216                                         struct device_attribute *attr,
1217                                         char *buf)
1218 {
1219         struct bonding *bond = to_bond(d);
1220         return sprintf(buf, "%d\n", bond->params.lp_interval);
1221 }
1222
1223 static ssize_t bonding_store_lp_interval(struct device *d,
1224                                          struct device_attribute *attr,
1225                                          const char *buf, size_t count)
1226 {
1227         struct bonding *bond = to_bond(d);
1228         int new_value, ret;
1229
1230         if (sscanf(buf, "%d", &new_value) != 1) {
1231                 pr_err("%s: no lp interval value specified.\n",
1232                         bond->dev->name);
1233                 return -EINVAL;
1234         }
1235
1236         if (!rtnl_trylock())
1237                 return restart_syscall();
1238
1239         ret = bond_option_lp_interval_set(bond, new_value);
1240         if (!ret)
1241                 ret = count;
1242
1243         rtnl_unlock();
1244         return ret;
1245 }
1246
1247 static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR,
1248                    bonding_show_lp_interval, bonding_store_lp_interval);
1249
1250 static ssize_t bonding_show_packets_per_slave(struct device *d,
1251                                               struct device_attribute *attr,
1252                                               char *buf)
1253 {
1254         struct bonding *bond = to_bond(d);
1255         unsigned int packets_per_slave = bond->params.packets_per_slave;
1256         return sprintf(buf, "%u\n", packets_per_slave);
1257 }
1258
1259 static ssize_t bonding_store_packets_per_slave(struct device *d,
1260                                                struct device_attribute *attr,
1261                                                const char *buf, size_t count)
1262 {
1263         struct bonding *bond = to_bond(d);
1264         int ret;
1265
1266         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_PACKETS_PER_SLAVE,
1267                                    (char *)buf);
1268         if (!ret)
1269                 ret = count;
1270
1271         return ret;
1272 }
1273
1274 static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR,
1275                    bonding_show_packets_per_slave,
1276                    bonding_store_packets_per_slave);
1277
1278 static struct attribute *per_bond_attrs[] = {
1279         &dev_attr_slaves.attr,
1280         &dev_attr_mode.attr,
1281         &dev_attr_fail_over_mac.attr,
1282         &dev_attr_arp_validate.attr,
1283         &dev_attr_arp_all_targets.attr,
1284         &dev_attr_arp_interval.attr,
1285         &dev_attr_arp_ip_target.attr,
1286         &dev_attr_downdelay.attr,
1287         &dev_attr_updelay.attr,
1288         &dev_attr_lacp_rate.attr,
1289         &dev_attr_ad_select.attr,
1290         &dev_attr_xmit_hash_policy.attr,
1291         &dev_attr_num_grat_arp.attr,
1292         &dev_attr_num_unsol_na.attr,
1293         &dev_attr_miimon.attr,
1294         &dev_attr_primary.attr,
1295         &dev_attr_primary_reselect.attr,
1296         &dev_attr_use_carrier.attr,
1297         &dev_attr_active_slave.attr,
1298         &dev_attr_mii_status.attr,
1299         &dev_attr_ad_aggregator.attr,
1300         &dev_attr_ad_num_ports.attr,
1301         &dev_attr_ad_actor_key.attr,
1302         &dev_attr_ad_partner_key.attr,
1303         &dev_attr_ad_partner_mac.attr,
1304         &dev_attr_queue_id.attr,
1305         &dev_attr_all_slaves_active.attr,
1306         &dev_attr_resend_igmp.attr,
1307         &dev_attr_min_links.attr,
1308         &dev_attr_lp_interval.attr,
1309         &dev_attr_packets_per_slave.attr,
1310         NULL,
1311 };
1312
1313 static struct attribute_group bonding_group = {
1314         .name = "bonding",
1315         .attrs = per_bond_attrs,
1316 };
1317
1318 /*
1319  * Initialize sysfs.  This sets up the bonding_masters file in
1320  * /sys/class/net.
1321  */
1322 int bond_create_sysfs(struct bond_net *bn)
1323 {
1324         int ret;
1325
1326         bn->class_attr_bonding_masters = class_attr_bonding_masters;
1327         sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
1328
1329         ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
1330                                           bn->net);
1331         /*
1332          * Permit multiple loads of the module by ignoring failures to
1333          * create the bonding_masters sysfs file.  Bonding devices
1334          * created by second or subsequent loads of the module will
1335          * not be listed in, or controllable by, bonding_masters, but
1336          * will have the usual "bonding" sysfs directory.
1337          *
1338          * This is done to preserve backwards compatibility for
1339          * initscripts/sysconfig, which load bonding multiple times to
1340          * configure multiple bonding devices.
1341          */
1342         if (ret == -EEXIST) {
1343                 /* Is someone being kinky and naming a device bonding_master? */
1344                 if (__dev_get_by_name(bn->net,
1345                                       class_attr_bonding_masters.attr.name))
1346                         pr_err("network device named %s already exists in sysfs",
1347                                class_attr_bonding_masters.attr.name);
1348                 ret = 0;
1349         }
1350
1351         return ret;
1352
1353 }
1354
1355 /*
1356  * Remove /sys/class/net/bonding_masters.
1357  */
1358 void bond_destroy_sysfs(struct bond_net *bn)
1359 {
1360         netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
1361 }
1362
1363 /*
1364  * Initialize sysfs for each bond.  This sets up and registers
1365  * the 'bondctl' directory for each individual bond under /sys/class/net.
1366  */
1367 void bond_prepare_sysfs_group(struct bonding *bond)
1368 {
1369         bond->dev->sysfs_groups[0] = &bonding_group;
1370 }
1371