Merge branch 'master'
[linux-2.6] / 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  * Changes:
24  *
25  * 2004/12/12 - Mitch Williams <mitch.a.williams at intel dot com>
26  *      - Initial creation of sysfs interface.
27  *
28  * 2005/06/22 - Radheka Godse <radheka.godse at intel dot com>
29  *      - Added ifenslave -c type functionality to sysfs
30  *      - Added sysfs files for attributes such as  MII Status and
31  *        802.3ad aggregator that are displayed in /proc
32  *      - Added "name value" format to sysfs "mode" and
33  *        "lacp_rate", for e.g., "active-backup 1" or "slow 0" for
34  *        consistency and ease of script parsing
35  *      - Fixed reversal of octets in arp_ip_targets via sysfs
36  *      - sysfs support to handle bond interface re-naming
37  *      - Moved all sysfs entries into /sys/class/net instead of
38  *        of using a standalone subsystem.
39  *      - Added sysfs symlinks between masters and slaves
40  *      - Corrected bugs in sysfs unload path when creating bonds
41  *        with existing interface names.
42  *      - Removed redundant sysfs stat file since it duplicates slave info
43  *        from the proc file
44  *      - Fixed errors in sysfs show/store arp targets.
45  *      - For consistency with ifenslave, instead of exiting
46  *        with an error, updated bonding sysfs to
47  *        close and attempt to enslave an up adapter.
48  *      - Fixed NULL dereference when adding a slave interface
49  *        that does not exist.
50  *      - Added checks in sysfs bonding to reject invalid ip addresses
51  *      - Synch up with post linux-2.6.12 bonding changes
52  *      - Created sysfs bond attrib for xmit_hash_policy
53  *
54  * 2005/09/19 - Mitch Williams <mitch.a.williams at intel dot com>
55  *      - Changed semantics of multi-item files to be command-based
56  *        instead of list-based.
57  *      - Changed ARP target handler to use in_aton instead of sscanf
58  *      - Style changes.
59  * 2005/09/27 - Mitch Williams <mitch.a.williams at intel dot com>
60  *      - Made line endings consistent.
61  *      - Removed "none" from primary output - just put blank instead
62  *      - Fixed bug with long interface names
63  */
64 #include <linux/config.h>
65 #include <linux/kernel.h>
66 #include <linux/module.h>
67 #include <linux/sched.h>
68 #include <linux/device.h>
69 #include <linux/sysdev.h>
70 #include <linux/fs.h>
71 #include <linux/types.h>
72 #include <linux/string.h>
73 #include <linux/netdevice.h>
74 #include <linux/inetdevice.h>
75 #include <linux/in.h>
76 #include <linux/sysfs.h>
77 #include <linux/string.h>
78 #include <linux/ctype.h>
79 #include <linux/inet.h>
80 #include <linux/rtnetlink.h>
81
82 /* #define BONDING_DEBUG 1 */
83 #include "bonding.h"
84 #define to_class_dev(obj) container_of(obj,struct class_device,kobj)
85 #define to_net_dev(class) container_of(class, struct net_device, class_dev)
86 #define to_bond(cd)     ((struct bonding *)(to_net_dev(cd)->priv))
87
88 /*---------------------------- Declarations -------------------------------*/
89
90
91 extern struct list_head bond_dev_list;
92 extern struct bond_params bonding_defaults;
93 extern struct bond_parm_tbl bond_mode_tbl[];
94 extern struct bond_parm_tbl bond_lacp_tbl[];
95 extern struct bond_parm_tbl xmit_hashtype_tbl[];
96
97 static int expected_refcount = -1;
98 static struct class *netdev_class;
99 /*--------------------------- Data Structures -----------------------------*/
100
101 /* Bonding sysfs lock.  Why can't we just use the subsytem lock?
102  * Because kobject_register tries to acquire the subsystem lock.  If
103  * we already hold the lock (which we would if the user was creating
104  * a new bond through the sysfs interface), we deadlock.
105  * This lock is only needed when deleting a bond - we need to make sure
106  * that we don't collide with an ongoing ioctl.
107  */
108
109 struct rw_semaphore bonding_rwsem;
110
111
112
113
114 /*------------------------------ Functions --------------------------------*/
115
116 /*
117  * "show" function for the bond_masters attribute.
118  * The class parameter is ignored.
119  */
120 static ssize_t bonding_show_bonds(struct class *cls, char *buffer)
121 {
122         int res = 0;
123         struct bonding *bond;
124
125         down_read(&(bonding_rwsem));
126
127         list_for_each_entry(bond, &bond_dev_list, bond_list) {
128                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
129                         /* not enough space for another interface name */
130                         if ((PAGE_SIZE - res) > 10)
131                                 res = PAGE_SIZE - 10;
132                         res += sprintf(buffer + res, "++more++");
133                         break;
134                 }
135                 res += sprintf(buffer + res, "%s ",
136                                bond->dev->name);
137         }
138         res += sprintf(buffer + res, "\n");
139         res++;
140         up_read(&(bonding_rwsem));
141         return res;
142 }
143
144 /*
145  * "store" function for the bond_masters attribute.  This is what
146  * creates and deletes entire bonds.
147  *
148  * The class parameter is ignored.
149  *
150  */
151
152 static ssize_t bonding_store_bonds(struct class *cls, const char *buffer, size_t count)
153 {
154         char command[IFNAMSIZ + 1] = {0, };
155         char *ifname;
156         int res = count;
157         struct bonding *bond;
158         struct bonding *nxt;
159
160         down_write(&(bonding_rwsem));
161         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
162         ifname = command + 1;
163         if ((strlen(command) <= 1) ||
164             !dev_valid_name(ifname))
165                 goto err_no_cmd;
166
167         if (command[0] == '+') {
168
169                 /* Check to see if the bond already exists. */
170                 list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list)
171                         if (strnicmp(bond->dev->name, ifname, IFNAMSIZ) == 0) {
172                                 printk(KERN_ERR DRV_NAME
173                                         ": cannot add bond %s; it already exists\n",
174                                         ifname);
175                                 res = -EPERM;
176                                 goto out;
177                         }
178
179                 printk(KERN_INFO DRV_NAME
180                         ": %s is being created...\n", ifname);
181                 if (bond_create(ifname, &bonding_defaults, &bond)) {
182                         printk(KERN_INFO DRV_NAME
183                         ": %s interface already exists. Bond creation failed.\n",
184                         ifname);
185                         res = -EPERM;
186                 }
187                 goto out;
188         }
189
190         if (command[0] == '-') {
191                 list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list)
192                         if (strnicmp(bond->dev->name, ifname, IFNAMSIZ) == 0) {
193                                 rtnl_lock();
194                                 /* check the ref count on the bond's kobject.
195                                  * If it's > expected, then there's a file open,
196                                  * and we have to fail.
197                                  */
198                                 if (atomic_read(&bond->dev->class_dev.kobj.kref.refcount)
199                                                         > expected_refcount){
200                                         rtnl_unlock();
201                                         printk(KERN_INFO DRV_NAME
202                                                 ": Unable remove bond %s due to open references.\n",
203                                                 ifname);
204                                         res = -EPERM;
205                                         goto out;
206                                 }
207                                 printk(KERN_INFO DRV_NAME
208                                         ": %s is being deleted...\n",
209                                         bond->dev->name);
210                                 unregister_netdevice(bond->dev);
211                                 bond_deinit(bond->dev);
212                                 bond_destroy_sysfs_entry(bond);
213                                 rtnl_unlock();
214                                 goto out;
215                         }
216
217                 printk(KERN_ERR DRV_NAME
218                         ": unable to delete non-existent bond %s\n", ifname);
219                 res = -ENODEV;
220                 goto out;
221         }
222
223 err_no_cmd:
224         printk(KERN_ERR DRV_NAME
225                 ": no command found in bonding_masters. Use +ifname or -ifname.\n");
226         res = -EPERM;
227
228         /* Always return either count or an error.  If you return 0, you'll
229          * get called forever, which is bad.
230          */
231 out:
232         up_write(&(bonding_rwsem));
233         return res;
234 }
235 /* class attribute for bond_masters file.  This ends up in /sys/class/net */
236 static CLASS_ATTR(bonding_masters,  S_IWUSR | S_IRUGO,
237                   bonding_show_bonds, bonding_store_bonds);
238
239 int bond_create_slave_symlinks(struct net_device *master, struct net_device *slave)
240 {
241         char linkname[IFNAMSIZ+7];
242         int ret = 0;
243
244         /* first, create a link from the slave back to the master */
245         ret = sysfs_create_link(&(slave->class_dev.kobj), &(master->class_dev.kobj),
246                                 "master");
247         if (ret)
248                 return ret;
249         /* next, create a link from the master to the slave */
250         sprintf(linkname,"slave_%s",slave->name);
251         ret = sysfs_create_link(&(master->class_dev.kobj), &(slave->class_dev.kobj),
252                                 linkname);
253         return ret;
254
255 }
256
257 void bond_destroy_slave_symlinks(struct net_device *master, struct net_device *slave)
258 {
259         char linkname[IFNAMSIZ+7];
260
261         sysfs_remove_link(&(slave->class_dev.kobj), "master");
262         sprintf(linkname,"slave_%s",slave->name);
263         sysfs_remove_link(&(master->class_dev.kobj), linkname);
264 }
265
266
267 /*
268  * Show the slaves in the current bond.
269  */
270 static ssize_t bonding_show_slaves(struct class_device *cd, char *buf)
271 {
272         struct slave *slave;
273         int i, res = 0;
274         struct bonding *bond = to_bond(cd);
275
276         read_lock_bh(&bond->lock);
277         bond_for_each_slave(bond, slave, i) {
278                 if (res > (PAGE_SIZE - IFNAMSIZ)) {
279                         /* not enough space for another interface name */
280                         if ((PAGE_SIZE - res) > 10)
281                                 res = PAGE_SIZE - 10;
282                         res += sprintf(buf + res, "++more++");
283                         break;
284                 }
285                 res += sprintf(buf + res, "%s ", slave->dev->name);
286         }
287         read_unlock_bh(&bond->lock);
288         res += sprintf(buf + res, "\n");
289         res++;
290         return res;
291 }
292
293 /*
294  * Set the slaves in the current bond.  The bond interface must be
295  * up for this to succeed.
296  * This function is largely the same flow as bonding_update_bonds().
297  */
298 static ssize_t bonding_store_slaves(struct class_device *cd, const char *buffer, size_t count)
299 {
300         char command[IFNAMSIZ + 1] = { 0, };
301         char *ifname;
302         int i, res, found, ret = count;
303         struct slave *slave;
304         struct net_device *dev = 0;
305         struct bonding *bond = to_bond(cd);
306
307         /* Quick sanity check -- is the bond interface up? */
308         if (!(bond->dev->flags & IFF_UP)) {
309                 printk(KERN_ERR DRV_NAME
310                        ": %s: Unable to update slaves because interface is down.\n",
311                        bond->dev->name);
312                 ret = -EPERM;
313                 goto out;
314         }
315
316         /* Note:  We can't hold bond->lock here, as bond_create grabs it. */
317
318         sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
319         ifname = command + 1;
320         if ((strlen(command) <= 1) ||
321             !dev_valid_name(ifname))
322                 goto err_no_cmd;
323
324         if (command[0] == '+') {
325
326                 /* Got a slave name in ifname.  Is it already in the list? */
327                 found = 0;
328                 read_lock_bh(&bond->lock);
329                 bond_for_each_slave(bond, slave, i)
330                         if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) {
331                                 printk(KERN_ERR DRV_NAME
332                                        ": %s: Interface %s is already enslaved!\n",
333                                        bond->dev->name, ifname);
334                                 ret = -EPERM;
335                                 read_unlock_bh(&bond->lock);
336                                 goto out;
337                         }
338
339                 read_unlock_bh(&bond->lock);
340                 printk(KERN_INFO DRV_NAME ": %s: Adding slave %s.\n",
341                        bond->dev->name, ifname);
342                 dev = dev_get_by_name(ifname);
343                 if (!dev) {
344                         printk(KERN_INFO DRV_NAME
345                                ": %s: Interface %s does not exist!\n",
346                                bond->dev->name, ifname);
347                         ret = -EPERM;
348                         goto out;
349                 }
350                 else
351                         dev_put(dev);
352
353                 if (dev->flags & IFF_UP) {
354                         printk(KERN_ERR DRV_NAME
355                                ": %s: Error: Unable to enslave %s "
356                                "because it is already up.\n",
357                                bond->dev->name, dev->name);
358                         ret = -EPERM;
359                         goto out;
360                 }
361                 /* If this is the first slave, then we need to set
362                    the master's hardware address to be the same as the
363                    slave's. */
364                 if (!(*((u32 *) & (bond->dev->dev_addr[0])))) {
365                         memcpy(bond->dev->dev_addr, dev->dev_addr,
366                                dev->addr_len);
367                 }
368
369                 /* Set the slave's MTU to match the bond */
370                 if (dev->mtu != bond->dev->mtu) {
371                         if (dev->change_mtu) {
372                                 res = dev->change_mtu(dev,
373                                                       bond->dev->mtu);
374                                 if (res) {
375                                         ret = res;
376                                         goto out;
377                                 }
378                         } else {
379                                 dev->mtu = bond->dev->mtu;
380                         }
381                 }
382                 rtnl_lock();
383                 res = bond_enslave(bond->dev, dev);
384                 rtnl_unlock();
385                 if (res) {
386                         ret = res;
387                 }
388                 goto out;
389         }
390
391         if (command[0] == '-') {
392                 dev = NULL;
393                 bond_for_each_slave(bond, slave, i)
394                         if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) {
395                                 dev = slave->dev;
396                                 break;
397                         }
398                 if (dev) {
399                         printk(KERN_INFO DRV_NAME ": %s: Removing slave %s\n",
400                                 bond->dev->name, dev->name);
401                         rtnl_lock();
402                         res = bond_release(bond->dev, dev);
403                         rtnl_unlock();
404                         if (res) {
405                                 ret = res;
406                                 goto out;
407                         }
408                         /* set the slave MTU to the default */
409                         if (dev->change_mtu) {
410                                 dev->change_mtu(dev, 1500);
411                         } else {
412                                 dev->mtu = 1500;
413                         }
414                 }
415                 else {
416                         printk(KERN_ERR DRV_NAME ": unable to remove non-existent slave %s for bond %s.\n",
417                                 ifname, bond->dev->name);
418                         ret = -ENODEV;
419                 }
420                 goto out;
421         }
422
423 err_no_cmd:
424         printk(KERN_ERR DRV_NAME ": no command found in slaves file for bond %s. Use +ifname or -ifname.\n", bond->dev->name);
425         ret = -EPERM;
426
427 out:
428         return ret;
429 }
430
431 static CLASS_DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, bonding_store_slaves);
432
433 /*
434  * Show and set the bonding mode.  The bond interface must be down to
435  * change the mode.
436  */
437 static ssize_t bonding_show_mode(struct class_device *cd, char *buf)
438 {
439         struct bonding *bond = to_bond(cd);
440
441         return sprintf(buf, "%s %d\n",
442                         bond_mode_tbl[bond->params.mode].modename,
443                         bond->params.mode) + 1;
444 }
445
446 static ssize_t bonding_store_mode(struct class_device *cd, const char *buf, size_t count)
447 {
448         int new_value, ret = count;
449         struct bonding *bond = to_bond(cd);
450
451         if (bond->dev->flags & IFF_UP) {
452                 printk(KERN_ERR DRV_NAME
453                        ": unable to update mode of %s because interface is up.\n",
454                        bond->dev->name);
455                 ret = -EPERM;
456                 goto out;
457         }
458
459         new_value = bond_parse_parm((char *)buf, bond_mode_tbl);
460         if (new_value < 0)  {
461                 printk(KERN_ERR DRV_NAME
462                        ": %s: Ignoring invalid mode value %.*s.\n",
463                        bond->dev->name,
464                        (int)strlen(buf) - 1, buf);
465                 ret = -EINVAL;
466                 goto out;
467         } else {
468                 bond->params.mode = new_value;
469                 bond_set_mode_ops(bond, bond->params.mode);
470                 printk(KERN_INFO DRV_NAME ": %s: setting mode to %s (%d).\n",
471                         bond->dev->name, bond_mode_tbl[new_value].modename, new_value);
472         }
473 out:
474         return ret;
475 }
476 static CLASS_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, bonding_show_mode, bonding_store_mode);
477
478 /*
479  * Show and set the bonding transmit hash method.  The bond interface must be down to
480  * change the xmit hash policy.
481  */
482 static ssize_t bonding_show_xmit_hash(struct class_device *cd, char *buf)
483 {
484         int count;
485         struct bonding *bond = to_bond(cd);
486
487         if ((bond->params.mode != BOND_MODE_XOR) &&
488             (bond->params.mode != BOND_MODE_8023AD)) {
489                 // Not Applicable
490                 count = sprintf(buf, "NA\n") + 1;
491         } else {
492                 count = sprintf(buf, "%s %d\n",
493                         xmit_hashtype_tbl[bond->params.xmit_policy].modename,
494                         bond->params.xmit_policy) + 1;
495         }
496
497         return count;
498 }
499
500 static ssize_t bonding_store_xmit_hash(struct class_device *cd, const char *buf, size_t count)
501 {
502         int new_value, ret = count;
503         struct bonding *bond = to_bond(cd);
504
505         if (bond->dev->flags & IFF_UP) {
506                 printk(KERN_ERR DRV_NAME
507                        "%s: Interface is up. Unable to update xmit policy.\n",
508                        bond->dev->name);
509                 ret = -EPERM;
510                 goto out;
511         }
512
513         if ((bond->params.mode != BOND_MODE_XOR) &&
514             (bond->params.mode != BOND_MODE_8023AD)) {
515                 printk(KERN_ERR DRV_NAME
516                        "%s: Transmit hash policy is irrelevant in this mode.\n",
517                        bond->dev->name);
518                 ret = -EPERM;
519                 goto out;
520         }
521
522         new_value = bond_parse_parm((char *)buf, xmit_hashtype_tbl);
523         if (new_value < 0)  {
524                 printk(KERN_ERR DRV_NAME
525                        ": %s: Ignoring invalid xmit hash policy value %.*s.\n",
526                        bond->dev->name,
527                        (int)strlen(buf) - 1, buf);
528                 ret = -EINVAL;
529                 goto out;
530         } else {
531                 bond->params.xmit_policy = new_value;
532                 bond_set_mode_ops(bond, bond->params.mode);
533                 printk(KERN_INFO DRV_NAME ": %s: setting xmit hash policy to %s (%d).\n",
534                         bond->dev->name, xmit_hashtype_tbl[new_value].modename, new_value);
535         }
536 out:
537         return ret;
538 }
539 static CLASS_DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, bonding_show_xmit_hash, bonding_store_xmit_hash);
540
541 /*
542  * Show and set the arp timer interval.  There are two tricky bits
543  * here.  First, if ARP monitoring is activated, then we must disable
544  * MII monitoring.  Second, if the ARP timer isn't running, we must
545  * start it.
546  */
547 static ssize_t bonding_show_arp_interval(struct class_device *cd, char *buf)
548 {
549         struct bonding *bond = to_bond(cd);
550
551         return sprintf(buf, "%d\n", bond->params.arp_interval) + 1;
552 }
553
554 static ssize_t bonding_store_arp_interval(struct class_device *cd, const char *buf, size_t count)
555 {
556         int new_value, ret = count;
557         struct bonding *bond = to_bond(cd);
558
559         if (sscanf(buf, "%d", &new_value) != 1) {
560                 printk(KERN_ERR DRV_NAME
561                        ": %s: no arp_interval value specified.\n",
562                        bond->dev->name);
563                 ret = -EINVAL;
564                 goto out;
565         }
566         if (new_value < 0) {
567                 printk(KERN_ERR DRV_NAME
568                        ": %s: Invalid arp_interval value %d not in range 1-%d; rejected.\n",
569                        bond->dev->name, new_value, INT_MAX);
570                 ret = -EINVAL;
571                 goto out;
572         }
573
574         printk(KERN_INFO DRV_NAME
575                ": %s: Setting ARP monitoring interval to %d.\n",
576                bond->dev->name, new_value);
577         bond->params.arp_interval = new_value;
578         if (bond->params.miimon) {
579                 printk(KERN_INFO DRV_NAME
580                        ": %s: ARP monitoring cannot be used with MII monitoring. "
581                        "%s Disabling MII monitoring.\n",
582                        bond->dev->name, bond->dev->name);
583                 bond->params.miimon = 0;
584                 /* Kill MII timer, else it brings bond's link down */
585                 if (bond->arp_timer.function) {
586                         printk(KERN_INFO DRV_NAME
587                         ": %s: Kill MII timer, else it brings bond's link down...\n",
588                        bond->dev->name);
589                         del_timer_sync(&bond->mii_timer);
590                 }
591         }
592         if (!bond->params.arp_targets[0]) {
593                 printk(KERN_INFO DRV_NAME
594                        ": %s: ARP monitoring has been set up, "
595                        "but no ARP targets have been specified.\n",
596                        bond->dev->name);
597         }
598         if (bond->dev->flags & IFF_UP) {
599                 /* If the interface is up, we may need to fire off
600                  * the ARP timer.  If the interface is down, the
601                  * timer will get fired off when the open function
602                  * is called.
603                  */
604                 if (bond->arp_timer.function) {
605                         /* The timer's already set up, so fire it off */
606                         mod_timer(&bond->arp_timer, jiffies + 1);
607                 } else {
608                         /* Set up the timer. */
609                         init_timer(&bond->arp_timer);
610                         bond->arp_timer.expires = jiffies + 1;
611                         bond->arp_timer.data =
612                                 (unsigned long) bond->dev;
613                         if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
614                                 bond->arp_timer.function =
615                                         (void *)
616                                         &bond_activebackup_arp_mon;
617                         } else {
618                                 bond->arp_timer.function =
619                                         (void *)
620                                         &bond_loadbalance_arp_mon;
621                         }
622                         add_timer(&bond->arp_timer);
623                 }
624         }
625
626 out:
627         return ret;
628 }
629 static CLASS_DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR , bonding_show_arp_interval, bonding_store_arp_interval);
630
631 /*
632  * Show and set the arp targets.
633  */
634 static ssize_t bonding_show_arp_targets(struct class_device *cd, char *buf)
635 {
636         int i, res = 0;
637         struct bonding *bond = to_bond(cd);
638
639         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
640                 if (bond->params.arp_targets[i])
641                         res += sprintf(buf + res, "%u.%u.%u.%u ",
642                                NIPQUAD(bond->params.arp_targets[i]));
643         }
644         if (res)
645                 res--;  /* eat the leftover space */
646         res += sprintf(buf + res, "\n");
647         res++;
648         return res;
649 }
650
651 static ssize_t bonding_store_arp_targets(struct class_device *cd, const char *buf, size_t count)
652 {
653         u32 newtarget;
654         int i = 0, done = 0, ret = count;
655         struct bonding *bond = to_bond(cd);
656         u32 *targets;
657
658         targets = bond->params.arp_targets;
659         newtarget = in_aton(buf + 1);
660         /* look for adds */
661         if (buf[0] == '+') {
662                 if ((newtarget == 0) || (newtarget == INADDR_BROADCAST)) {
663                         printk(KERN_ERR DRV_NAME
664                                ": %s: invalid ARP target %u.%u.%u.%u specified for addition\n",
665                                bond->dev->name, NIPQUAD(newtarget));
666                         ret = -EINVAL;
667                         goto out;
668                 }
669                 /* look for an empty slot to put the target in, and check for dupes */
670                 for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
671                         if (targets[i] == newtarget) { /* duplicate */
672                                 printk(KERN_ERR DRV_NAME
673                                        ": %s: ARP target %u.%u.%u.%u is already present\n",
674                                        bond->dev->name, NIPQUAD(newtarget));
675                                 if (done)
676                                         targets[i] = 0;
677                                 ret = -EINVAL;
678                                 goto out;
679                         }
680                         if (targets[i] == 0 && !done) {
681                                 printk(KERN_INFO DRV_NAME
682                                        ": %s: adding ARP target %d.%d.%d.%d.\n",
683                                        bond->dev->name, NIPQUAD(newtarget));
684                                 done = 1;
685                                 targets[i] = newtarget;
686                         }
687                 }
688                 if (!done) {
689                         printk(KERN_ERR DRV_NAME
690                                ": %s: ARP target table is full!\n",
691                                bond->dev->name);
692                         ret = -EINVAL;
693                         goto out;
694                 }
695
696         }
697         else if (buf[0] == '-') {
698                 if ((newtarget == 0) || (newtarget == INADDR_BROADCAST)) {
699                         printk(KERN_ERR DRV_NAME
700                                ": %s: invalid ARP target %d.%d.%d.%d specified for removal\n",
701                                bond->dev->name, NIPQUAD(newtarget));
702                         ret = -EINVAL;
703                         goto out;
704                 }
705
706                 for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
707                         if (targets[i] == newtarget) {
708                                 printk(KERN_INFO DRV_NAME
709                                        ": %s: removing ARP target %d.%d.%d.%d.\n",
710                                        bond->dev->name, NIPQUAD(newtarget));
711                                 targets[i] = 0;
712                                 done = 1;
713                         }
714                 }
715                 if (!done) {
716                         printk(KERN_INFO DRV_NAME
717                                ": %s: unable to remove nonexistent ARP target %d.%d.%d.%d.\n",
718                                bond->dev->name, NIPQUAD(newtarget));
719                         ret = -EINVAL;
720                         goto out;
721                 }
722         }
723         else {
724                 printk(KERN_ERR DRV_NAME ": no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
725                         bond->dev->name);
726                 ret = -EPERM;
727                 goto out;
728         }
729
730 out:
731         return ret;
732 }
733 static CLASS_DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
734
735 /*
736  * Show and set the up and down delays.  These must be multiples of the
737  * MII monitoring value, and are stored internally as the multiplier.
738  * Thus, we must translate to MS for the real world.
739  */
740 static ssize_t bonding_show_downdelay(struct class_device *cd, char *buf)
741 {
742         struct bonding *bond = to_bond(cd);
743
744         return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon) + 1;
745 }
746
747 static ssize_t bonding_store_downdelay(struct class_device *cd, const char *buf, size_t count)
748 {
749         int new_value, ret = count;
750         struct bonding *bond = to_bond(cd);
751
752         if (!(bond->params.miimon)) {
753                 printk(KERN_ERR DRV_NAME
754                        ": %s: Unable to set down delay as MII monitoring is disabled\n",
755                        bond->dev->name);
756                 ret = -EPERM;
757                 goto out;
758         }
759
760         if (sscanf(buf, "%d", &new_value) != 1) {
761                 printk(KERN_ERR DRV_NAME
762                        ": %s: no down delay value specified.\n",
763                        bond->dev->name);
764                 ret = -EINVAL;
765                 goto out;
766         }
767         if (new_value < 0) {
768                 printk(KERN_ERR DRV_NAME
769                        ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n",
770                        bond->dev->name, new_value, 1, INT_MAX);
771                 ret = -EINVAL;
772                 goto out;
773         } else {
774                 if ((new_value % bond->params.miimon) != 0) {
775                         printk(KERN_WARNING DRV_NAME
776                                ": %s: Warning: down delay (%d) is not a multiple "
777                                "of miimon (%d), delay rounded to %d ms\n",
778                                bond->dev->name, new_value, bond->params.miimon,
779                                (new_value / bond->params.miimon) *
780                                bond->params.miimon);
781                 }
782                 bond->params.downdelay = new_value / bond->params.miimon;
783                 printk(KERN_INFO DRV_NAME ": %s: Setting down delay to %d.\n",
784                        bond->dev->name, bond->params.downdelay * bond->params.miimon);
785
786         }
787
788 out:
789         return ret;
790 }
791 static CLASS_DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR , bonding_show_downdelay, bonding_store_downdelay);
792
793 static ssize_t bonding_show_updelay(struct class_device *cd, char *buf)
794 {
795         struct bonding *bond = to_bond(cd);
796
797         return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon) + 1;
798
799 }
800
801 static ssize_t bonding_store_updelay(struct class_device *cd, const char *buf, size_t count)
802 {
803         int new_value, ret = count;
804         struct bonding *bond = to_bond(cd);
805
806         if (!(bond->params.miimon)) {
807                 printk(KERN_ERR DRV_NAME
808                        ": %s: Unable to set up delay as MII monitoring is disabled\n",
809                        bond->dev->name);
810                 ret = -EPERM;
811                 goto out;
812         }
813
814         if (sscanf(buf, "%d", &new_value) != 1) {
815                 printk(KERN_ERR DRV_NAME
816                        ": %s: no up delay value specified.\n",
817                        bond->dev->name);
818                 ret = -EINVAL;
819                 goto out;
820         }
821         if (new_value < 0) {
822                 printk(KERN_ERR DRV_NAME
823                        ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n",
824                        bond->dev->name, new_value, 1, INT_MAX);
825                 ret = -EINVAL;
826                 goto out;
827         } else {
828                 if ((new_value % bond->params.miimon) != 0) {
829                         printk(KERN_WARNING DRV_NAME
830                                ": %s: Warning: up delay (%d) is not a multiple "
831                                "of miimon (%d), updelay rounded to %d ms\n",
832                                bond->dev->name, new_value, bond->params.miimon,
833                                (new_value / bond->params.miimon) *
834                                bond->params.miimon);
835                 }
836                 bond->params.updelay = new_value / bond->params.miimon;
837                 printk(KERN_INFO DRV_NAME ": %s: Setting up delay to %d.\n",
838                        bond->dev->name, bond->params.updelay * bond->params.miimon);
839
840         }
841
842 out:
843         return ret;
844 }
845 static CLASS_DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR , bonding_show_updelay, bonding_store_updelay);
846
847 /*
848  * Show and set the LACP interval.  Interface must be down, and the mode
849  * must be set to 802.3ad mode.
850  */
851 static ssize_t bonding_show_lacp(struct class_device *cd, char *buf)
852 {
853         struct bonding *bond = to_bond(cd);
854
855         return sprintf(buf, "%s %d\n",
856                 bond_lacp_tbl[bond->params.lacp_fast].modename,
857                 bond->params.lacp_fast) + 1;
858 }
859
860 static ssize_t bonding_store_lacp(struct class_device *cd, const char *buf, size_t count)
861 {
862         int new_value, ret = count;
863         struct bonding *bond = to_bond(cd);
864
865         if (bond->dev->flags & IFF_UP) {
866                 printk(KERN_ERR DRV_NAME
867                        ": %s: Unable to update LACP rate because interface is up.\n",
868                        bond->dev->name);
869                 ret = -EPERM;
870                 goto out;
871         }
872
873         if (bond->params.mode != BOND_MODE_8023AD) {
874                 printk(KERN_ERR DRV_NAME
875                        ": %s: Unable to update LACP rate because bond is not in 802.3ad mode.\n",
876                        bond->dev->name);
877                 ret = -EPERM;
878                 goto out;
879         }
880
881         new_value = bond_parse_parm((char *)buf, bond_lacp_tbl);
882
883         if ((new_value == 1) || (new_value == 0)) {
884                 bond->params.lacp_fast = new_value;
885                 printk(KERN_INFO DRV_NAME
886                        ": %s: Setting LACP rate to %s (%d).\n",
887                        bond->dev->name, bond_lacp_tbl[new_value].modename, new_value);
888         } else {
889                 printk(KERN_ERR DRV_NAME
890                        ": %s: Ignoring invalid LACP rate value %.*s.\n",
891                         bond->dev->name, (int)strlen(buf) - 1, buf);
892                 ret = -EINVAL;
893         }
894 out:
895         return ret;
896 }
897 static CLASS_DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bonding_store_lacp);
898
899 /*
900  * Show and set the MII monitor interval.  There are two tricky bits
901  * here.  First, if MII monitoring is activated, then we must disable
902  * ARP monitoring.  Second, if the timer isn't running, we must
903  * start it.
904  */
905 static ssize_t bonding_show_miimon(struct class_device *cd, char *buf)
906 {
907         struct bonding *bond = to_bond(cd);
908
909         return sprintf(buf, "%d\n", bond->params.miimon) + 1;
910 }
911
912 static ssize_t bonding_store_miimon(struct class_device *cd, const char *buf, size_t count)
913 {
914         int new_value, ret = count;
915         struct bonding *bond = to_bond(cd);
916
917         if (sscanf(buf, "%d", &new_value) != 1) {
918                 printk(KERN_ERR DRV_NAME
919                        ": %s: no miimon value specified.\n",
920                        bond->dev->name);
921                 ret = -EINVAL;
922                 goto out;
923         }
924         if (new_value < 0) {
925                 printk(KERN_ERR DRV_NAME
926                        ": %s: Invalid miimon value %d not in range %d-%d; rejected.\n",
927                        bond->dev->name, new_value, 1, INT_MAX);
928                 ret = -EINVAL;
929                 goto out;
930         } else {
931                 printk(KERN_INFO DRV_NAME
932                        ": %s: Setting MII monitoring interval to %d.\n",
933                        bond->dev->name, new_value);
934                 bond->params.miimon = new_value;
935                 if(bond->params.updelay)
936                         printk(KERN_INFO DRV_NAME
937                               ": %s: Note: Updating updelay (to %d) "
938                               "since it is a multiple of the miimon value.\n",
939                               bond->dev->name,
940                               bond->params.updelay * bond->params.miimon);
941                 if(bond->params.downdelay)
942                         printk(KERN_INFO DRV_NAME
943                               ": %s: Note: Updating downdelay (to %d) "
944                               "since it is a multiple of the miimon value.\n",
945                               bond->dev->name,
946                               bond->params.downdelay * bond->params.miimon);
947                 if (bond->params.arp_interval) {
948                         printk(KERN_INFO DRV_NAME
949                                ": %s: MII monitoring cannot be used with "
950                                "ARP monitoring. Disabling ARP monitoring...\n",
951                                bond->dev->name);
952                         bond->params.arp_interval = 0;
953                         /* Kill ARP timer, else it brings bond's link down */
954                         if (bond->mii_timer.function) {
955                                 printk(KERN_INFO DRV_NAME
956                                 ": %s: Kill ARP timer, else it brings bond's link down...\n",
957                                bond->dev->name);
958                                 del_timer_sync(&bond->arp_timer);
959                         }
960                 }
961
962                 if (bond->dev->flags & IFF_UP) {
963                         /* If the interface is up, we may need to fire off
964                          * the MII timer. If the interface is down, the
965                          * timer will get fired off when the open function
966                          * is called.
967                          */
968                         if (bond->mii_timer.function) {
969                                 /* The timer's already set up, so fire it off */
970                                 mod_timer(&bond->mii_timer, jiffies + 1);
971                         } else {
972                                 /* Set up the timer. */
973                                 init_timer(&bond->mii_timer);
974                                 bond->mii_timer.expires = jiffies + 1;
975                                 bond->mii_timer.data =
976                                         (unsigned long) bond->dev;
977                                 bond->mii_timer.function =
978                                         (void *) &bond_mii_monitor;
979                                 add_timer(&bond->mii_timer);
980                         }
981                 }
982         }
983 out:
984         return ret;
985 }
986 static CLASS_DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding_store_miimon);
987
988 /*
989  * Show and set the primary slave.  The store function is much
990  * simpler than bonding_store_slaves function because it only needs to
991  * handle one interface name.
992  * The bond must be a mode that supports a primary for this be
993  * set.
994  */
995 static ssize_t bonding_show_primary(struct class_device *cd, char *buf)
996 {
997         int count = 0;
998         struct bonding *bond = to_bond(cd);
999
1000         if (bond->primary_slave)
1001                 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name) + 1;
1002         else
1003                 count = sprintf(buf, "\n") + 1;
1004
1005         return count;
1006 }
1007
1008 static ssize_t bonding_store_primary(struct class_device *cd, const char *buf, size_t count)
1009 {
1010         int i;
1011         struct slave *slave;
1012         struct bonding *bond = to_bond(cd);
1013
1014         write_lock_bh(&bond->lock);
1015         if (!USES_PRIMARY(bond->params.mode)) {
1016                 printk(KERN_INFO DRV_NAME
1017                        ": %s: Unable to set primary slave; %s is in mode %d\n",
1018                        bond->dev->name, bond->dev->name, bond->params.mode);
1019         } else {
1020                 bond_for_each_slave(bond, slave, i) {
1021                         if (strnicmp
1022                             (slave->dev->name, buf,
1023                              strlen(slave->dev->name)) == 0) {
1024                                 printk(KERN_INFO DRV_NAME
1025                                        ": %s: Setting %s as primary slave.\n",
1026                                        bond->dev->name, slave->dev->name);
1027                                 bond->primary_slave = slave;
1028                                 bond_select_active_slave(bond);
1029                                 goto out;
1030                         }
1031                 }
1032
1033                 /* if we got here, then we didn't match the name of any slave */
1034
1035                 if (strlen(buf) == 0 || buf[0] == '\n') {
1036                         printk(KERN_INFO DRV_NAME
1037                                ": %s: Setting primary slave to None.\n",
1038                                bond->dev->name);
1039                         bond->primary_slave = 0;
1040                                 bond_select_active_slave(bond);
1041                 } else {
1042                         printk(KERN_INFO DRV_NAME
1043                                ": %s: Unable to set %.*s as primary slave as it is not a slave.\n",
1044                                bond->dev->name, (int)strlen(buf) - 1, buf);
1045                 }
1046         }
1047 out:
1048         write_unlock_bh(&bond->lock);
1049         return count;
1050 }
1051 static CLASS_DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, bonding_show_primary, bonding_store_primary);
1052
1053 /*
1054  * Show and set the use_carrier flag.
1055  */
1056 static ssize_t bonding_show_carrier(struct class_device *cd, char *buf)
1057 {
1058         struct bonding *bond = to_bond(cd);
1059
1060         return sprintf(buf, "%d\n", bond->params.use_carrier) + 1;
1061 }
1062
1063 static ssize_t bonding_store_carrier(struct class_device *cd, const char *buf, size_t count)
1064 {
1065         int new_value, ret = count;
1066         struct bonding *bond = to_bond(cd);
1067
1068
1069         if (sscanf(buf, "%d", &new_value) != 1) {
1070                 printk(KERN_ERR DRV_NAME
1071                        ": %s: no use_carrier value specified.\n",
1072                        bond->dev->name);
1073                 ret = -EINVAL;
1074                 goto out;
1075         }
1076         if ((new_value == 0) || (new_value == 1)) {
1077                 bond->params.use_carrier = new_value;
1078                 printk(KERN_INFO DRV_NAME ": %s: Setting use_carrier to %d.\n",
1079                        bond->dev->name, new_value);
1080         } else {
1081                 printk(KERN_INFO DRV_NAME
1082                        ": %s: Ignoring invalid use_carrier value %d.\n",
1083                        bond->dev->name, new_value);
1084         }
1085 out:
1086         return count;
1087 }
1088 static CLASS_DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, bonding_show_carrier, bonding_store_carrier);
1089
1090
1091 /*
1092  * Show and set currently active_slave.
1093  */
1094 static ssize_t bonding_show_active_slave(struct class_device *cd, char *buf)
1095 {
1096         struct slave *curr;
1097         struct bonding *bond = to_bond(cd);
1098         int count;
1099
1100
1101         read_lock(&bond->curr_slave_lock);
1102         curr = bond->curr_active_slave;
1103         read_unlock(&bond->curr_slave_lock);
1104
1105         if (USES_PRIMARY(bond->params.mode) && curr)
1106                 count = sprintf(buf, "%s\n", curr->dev->name) + 1;
1107         else
1108                 count = sprintf(buf, "\n") + 1;
1109         return count;
1110 }
1111
1112 static ssize_t bonding_store_active_slave(struct class_device *cd, const char *buf, size_t count)
1113 {
1114         int i;
1115         struct slave *slave;
1116         struct slave *old_active = NULL;
1117         struct slave *new_active = NULL;
1118         struct bonding *bond = to_bond(cd);
1119
1120         write_lock_bh(&bond->lock);
1121         if (!USES_PRIMARY(bond->params.mode)) {
1122                 printk(KERN_INFO DRV_NAME
1123                        ": %s: Unable to change active slave; %s is in mode %d\n",
1124                        bond->dev->name, bond->dev->name, bond->params.mode);
1125         } else {
1126                 bond_for_each_slave(bond, slave, i) {
1127                         if (strnicmp
1128                             (slave->dev->name, buf,
1129                              strlen(slave->dev->name)) == 0) {
1130                                 old_active = bond->curr_active_slave;
1131                                 new_active = slave;
1132                                 if (new_active && (new_active == old_active)) {
1133                                         /* do nothing */
1134                                         printk(KERN_INFO DRV_NAME
1135                                                ": %s: %s is already the current active slave.\n",
1136                                                bond->dev->name, slave->dev->name);
1137                                         goto out;
1138                                 }
1139                                 else {
1140                                         if ((new_active) &&
1141                                             (old_active) &&
1142                                             (new_active->link == BOND_LINK_UP) &&
1143                                             IS_UP(new_active->dev)) {
1144                                                 printk(KERN_INFO DRV_NAME
1145                                                       ": %s: Setting %s as active slave.\n",
1146                                                       bond->dev->name, slave->dev->name);
1147                                                 bond_change_active_slave(bond, new_active);
1148                                         }
1149                                         else {
1150                                                 printk(KERN_INFO DRV_NAME
1151                                                       ": %s: Could not set %s as active slave; "
1152                                                       "either %s is down or the link is down.\n",
1153                                                       bond->dev->name, slave->dev->name,
1154                                                       slave->dev->name);
1155                                         }
1156                                         goto out;
1157                                 }
1158                         }
1159                 }
1160
1161                 /* if we got here, then we didn't match the name of any slave */
1162
1163                 if (strlen(buf) == 0 || buf[0] == '\n') {
1164                         printk(KERN_INFO DRV_NAME
1165                                ": %s: Setting active slave to None.\n",
1166                                bond->dev->name);
1167                         bond->primary_slave = 0;
1168                                 bond_select_active_slave(bond);
1169                 } else {
1170                         printk(KERN_INFO DRV_NAME
1171                                ": %s: Unable to set %.*s as active slave as it is not a slave.\n",
1172                                bond->dev->name, (int)strlen(buf) - 1, buf);
1173                 }
1174         }
1175 out:
1176         write_unlock_bh(&bond->lock);
1177         return count;
1178
1179 }
1180 static CLASS_DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, bonding_show_active_slave, bonding_store_active_slave);
1181
1182
1183 /*
1184  * Show link status of the bond interface.
1185  */
1186 static ssize_t bonding_show_mii_status(struct class_device *cd, char *buf)
1187 {
1188         struct slave *curr;
1189         struct bonding *bond = to_bond(cd);
1190
1191         read_lock(&bond->curr_slave_lock);
1192         curr = bond->curr_active_slave;
1193         read_unlock(&bond->curr_slave_lock);
1194
1195         return sprintf(buf, "%s\n", (curr) ? "up" : "down") + 1;
1196 }
1197 static CLASS_DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
1198
1199
1200 /*
1201  * Show current 802.3ad aggregator ID.
1202  */
1203 static ssize_t bonding_show_ad_aggregator(struct class_device *cd, char *buf)
1204 {
1205         int count = 0;
1206         struct bonding *bond = to_bond(cd);
1207
1208         if (bond->params.mode == BOND_MODE_8023AD) {
1209                 struct ad_info ad_info;
1210                 count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.aggregator_id) + 1;
1211         }
1212         else
1213                 count = sprintf(buf, "\n") + 1;
1214
1215         return count;
1216 }
1217 static CLASS_DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
1218
1219
1220 /*
1221  * Show number of active 802.3ad ports.
1222  */
1223 static ssize_t bonding_show_ad_num_ports(struct class_device *cd, char *buf)
1224 {
1225         int count = 0;
1226         struct bonding *bond = to_bond(cd);
1227
1228         if (bond->params.mode == BOND_MODE_8023AD) {
1229                 struct ad_info ad_info;
1230                 count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0: ad_info.ports) + 1;
1231         }
1232         else
1233                 count = sprintf(buf, "\n") + 1;
1234
1235         return count;
1236 }
1237 static CLASS_DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
1238
1239
1240 /*
1241  * Show current 802.3ad actor key.
1242  */
1243 static ssize_t bonding_show_ad_actor_key(struct class_device *cd, char *buf)
1244 {
1245         int count = 0;
1246         struct bonding *bond = to_bond(cd);
1247
1248         if (bond->params.mode == BOND_MODE_8023AD) {
1249                 struct ad_info ad_info;
1250                 count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.actor_key) + 1;
1251         }
1252         else
1253                 count = sprintf(buf, "\n") + 1;
1254
1255         return count;
1256 }
1257 static CLASS_DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
1258
1259
1260 /*
1261  * Show current 802.3ad partner key.
1262  */
1263 static ssize_t bonding_show_ad_partner_key(struct class_device *cd, char *buf)
1264 {
1265         int count = 0;
1266         struct bonding *bond = to_bond(cd);
1267
1268         if (bond->params.mode == BOND_MODE_8023AD) {
1269                 struct ad_info ad_info;
1270                 count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.partner_key) + 1;
1271         }
1272         else
1273                 count = sprintf(buf, "\n") + 1;
1274
1275         return count;
1276 }
1277 static CLASS_DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1278
1279
1280 /*
1281  * Show current 802.3ad partner mac.
1282  */
1283 static ssize_t bonding_show_ad_partner_mac(struct class_device *cd, char *buf)
1284 {
1285         int count = 0;
1286         struct bonding *bond = to_bond(cd);
1287
1288         if (bond->params.mode == BOND_MODE_8023AD) {
1289                 struct ad_info ad_info;
1290                 if (!bond_3ad_get_active_agg_info(bond, &ad_info)) {
1291                         count = sprintf(buf,"%02x:%02x:%02x:%02x:%02x:%02x\n",
1292                                        ad_info.partner_system[0],
1293                                        ad_info.partner_system[1],
1294                                        ad_info.partner_system[2],
1295                                        ad_info.partner_system[3],
1296                                        ad_info.partner_system[4],
1297                                        ad_info.partner_system[5]) + 1;
1298                 }
1299         }
1300         else
1301                 count = sprintf(buf, "\n") + 1;
1302
1303         return count;
1304 }
1305 static CLASS_DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1306
1307
1308
1309 static struct attribute *per_bond_attrs[] = {
1310         &class_device_attr_slaves.attr,
1311         &class_device_attr_mode.attr,
1312         &class_device_attr_arp_interval.attr,
1313         &class_device_attr_arp_ip_target.attr,
1314         &class_device_attr_downdelay.attr,
1315         &class_device_attr_updelay.attr,
1316         &class_device_attr_lacp_rate.attr,
1317         &class_device_attr_xmit_hash_policy.attr,
1318         &class_device_attr_miimon.attr,
1319         &class_device_attr_primary.attr,
1320         &class_device_attr_use_carrier.attr,
1321         &class_device_attr_active_slave.attr,
1322         &class_device_attr_mii_status.attr,
1323         &class_device_attr_ad_aggregator.attr,
1324         &class_device_attr_ad_num_ports.attr,
1325         &class_device_attr_ad_actor_key.attr,
1326         &class_device_attr_ad_partner_key.attr,
1327         &class_device_attr_ad_partner_mac.attr,
1328         NULL,
1329 };
1330
1331 static struct attribute_group bonding_group = {
1332         .name = "bonding",
1333         .attrs = per_bond_attrs,
1334 };
1335
1336 /*
1337  * Initialize sysfs.  This sets up the bonding_masters file in
1338  * /sys/class/net.
1339  */
1340 int bond_create_sysfs(void)
1341 {
1342         int ret = 0;
1343         struct bonding *firstbond;
1344
1345         init_rwsem(&bonding_rwsem);
1346
1347         /* get the netdev class pointer */
1348         firstbond = container_of(bond_dev_list.next, struct bonding, bond_list);
1349         if (!firstbond)
1350                 return -ENODEV;
1351
1352         netdev_class = firstbond->dev->class_dev.class;
1353         if (!netdev_class)
1354                 return -ENODEV;
1355
1356         ret = class_create_file(netdev_class, &class_attr_bonding_masters);
1357
1358         return ret;
1359
1360 }
1361
1362 /*
1363  * Remove /sys/class/net/bonding_masters.
1364  */
1365 void bond_destroy_sysfs(void)
1366 {
1367         if (netdev_class)
1368                 class_remove_file(netdev_class, &class_attr_bonding_masters);
1369 }
1370
1371 /*
1372  * Initialize sysfs for each bond.  This sets up and registers
1373  * the 'bondctl' directory for each individual bond under /sys/class/net.
1374  */
1375 int bond_create_sysfs_entry(struct bonding *bond)
1376 {
1377         struct net_device *dev = bond->dev;
1378         int err;
1379
1380         err = sysfs_create_group(&(dev->class_dev.kobj), &bonding_group);
1381         if (err) {
1382                 printk(KERN_EMERG "eek! didn't create group!\n");
1383         }
1384
1385         if (expected_refcount < 1)
1386                 expected_refcount = atomic_read(&bond->dev->class_dev.kobj.kref.refcount);
1387
1388         return err;
1389 }
1390 /*
1391  * Remove sysfs entries for each bond.
1392  */
1393 void bond_destroy_sysfs_entry(struct bonding *bond)
1394 {
1395         struct net_device *dev = bond->dev;
1396
1397         sysfs_remove_group(&(dev->class_dev.kobj), &bonding_group);
1398 }
1399