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