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