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         struct bonding *bond = to_bond(d);
 204         int ret;
 205
 206         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_SLAVES, (char *)buffer);
 207         if (!ret)
 208                 ret = count;
 209
 210         return ret;
 211 }
 212 static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves,
 213                    bonding_store_slaves);
 214
 215 /*
 216  * Show and set the bonding mode.  The bond interface must be down to
 217  * change the mode.
 218  */
 219 static ssize_t bonding_show_mode(struct device *d,
 220                                  struct device_attribute *attr, char *buf)
 221 {
 222         struct bonding *bond = to_bond(d);
 223         const struct bond_opt_value *val;
 224
 225         val = bond_opt_get_val(BOND_OPT_MODE, bond->params.mode);
 226
 227         return sprintf(buf, "%s %d\n", val->string, bond->params.mode);
 228 }
 229
 230 static ssize_t bonding_store_mode(struct device *d,
 231                                   struct device_attribute *attr,
 232                                   const char *buf, size_t count)
 233 {
 234         struct bonding *bond = to_bond(d);
 235         int ret;
 236
 237         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MODE, (char *)buf);
 238         if (!ret)
 239                 ret = count;
 240
 241         return ret;
 242 }
 243 static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 244                    bonding_show_mode, bonding_store_mode);
 245
 246 /*
 247  * Show and set the bonding transmit hash method.
 248  */
 249 static ssize_t bonding_show_xmit_hash(struct device *d,
 250                                       struct device_attribute *attr,
 251                                       char *buf)
 252 {
 253         struct bonding *bond = to_bond(d);
 254         const struct bond_opt_value *val;
 255
 256         val = bond_opt_get_val(BOND_OPT_XMIT_HASH, bond->params.xmit_policy);
 257
 258         return sprintf(buf, "%s %d\n", val->string, bond->params.xmit_policy);
 259 }
 260
 261 static ssize_t bonding_store_xmit_hash(struct device *d,
 262                                        struct device_attribute *attr,
 263                                        const char *buf, size_t count)
 264 {
 265         struct bonding *bond = to_bond(d);
 266         int ret;
 267
 268         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_XMIT_HASH, (char *)buf);
 269         if (!ret)
 270                 ret = count;
 271
 272         return ret;
 273 }
 274 static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR,
 275                    bonding_show_xmit_hash, bonding_store_xmit_hash);
 276
 277 /*
 278  * Show and set arp_validate.
 279  */
 280 static ssize_t bonding_show_arp_validate(struct device *d,
 281                                          struct device_attribute *attr,
 282                                          char *buf)
 283 {
 284         struct bonding *bond = to_bond(d);
 285         const struct bond_opt_value *val;
 286
 287         val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE,
 288                                bond->params.arp_validate);
 289
 290         return sprintf(buf, "%s %d\n", val->string, bond->params.arp_validate);
 291 }
 292
 293 static ssize_t bonding_store_arp_validate(struct device *d,
 294                                           struct device_attribute *attr,
 295                                           const char *buf, size_t count)
 296 {
 297         struct bonding *bond = to_bond(d);
 298         int ret;
 299
 300         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_VALIDATE, (char *)buf);
 301         if (!ret)
 302                 ret = count;
 303
 304         return ret;
 305 }
 306
 307 static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate,
 308                    bonding_store_arp_validate);
 309 /*
 310  * Show and set arp_all_targets.
 311  */
 312 static ssize_t bonding_show_arp_all_targets(struct device *d,
 313                                          struct device_attribute *attr,
 314                                          char *buf)
 315 {
 316         struct bonding *bond = to_bond(d);
 317         const struct bond_opt_value *val;
 318
 319         val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS,
 320                                bond->params.arp_all_targets);
 321         return sprintf(buf, "%s %d\n",
 322                        val->string, bond->params.arp_all_targets);
 323 }
 324
 325 static ssize_t bonding_store_arp_all_targets(struct device *d,
 326                                           struct device_attribute *attr,
 327                                           const char *buf, size_t count)
 328 {
 329         struct bonding *bond = to_bond(d);
 330         int ret;
 331
 332         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_ALL_TARGETS, (char *)buf);
 333         if (!ret)
 334                 ret = count;
 335
 336         return ret;
 337 }
 338
 339 static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR,
 340                    bonding_show_arp_all_targets, bonding_store_arp_all_targets);
 341
 342 /*
 343  * Show and store fail_over_mac.  User only allowed to change the
 344  * value when there are no slaves.
 345  */
 346 static ssize_t bonding_show_fail_over_mac(struct device *d,
 347                                           struct device_attribute *attr,
 348                                           char *buf)
 349 {
 350         struct bonding *bond = to_bond(d);
 351         const struct bond_opt_value *val;
 352
 353         val = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC,
 354                                bond->params.fail_over_mac);
 355
 356         return sprintf(buf, "%s %d\n", val->string, bond->params.fail_over_mac);
 357 }
 358
 359 static ssize_t bonding_store_fail_over_mac(struct device *d,
 360                                            struct device_attribute *attr,
 361                                            const char *buf, size_t count)
 362 {
 363         struct bonding *bond = to_bond(d);
 364         int ret;
 365
 366         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_FAIL_OVER_MAC, (char *)buf);
 367         if (!ret)
 368                 ret = count;
 369
 370         return ret;
 371 }
 372
 373 static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR,
 374                    bonding_show_fail_over_mac, bonding_store_fail_over_mac);
 375
 376 /*
 377  * Show and set the arp timer interval.  There are two tricky bits
 378  * here.  First, if ARP monitoring is activated, then we must disable
 379  * MII monitoring.  Second, if the ARP timer isn't running, we must
 380  * start it.
 381  */
 382 static ssize_t bonding_show_arp_interval(struct device *d,
 383                                          struct device_attribute *attr,
 384                                          char *buf)
 385 {
 386         struct bonding *bond = to_bond(d);
 387
 388         return sprintf(buf, "%d\n", bond->params.arp_interval);
 389 }
 390
 391 static ssize_t bonding_store_arp_interval(struct device *d,
 392                                           struct device_attribute *attr,
 393                                           const char *buf, size_t count)
 394 {
 395         struct bonding *bond = to_bond(d);
 396         int ret;
 397
 398         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_INTERVAL, (char *)buf);
 399         if (!ret)
 400                 ret = count;
 401
 402         return ret;
 403 }
 404 static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR,
 405                    bonding_show_arp_interval, bonding_store_arp_interval);
 406
 407 /*
 408  * Show and set the arp targets.
 409  */
 410 static ssize_t bonding_show_arp_targets(struct device *d,
 411                                         struct device_attribute *attr,
 412                                         char *buf)
 413 {
 414         struct bonding *bond = to_bond(d);
 415         int i, res = 0;
 416
 417         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 418                 if (bond->params.arp_targets[i])
 419                         res += sprintf(buf + res, "%pI4 ",
 420                                        &bond->params.arp_targets[i]);
 421         }
 422         if (res)
 423                 buf[res-1] = '\n'; /* eat the leftover space */
 424
 425         return res;
 426 }
 427
 428 static ssize_t bonding_store_arp_targets(struct device *d,
 429                                          struct device_attribute *attr,
 430                                          const char *buf, size_t count)
 431 {
 432         struct bonding *bond = to_bond(d);
 433         int ret;
 434
 435         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_TARGETS, (char *)buf);
 436         if (!ret)
 437                 ret = count;
 438
 439         return ret;
 440 }
 441 static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
 442
 443 /*
 444  * Show and set the up and down delays.  These must be multiples of the
 445  * MII monitoring value, and are stored internally as the multiplier.
 446  * Thus, we must translate to MS for the real world.
 447  */
 448 static ssize_t bonding_show_downdelay(struct device *d,
 449                                       struct device_attribute *attr,
 450                                       char *buf)
 451 {
 452         struct bonding *bond = to_bond(d);
 453
 454         return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
 455 }
 456
 457 static ssize_t bonding_store_downdelay(struct device *d,
 458                                        struct device_attribute *attr,
 459                                        const char *buf, size_t count)
 460 {
 461         struct bonding *bond = to_bond(d);
 462         int ret;
 463
 464         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_DOWNDELAY, (char *)buf);
 465         if (!ret)
 466                 ret = count;
 467
 468         return ret;
 469 }
 470 static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR,
 471                    bonding_show_downdelay, bonding_store_downdelay);
 472
 473 static ssize_t bonding_show_updelay(struct device *d,
 474                                     struct device_attribute *attr,
 475                                     char *buf)
 476 {
 477         struct bonding *bond = to_bond(d);
 478
 479         return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon);
 480
 481 }
 482
 483 static ssize_t bonding_store_updelay(struct device *d,
 484                                      struct device_attribute *attr,
 485                                      const char *buf, size_t count)
 486 {
 487         struct bonding *bond = to_bond(d);
 488         int ret;
 489
 490         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_UPDELAY, (char *)buf);
 491         if (!ret)
 492                 ret = count;
 493
 494         return ret;
 495 }
 496 static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR,
 497                    bonding_show_updelay, bonding_store_updelay);
 498
 499 /*
 500  * Show and set the LACP interval.  Interface must be down, and the mode
 501  * must be set to 802.3ad mode.
 502  */
 503 static ssize_t bonding_show_lacp(struct device *d,
 504                                  struct device_attribute *attr,
 505                                  char *buf)
 506 {
 507         struct bonding *bond = to_bond(d);
 508         const struct bond_opt_value *val;
 509
 510         val = bond_opt_get_val(BOND_OPT_LACP_RATE, bond->params.lacp_fast);
 511
 512         return sprintf(buf, "%s %d\n", val->string, bond->params.lacp_fast);
 513 }
 514
 515 static ssize_t bonding_store_lacp(struct device *d,
 516                                   struct device_attribute *attr,
 517                                   const char *buf, size_t count)
 518 {
 519         struct bonding *bond = to_bond(d);
 520         int ret;
 521
 522         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_LACP_RATE, (char *)buf);
 523         if (!ret)
 524                 ret = count;
 525
 526         return ret;
 527 }
 528 static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR,
 529                    bonding_show_lacp, bonding_store_lacp);
 530
 531 static ssize_t bonding_show_min_links(struct device *d,
 532                                       struct device_attribute *attr,
 533                                       char *buf)
 534 {
 535         struct bonding *bond = to_bond(d);
 536
 537         return sprintf(buf, "%d\n", bond->params.min_links);
 538 }
 539
 540 static ssize_t bonding_store_min_links(struct device *d,
 541                                        struct device_attribute *attr,
 542                                        const char *buf, size_t count)
 543 {
 544         struct bonding *bond = to_bond(d);
 545         int ret;
 546
 547         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MINLINKS, (char *)buf);
 548         if (!ret)
 549                 ret = count;
 550
 551         return ret;
 552 }
 553 static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR,
 554                    bonding_show_min_links, bonding_store_min_links);
 555
 556 static ssize_t bonding_show_ad_select(struct device *d,
 557                                       struct device_attribute *attr,
 558                                       char *buf)
 559 {
 560         struct bonding *bond = to_bond(d);
 561         const struct bond_opt_value *val;
 562
 563         val = bond_opt_get_val(BOND_OPT_AD_SELECT, bond->params.ad_select);
 564
 565         return sprintf(buf, "%s %d\n", val->string, bond->params.ad_select);
 566 }
 567
 568
 569 static ssize_t bonding_store_ad_select(struct device *d,
 570                                        struct device_attribute *attr,
 571                                        const char *buf, size_t count)
 572 {
 573         struct bonding *bond = to_bond(d);
 574         int ret;
 575
 576         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_AD_SELECT, (char *)buf);
 577         if (!ret)
 578                 ret = count;
 579
 580         return ret;
 581 }
 582 static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR,
 583                    bonding_show_ad_select, bonding_store_ad_select);
 584
 585 /*
 586  * Show and set the number of peer notifications to send after a failover event.
 587  */
 588 static ssize_t bonding_show_num_peer_notif(struct device *d,
 589                                            struct device_attribute *attr,
 590                                            char *buf)
 591 {
 592         struct bonding *bond = to_bond(d);
 593         return sprintf(buf, "%d\n", bond->params.num_peer_notif);
 594 }
 595
 596 static ssize_t bonding_store_num_peer_notif(struct device *d,
 597                                             struct device_attribute *attr,
 598                                             const char *buf, size_t count)
 599 {
 600         struct bonding *bond = to_bond(d);
 601         int ret;
 602
 603         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_NUM_PEER_NOTIF, (char *)buf);
 604         if (!ret)
 605                 ret = count;
 606
 607         return ret;
 608 }
 609 static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR,
 610                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 611 static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR,
 612                    bonding_show_num_peer_notif, bonding_store_num_peer_notif);
 613
 614 /*
 615  * Show and set the MII monitor interval.  There are two tricky bits
 616  * here.  First, if MII monitoring is activated, then we must disable
 617  * ARP monitoring.  Second, if the timer isn't running, we must
 618  * start it.
 619  */
 620 static ssize_t bonding_show_miimon(struct device *d,
 621                                    struct device_attribute *attr,
 622                                    char *buf)
 623 {
 624         struct bonding *bond = to_bond(d);
 625
 626         return sprintf(buf, "%d\n", bond->params.miimon);
 627 }
 628
 629 static ssize_t bonding_store_miimon(struct device *d,
 630                                     struct device_attribute *attr,
 631                                     const char *buf, size_t count)
 632 {
 633         struct bonding *bond = to_bond(d);
 634         int ret;
 635
 636         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MIIMON, (char *)buf);
 637         if (!ret)
 638                 ret = count;
 639
 640         return ret;
 641 }
 642 static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
 643                    bonding_show_miimon, bonding_store_miimon);
 644
 645 /*
 646  * Show and set the primary slave.  The store function is much
 647  * simpler than bonding_store_slaves function because it only needs to
 648  * handle one interface name.
 649  * The bond must be a mode that supports a primary for this be
 650  * set.
 651  */
 652 static ssize_t bonding_show_primary(struct device *d,
 653                                     struct device_attribute *attr,
 654                                     char *buf)
 655 {
 656         int count = 0;
 657         struct bonding *bond = to_bond(d);
 658
 659         if (bond->primary_slave)
 660                 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
 661
 662         return count;
 663 }
 664
 665 static ssize_t bonding_store_primary(struct device *d,
 666                                      struct device_attribute *attr,
 667                                      const char *buf, size_t count)
 668 {
 669         struct bonding *bond = to_bond(d);
 670         int ret;
 671
 672         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_PRIMARY, (char *)buf);
 673         if (!ret)
 674                 ret = count;
 675
 676         return ret;
 677 }
 678 static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR,
 679                    bonding_show_primary, bonding_store_primary);
 680
 681 /*
 682  * Show and set the primary_reselect flag.
 683  */
 684 static ssize_t bonding_show_primary_reselect(struct device *d,
 685                                              struct device_attribute *attr,
 686                                              char *buf)
 687 {
 688         struct bonding *bond = to_bond(d);
 689         const struct bond_opt_value *val;
 690
 691         val = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT,
 692                                bond->params.primary_reselect);
 693
 694         return sprintf(buf, "%s %d\n",
 695                        val->string, bond->params.primary_reselect);
 696 }
 697
 698 static ssize_t bonding_store_primary_reselect(struct device *d,
 699                                               struct device_attribute *attr,
 700                                               const char *buf, size_t count)
 701 {
 702         struct bonding *bond = to_bond(d);
 703         int ret;
 704
 705         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_PRIMARY_RESELECT,
 706                                    (char *)buf);
 707         if (!ret)
 708                 ret = count;
 709
 710         return ret;
 711 }
 712 static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR,
 713                    bonding_show_primary_reselect,
 714                    bonding_store_primary_reselect);
 715
 716 /*
 717  * Show and set the use_carrier flag.
 718  */
 719 static ssize_t bonding_show_carrier(struct device *d,
 720                                     struct device_attribute *attr,
 721                                     char *buf)
 722 {
 723         struct bonding *bond = to_bond(d);
 724
 725         return sprintf(buf, "%d\n", bond->params.use_carrier);
 726 }
 727
 728 static ssize_t bonding_store_carrier(struct device *d,
 729                                      struct device_attribute *attr,
 730                                      const char *buf, size_t count)
 731 {
 732         struct bonding *bond = to_bond(d);
 733         int ret;
 734
 735         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_USE_CARRIER, (char *)buf);
 736         if (!ret)
 737                 ret = count;
 738
 739         return ret;
 740 }
 741 static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR,
 742                    bonding_show_carrier, bonding_store_carrier);
 743
 744
 745 /*
 746  * Show and set currently active_slave.
 747  */
 748 static ssize_t bonding_show_active_slave(struct device *d,
 749                                          struct device_attribute *attr,
 750                                          char *buf)
 751 {
 752         struct bonding *bond = to_bond(d);
 753         struct net_device *slave_dev;
 754         int count = 0;
 755
 756         rcu_read_lock();
 757         slave_dev = bond_option_active_slave_get_rcu(bond);
 758         if (slave_dev)
 759                 count = sprintf(buf, "%s\n", slave_dev->name);
 760         rcu_read_unlock();
 761
 762         return count;
 763 }
 764
 765 static ssize_t bonding_store_active_slave(struct device *d,
 766                                           struct device_attribute *attr,
 767                                           const char *buf, size_t count)
 768 {
 769         struct bonding *bond = to_bond(d);
 770         int ret;
 771
 772         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ACTIVE_SLAVE, (char *)buf);
 773         if (!ret)
 774                 ret = count;
 775
 776         return ret;
 777 }
 778 static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR,
 779                    bonding_show_active_slave, bonding_store_active_slave);
 780
 781
 782 /*
 783  * Show link status of the bond interface.
 784  */
 785 static ssize_t bonding_show_mii_status(struct device *d,
 786                                        struct device_attribute *attr,
 787                                        char *buf)
 788 {
 789         struct bonding *bond = to_bond(d);
 790
 791         return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down");
 792 }
 793 static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
 794
 795 /*
 796  * Show current 802.3ad aggregator ID.
 797  */
 798 static ssize_t bonding_show_ad_aggregator(struct device *d,
 799                                           struct device_attribute *attr,
 800                                           char *buf)
 801 {
 802         int count = 0;
 803         struct bonding *bond = to_bond(d);
 804
 805         if (bond->params.mode == BOND_MODE_8023AD) {
 806                 struct ad_info ad_info;
 807                 count = sprintf(buf, "%d\n",
 808                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 809                                 ?  0 : ad_info.aggregator_id);
 810         }
 811
 812         return count;
 813 }
 814 static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
 815
 816
 817 /*
 818  * Show number of active 802.3ad ports.
 819  */
 820 static ssize_t bonding_show_ad_num_ports(struct device *d,
 821                                          struct device_attribute *attr,
 822                                          char *buf)
 823 {
 824         int count = 0;
 825         struct bonding *bond = to_bond(d);
 826
 827         if (bond->params.mode == BOND_MODE_8023AD) {
 828                 struct ad_info ad_info;
 829                 count = sprintf(buf, "%d\n",
 830                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 831                                 ?  0 : ad_info.ports);
 832         }
 833
 834         return count;
 835 }
 836 static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
 837
 838
 839 /*
 840  * Show current 802.3ad actor key.
 841  */
 842 static ssize_t bonding_show_ad_actor_key(struct device *d,
 843                                          struct device_attribute *attr,
 844                                          char *buf)
 845 {
 846         int count = 0;
 847         struct bonding *bond = to_bond(d);
 848
 849         if (bond->params.mode == BOND_MODE_8023AD) {
 850                 struct ad_info ad_info;
 851                 count = sprintf(buf, "%d\n",
 852                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 853                                 ?  0 : ad_info.actor_key);
 854         }
 855
 856         return count;
 857 }
 858 static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
 859
 860
 861 /*
 862  * Show current 802.3ad partner key.
 863  */
 864 static ssize_t bonding_show_ad_partner_key(struct device *d,
 865                                            struct device_attribute *attr,
 866                                            char *buf)
 867 {
 868         int count = 0;
 869         struct bonding *bond = to_bond(d);
 870
 871         if (bond->params.mode == BOND_MODE_8023AD) {
 872                 struct ad_info ad_info;
 873                 count = sprintf(buf, "%d\n",
 874                                 bond_3ad_get_active_agg_info(bond, &ad_info)
 875                                 ?  0 : ad_info.partner_key);
 876         }
 877
 878         return count;
 879 }
 880 static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
 881
 882
 883 /*
 884  * Show current 802.3ad partner mac.
 885  */
 886 static ssize_t bonding_show_ad_partner_mac(struct device *d,
 887                                            struct device_attribute *attr,
 888                                            char *buf)
 889 {
 890         int count = 0;
 891         struct bonding *bond = to_bond(d);
 892
 893         if (bond->params.mode == BOND_MODE_8023AD) {
 894                 struct ad_info ad_info;
 895                 if (!bond_3ad_get_active_agg_info(bond, &ad_info))
 896                         count = sprintf(buf, "%pM\n", ad_info.partner_system);
 897         }
 898
 899         return count;
 900 }
 901 static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
 902
 903 /*
 904  * Show the queue_ids of the slaves in the current bond.
 905  */
 906 static ssize_t bonding_show_queue_id(struct device *d,
 907                                      struct device_attribute *attr,
 908                                      char *buf)
 909 {
 910         struct bonding *bond = to_bond(d);
 911         struct list_head *iter;
 912         struct slave *slave;
 913         int res = 0;
 914
 915         if (!rtnl_trylock())
 916                 return restart_syscall();
 917
 918         bond_for_each_slave(bond, slave, iter) {
 919                 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
 920                         /* not enough space for another interface_name:queue_id pair */
 921                         if ((PAGE_SIZE - res) > 10)
 922                                 res = PAGE_SIZE - 10;
 923                         res += sprintf(buf + res, "++more++ ");
 924                         break;
 925                 }
 926                 res += sprintf(buf + res, "%s:%d ",
 927                                slave->dev->name, slave->queue_id);
 928         }
 929         if (res)
 930                 buf[res-1] = '\n'; /* eat the leftover space */
 931
 932         rtnl_unlock();
 933
 934         return res;
 935 }
 936
 937 /*
 938  * Set the queue_ids of the  slaves in the current bond.  The bond
 939  * interface must be enslaved for this to work.
 940  */
 941 static ssize_t bonding_store_queue_id(struct device *d,
 942                                       struct device_attribute *attr,
 943                                       const char *buffer, size_t count)
 944 {
 945         struct bonding *bond = to_bond(d);
 946         int ret;
 947
 948         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_QUEUE_ID, (char *)buffer);
 949         if (!ret)
 950                 ret = count;
 951
 952         return ret;
 953 }
 954 static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id,
 955                    bonding_store_queue_id);
 956
 957
 958 /*
 959  * Show and set the all_slaves_active flag.
 960  */
 961 static ssize_t bonding_show_slaves_active(struct device *d,
 962                                           struct device_attribute *attr,
 963                                           char *buf)
 964 {
 965         struct bonding *bond = to_bond(d);
 966
 967         return sprintf(buf, "%d\n", bond->params.all_slaves_active);
 968 }
 969
 970 static ssize_t bonding_store_slaves_active(struct device *d,
 971                                            struct device_attribute *attr,
 972                                            const char *buf, size_t count)
 973 {
 974         struct bonding *bond = to_bond(d);
 975         int ret;
 976
 977         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ALL_SLAVES_ACTIVE,
 978                                    (char *)buf);
 979         if (!ret)
 980                 ret = count;
 981
 982         return ret;
 983 }
 984 static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR,
 985                    bonding_show_slaves_active, bonding_store_slaves_active);
 986
 987 /*
 988  * Show and set the number of IGMP membership reports to send on link failure
 989  */
 990 static ssize_t bonding_show_resend_igmp(struct device *d,
 991                                         struct device_attribute *attr,
 992                                         char *buf)
 993 {
 994         struct bonding *bond = to_bond(d);
 995
 996         return sprintf(buf, "%d\n", bond->params.resend_igmp);
 997 }
 998
 999 static ssize_t bonding_store_resend_igmp(struct device *d,
1000                                          struct device_attribute *attr,
1001                                          const char *buf, size_t count)
1002 {
1003         struct bonding *bond = to_bond(d);
1004         int ret;
1005
1006         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_RESEND_IGMP, (char *)buf);
1007         if (!ret)
1008                 ret = count;
1009
1010         return ret;
1011 }
1012
1013 static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR,
1014                    bonding_show_resend_igmp, bonding_store_resend_igmp);
1015
1016
1017 static ssize_t bonding_show_lp_interval(struct device *d,
1018                                         struct device_attribute *attr,
1019                                         char *buf)
1020 {
1021         struct bonding *bond = to_bond(d);
1022         return sprintf(buf, "%d\n", bond->params.lp_interval);
1023 }
1024
1025 static ssize_t bonding_store_lp_interval(struct device *d,
1026                                          struct device_attribute *attr,
1027                                          const char *buf, size_t count)
1028 {
1029         struct bonding *bond = to_bond(d);
1030         int ret;
1031
1032         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_LP_INTERVAL, (char *)buf);
1033         if (!ret)
1034                 ret = count;
1035
1036         return ret;
1037 }
1038
1039 static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR,
1040                    bonding_show_lp_interval, bonding_store_lp_interval);
1041
1042 static ssize_t bonding_show_packets_per_slave(struct device *d,
1043                                               struct device_attribute *attr,
1044                                               char *buf)
1045 {
1046         struct bonding *bond = to_bond(d);
1047         unsigned int packets_per_slave = bond->params.packets_per_slave;
1048         return sprintf(buf, "%u\n", packets_per_slave);
1049 }
1050
1051 static ssize_t bonding_store_packets_per_slave(struct device *d,
1052                                                struct device_attribute *attr,
1053                                                const char *buf, size_t count)
1054 {
1055         struct bonding *bond = to_bond(d);
1056         int ret;
1057
1058         ret = bond_opt_tryset_rtnl(bond, BOND_OPT_PACKETS_PER_SLAVE,
1059                                    (char *)buf);
1060         if (!ret)
1061                 ret = count;
1062
1063         return ret;
1064 }
1065
1066 static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR,
1067                    bonding_show_packets_per_slave,
1068                    bonding_store_packets_per_slave);
1069
1070 static struct attribute *per_bond_attrs[] = {
1071         &dev_attr_slaves.attr,
1072         &dev_attr_mode.attr,
1073         &dev_attr_fail_over_mac.attr,
1074         &dev_attr_arp_validate.attr,
1075         &dev_attr_arp_all_targets.attr,
1076         &dev_attr_arp_interval.attr,
1077         &dev_attr_arp_ip_target.attr,
1078         &dev_attr_downdelay.attr,
1079         &dev_attr_updelay.attr,
1080         &dev_attr_lacp_rate.attr,
1081         &dev_attr_ad_select.attr,
1082         &dev_attr_xmit_hash_policy.attr,
1083         &dev_attr_num_grat_arp.attr,
1084         &dev_attr_num_unsol_na.attr,
1085         &dev_attr_miimon.attr,
1086         &dev_attr_primary.attr,
1087         &dev_attr_primary_reselect.attr,
1088         &dev_attr_use_carrier.attr,
1089         &dev_attr_active_slave.attr,
1090         &dev_attr_mii_status.attr,
1091         &dev_attr_ad_aggregator.attr,
1092         &dev_attr_ad_num_ports.attr,
1093         &dev_attr_ad_actor_key.attr,
1094         &dev_attr_ad_partner_key.attr,
1095         &dev_attr_ad_partner_mac.attr,
1096         &dev_attr_queue_id.attr,
1097         &dev_attr_all_slaves_active.attr,
1098         &dev_attr_resend_igmp.attr,
1099         &dev_attr_min_links.attr,
1100         &dev_attr_lp_interval.attr,
1101         &dev_attr_packets_per_slave.attr,
1102         NULL,
1103 };
1104
1105 static struct attribute_group bonding_group = {
1106         .name = "bonding",
1107         .attrs = per_bond_attrs,
1108 };
1109
1110 /*
1111  * Initialize sysfs.  This sets up the bonding_masters file in
1112  * /sys/class/net.
1113  */
1114 int bond_create_sysfs(struct bond_net *bn)
1115 {
1116         int ret;
1117
1118         bn->class_attr_bonding_masters = class_attr_bonding_masters;
1119         sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
1120
1121         ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
1122                                           bn->net);
1123         /*
1124          * Permit multiple loads of the module by ignoring failures to
1125          * create the bonding_masters sysfs file.  Bonding devices
1126          * created by second or subsequent loads of the module will
1127          * not be listed in, or controllable by, bonding_masters, but
1128          * will have the usual "bonding" sysfs directory.
1129          *
1130          * This is done to preserve backwards compatibility for
1131          * initscripts/sysconfig, which load bonding multiple times to
1132          * configure multiple bonding devices.
1133          */
1134         if (ret == -EEXIST) {
1135                 /* Is someone being kinky and naming a device bonding_master? */
1136                 if (__dev_get_by_name(bn->net,
1137                                       class_attr_bonding_masters.attr.name))
1138                         pr_err("network device named %s already exists in sysfs\n",
1139                                class_attr_bonding_masters.attr.name);
1140                 ret = 0;
1141         }
1142
1143         return ret;
1144
1145 }
1146
1147 /*
1148  * Remove /sys/class/net/bonding_masters.
1149  */
1150 void bond_destroy_sysfs(struct bond_net *bn)
1151 {
1152         netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
1153 }
1154
1155 /*
1156  * Initialize sysfs for each bond.  This sets up and registers
1157  * the 'bondctl' directory for each individual bond under /sys/class/net.
1158  */
1159 void bond_prepare_sysfs_group(struct bonding *bond)
1160 {
1161         bond->dev->sysfs_groups[0] = &bonding_group;
1162 }
1163