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