3 * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
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.
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
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.
19 * The full GNU General Public License is included in this distribution in the
20 * file called LICENSE.
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/device.h>
26 #include <linux/sysdev.h>
28 #include <linux/types.h>
29 #include <linux/string.h>
30 #include <linux/netdevice.h>
31 #include <linux/inetdevice.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>
41 #define to_dev(obj) container_of(obj,struct device,kobj)
42 #define to_bond(cd) ((struct bonding *)(netdev_priv(to_net_dev(cd))))
44 /*---------------------------- Declarations -------------------------------*/
46 static int expected_refcount
= -1;
47 /*--------------------------- Data Structures -----------------------------*/
49 /* Bonding sysfs lock. Why can't we just use the subsystem lock?
50 * Because kobject_register tries to acquire the subsystem lock. If
51 * we already hold the lock (which we would if the user was creating
52 * a new bond through the sysfs interface), we deadlock.
53 * This lock is only needed when deleting a bond - we need to make sure
54 * that we don't collide with an ongoing ioctl.
57 struct rw_semaphore bonding_rwsem
;
62 /*------------------------------ Functions --------------------------------*/
65 * "show" function for the bond_masters attribute.
66 * The class parameter is ignored.
68 static ssize_t
bonding_show_bonds(struct class *cls
, char *buf
)
73 down_read(&(bonding_rwsem
));
75 list_for_each_entry(bond
, &bond_dev_list
, bond_list
) {
76 if (res
> (PAGE_SIZE
- IFNAMSIZ
)) {
77 /* not enough space for another interface name */
78 if ((PAGE_SIZE
- res
) > 10)
80 res
+= sprintf(buf
+ res
, "++more++ ");
83 res
+= sprintf(buf
+ res
, "%s ", bond
->dev
->name
);
86 buf
[res
-1] = '\n'; /* eat the leftover space */
87 up_read(&(bonding_rwsem
));
92 * "store" function for the bond_masters attribute. This is what
93 * creates and deletes entire bonds.
95 * The class parameter is ignored.
99 static ssize_t
bonding_store_bonds(struct class *cls
, const char *buffer
, size_t count
)
101 char command
[IFNAMSIZ
+ 1] = {0, };
104 struct bonding
*bond
;
106 sscanf(buffer
, "%16s", command
); /* IFNAMSIZ*/
107 ifname
= command
+ 1;
108 if ((strlen(command
) <= 1) ||
109 !dev_valid_name(ifname
))
112 if (command
[0] == '+') {
113 printk(KERN_INFO DRV_NAME
114 ": %s is being created...\n", ifname
);
115 rv
= bond_create(ifname
, &bonding_defaults
);
117 printk(KERN_INFO DRV_NAME
": Bond creation failed.\n");
123 if (command
[0] == '-') {
125 down_write(&bonding_rwsem
);
127 list_for_each_entry(bond
, &bond_dev_list
, bond_list
)
128 if (strnicmp(bond
->dev
->name
, ifname
, IFNAMSIZ
) == 0) {
129 /* check the ref count on the bond's kobject.
130 * If it's > expected, then there's a file open,
131 * and we have to fail.
133 if (atomic_read(&bond
->dev
->dev
.kobj
.kref
.refcount
)
134 > expected_refcount
){
135 printk(KERN_INFO DRV_NAME
136 ": Unable remove bond %s due to open references.\n",
141 printk(KERN_INFO DRV_NAME
142 ": %s is being deleted...\n",
148 printk(KERN_ERR DRV_NAME
149 ": unable to delete non-existent bond %s\n", ifname
);
155 printk(KERN_ERR DRV_NAME
156 ": no command found in bonding_masters. Use +ifname or -ifname.\n");
160 up_write(&bonding_rwsem
);
163 /* Always return either count or an error. If you return 0, you'll
164 * get called forever, which is bad.
169 /* class attribute for bond_masters file. This ends up in /sys/class/net */
170 static CLASS_ATTR(bonding_masters
, S_IWUSR
| S_IRUGO
,
171 bonding_show_bonds
, bonding_store_bonds
);
173 int bond_create_slave_symlinks(struct net_device
*master
, struct net_device
*slave
)
175 char linkname
[IFNAMSIZ
+7];
178 /* first, create a link from the slave back to the master */
179 ret
= sysfs_create_link(&(slave
->dev
.kobj
), &(master
->dev
.kobj
),
183 /* next, create a link from the master to the slave */
184 sprintf(linkname
,"slave_%s",slave
->name
);
185 ret
= sysfs_create_link(&(master
->dev
.kobj
), &(slave
->dev
.kobj
),
191 void bond_destroy_slave_symlinks(struct net_device
*master
, struct net_device
*slave
)
193 char linkname
[IFNAMSIZ
+7];
195 sysfs_remove_link(&(slave
->dev
.kobj
), "master");
196 sprintf(linkname
,"slave_%s",slave
->name
);
197 sysfs_remove_link(&(master
->dev
.kobj
), linkname
);
202 * Show the slaves in the current bond.
204 static ssize_t
bonding_show_slaves(struct device
*d
,
205 struct device_attribute
*attr
, char *buf
)
209 struct bonding
*bond
= to_bond(d
);
211 read_lock(&bond
->lock
);
212 bond_for_each_slave(bond
, slave
, i
) {
213 if (res
> (PAGE_SIZE
- IFNAMSIZ
)) {
214 /* not enough space for another interface name */
215 if ((PAGE_SIZE
- res
) > 10)
216 res
= PAGE_SIZE
- 10;
217 res
+= sprintf(buf
+ res
, "++more++ ");
220 res
+= sprintf(buf
+ res
, "%s ", slave
->dev
->name
);
222 read_unlock(&bond
->lock
);
224 buf
[res
-1] = '\n'; /* eat the leftover space */
229 * Set the slaves in the current bond. The bond interface must be
230 * up for this to succeed.
231 * This function is largely the same flow as bonding_update_bonds().
233 static ssize_t
bonding_store_slaves(struct device
*d
,
234 struct device_attribute
*attr
,
235 const char *buffer
, size_t count
)
237 char command
[IFNAMSIZ
+ 1] = { 0, };
239 int i
, res
, found
, ret
= count
;
242 struct net_device
*dev
= NULL
;
243 struct bonding
*bond
= to_bond(d
);
245 /* Quick sanity check -- is the bond interface up? */
246 if (!(bond
->dev
->flags
& IFF_UP
)) {
247 printk(KERN_WARNING DRV_NAME
248 ": %s: doing slave updates when interface is down.\n",
252 /* Note: We can't hold bond->lock here, as bond_create grabs it. */
255 return restart_syscall();
256 down_write(&(bonding_rwsem
));
258 sscanf(buffer
, "%16s", command
); /* IFNAMSIZ*/
259 ifname
= command
+ 1;
260 if ((strlen(command
) <= 1) ||
261 !dev_valid_name(ifname
))
264 if (command
[0] == '+') {
266 /* Got a slave name in ifname. Is it already in the list? */
268 read_lock(&bond
->lock
);
269 bond_for_each_slave(bond
, slave
, i
)
270 if (strnicmp(slave
->dev
->name
, ifname
, IFNAMSIZ
) == 0) {
271 printk(KERN_ERR DRV_NAME
272 ": %s: Interface %s is already enslaved!\n",
273 bond
->dev
->name
, ifname
);
275 read_unlock(&bond
->lock
);
279 read_unlock(&bond
->lock
);
280 printk(KERN_INFO DRV_NAME
": %s: Adding slave %s.\n",
281 bond
->dev
->name
, ifname
);
282 dev
= dev_get_by_name(&init_net
, ifname
);
284 printk(KERN_INFO DRV_NAME
285 ": %s: Interface %s does not exist!\n",
286 bond
->dev
->name
, ifname
);
293 if (dev
->flags
& IFF_UP
) {
294 printk(KERN_ERR DRV_NAME
295 ": %s: Error: Unable to enslave %s "
296 "because it is already up.\n",
297 bond
->dev
->name
, dev
->name
);
301 /* If this is the first slave, then we need to set
302 the master's hardware address to be the same as the
304 if (!(*((u32
*) & (bond
->dev
->dev_addr
[0])))) {
305 memcpy(bond
->dev
->dev_addr
, dev
->dev_addr
,
309 /* Set the slave's MTU to match the bond */
310 original_mtu
= dev
->mtu
;
311 res
= dev_set_mtu(dev
, bond
->dev
->mtu
);
317 res
= bond_enslave(bond
->dev
, dev
);
318 bond_for_each_slave(bond
, slave
, i
)
319 if (strnicmp(slave
->dev
->name
, ifname
, IFNAMSIZ
) == 0)
320 slave
->original_mtu
= original_mtu
;
327 if (command
[0] == '-') {
330 bond_for_each_slave(bond
, slave
, i
)
331 if (strnicmp(slave
->dev
->name
, ifname
, IFNAMSIZ
) == 0) {
333 original_mtu
= slave
->original_mtu
;
337 printk(KERN_INFO DRV_NAME
": %s: Removing slave %s\n",
338 bond
->dev
->name
, dev
->name
);
339 res
= bond_release(bond
->dev
, dev
);
344 /* set the slave MTU to the default */
345 dev_set_mtu(dev
, original_mtu
);
348 printk(KERN_ERR DRV_NAME
": unable to remove non-existent slave %s for bond %s.\n",
349 ifname
, bond
->dev
->name
);
356 printk(KERN_ERR DRV_NAME
": no command found in slaves file for bond %s. Use +ifname or -ifname.\n", bond
->dev
->name
);
360 up_write(&(bonding_rwsem
));
365 static DEVICE_ATTR(slaves
, S_IRUGO
| S_IWUSR
, bonding_show_slaves
, bonding_store_slaves
);
368 * Show and set the bonding mode. The bond interface must be down to
371 static ssize_t
bonding_show_mode(struct device
*d
,
372 struct device_attribute
*attr
, char *buf
)
374 struct bonding
*bond
= to_bond(d
);
376 return sprintf(buf
, "%s %d\n",
377 bond_mode_tbl
[bond
->params
.mode
].modename
,
381 static ssize_t
bonding_store_mode(struct device
*d
,
382 struct device_attribute
*attr
,
383 const char *buf
, size_t count
)
385 int new_value
, ret
= count
;
386 struct bonding
*bond
= to_bond(d
);
388 if (bond
->dev
->flags
& IFF_UP
) {
389 printk(KERN_ERR DRV_NAME
390 ": unable to update mode of %s because interface is up.\n",
396 new_value
= bond_parse_parm(buf
, bond_mode_tbl
);
398 printk(KERN_ERR DRV_NAME
399 ": %s: Ignoring invalid mode value %.*s.\n",
401 (int)strlen(buf
) - 1, buf
);
405 if (bond
->params
.mode
== BOND_MODE_8023AD
)
406 bond_unset_master_3ad_flags(bond
);
408 if (bond
->params
.mode
== BOND_MODE_ALB
)
409 bond_unset_master_alb_flags(bond
);
411 bond
->params
.mode
= new_value
;
412 bond_set_mode_ops(bond
, bond
->params
.mode
);
413 printk(KERN_INFO DRV_NAME
": %s: setting mode to %s (%d).\n",
414 bond
->dev
->name
, bond_mode_tbl
[new_value
].modename
, new_value
);
419 static DEVICE_ATTR(mode
, S_IRUGO
| S_IWUSR
, bonding_show_mode
, bonding_store_mode
);
422 * Show and set the bonding transmit hash method. The bond interface must be down to
423 * change the xmit hash policy.
425 static ssize_t
bonding_show_xmit_hash(struct device
*d
,
426 struct device_attribute
*attr
,
429 struct bonding
*bond
= to_bond(d
);
431 return sprintf(buf
, "%s %d\n",
432 xmit_hashtype_tbl
[bond
->params
.xmit_policy
].modename
,
433 bond
->params
.xmit_policy
);
436 static ssize_t
bonding_store_xmit_hash(struct device
*d
,
437 struct device_attribute
*attr
,
438 const char *buf
, size_t count
)
440 int new_value
, ret
= count
;
441 struct bonding
*bond
= to_bond(d
);
443 if (bond
->dev
->flags
& IFF_UP
) {
444 printk(KERN_ERR DRV_NAME
445 "%s: Interface is up. Unable to update xmit policy.\n",
451 new_value
= bond_parse_parm(buf
, xmit_hashtype_tbl
);
453 printk(KERN_ERR DRV_NAME
454 ": %s: Ignoring invalid xmit hash policy value %.*s.\n",
456 (int)strlen(buf
) - 1, buf
);
460 bond
->params
.xmit_policy
= new_value
;
461 bond_set_mode_ops(bond
, bond
->params
.mode
);
462 printk(KERN_INFO DRV_NAME
": %s: setting xmit hash policy to %s (%d).\n",
463 bond
->dev
->name
, xmit_hashtype_tbl
[new_value
].modename
, new_value
);
468 static DEVICE_ATTR(xmit_hash_policy
, S_IRUGO
| S_IWUSR
, bonding_show_xmit_hash
, bonding_store_xmit_hash
);
471 * Show and set arp_validate.
473 static ssize_t
bonding_show_arp_validate(struct device
*d
,
474 struct device_attribute
*attr
,
477 struct bonding
*bond
= to_bond(d
);
479 return sprintf(buf
, "%s %d\n",
480 arp_validate_tbl
[bond
->params
.arp_validate
].modename
,
481 bond
->params
.arp_validate
);
484 static ssize_t
bonding_store_arp_validate(struct device
*d
,
485 struct device_attribute
*attr
,
486 const char *buf
, size_t count
)
489 struct bonding
*bond
= to_bond(d
);
491 new_value
= bond_parse_parm(buf
, arp_validate_tbl
);
493 printk(KERN_ERR DRV_NAME
494 ": %s: Ignoring invalid arp_validate value %s\n",
495 bond
->dev
->name
, buf
);
498 if (new_value
&& (bond
->params
.mode
!= BOND_MODE_ACTIVEBACKUP
)) {
499 printk(KERN_ERR DRV_NAME
500 ": %s: arp_validate only supported in active-backup mode.\n",
504 printk(KERN_INFO DRV_NAME
": %s: setting arp_validate to %s (%d).\n",
505 bond
->dev
->name
, arp_validate_tbl
[new_value
].modename
,
508 if (!bond
->params
.arp_validate
&& new_value
) {
509 bond_register_arp(bond
);
510 } else if (bond
->params
.arp_validate
&& !new_value
) {
511 bond_unregister_arp(bond
);
514 bond
->params
.arp_validate
= new_value
;
519 static DEVICE_ATTR(arp_validate
, S_IRUGO
| S_IWUSR
, bonding_show_arp_validate
, bonding_store_arp_validate
);
522 * Show and store fail_over_mac. User only allowed to change the
523 * value when there are no slaves.
525 static ssize_t
bonding_show_fail_over_mac(struct device
*d
, struct device_attribute
*attr
, char *buf
)
527 struct bonding
*bond
= to_bond(d
);
529 return sprintf(buf
, "%s %d\n",
530 fail_over_mac_tbl
[bond
->params
.fail_over_mac
].modename
,
531 bond
->params
.fail_over_mac
);
534 static ssize_t
bonding_store_fail_over_mac(struct device
*d
, struct device_attribute
*attr
, const char *buf
, size_t count
)
537 struct bonding
*bond
= to_bond(d
);
539 if (bond
->slave_cnt
!= 0) {
540 printk(KERN_ERR DRV_NAME
541 ": %s: Can't alter fail_over_mac with slaves in bond.\n",
546 new_value
= bond_parse_parm(buf
, fail_over_mac_tbl
);
548 printk(KERN_ERR DRV_NAME
549 ": %s: Ignoring invalid fail_over_mac value %s.\n",
550 bond
->dev
->name
, buf
);
554 bond
->params
.fail_over_mac
= new_value
;
555 printk(KERN_INFO DRV_NAME
": %s: Setting fail_over_mac to %s (%d).\n",
556 bond
->dev
->name
, fail_over_mac_tbl
[new_value
].modename
,
562 static DEVICE_ATTR(fail_over_mac
, S_IRUGO
| S_IWUSR
, bonding_show_fail_over_mac
, bonding_store_fail_over_mac
);
565 * Show and set the arp timer interval. There are two tricky bits
566 * here. First, if ARP monitoring is activated, then we must disable
567 * MII monitoring. Second, if the ARP timer isn't running, we must
570 static ssize_t
bonding_show_arp_interval(struct device
*d
,
571 struct device_attribute
*attr
,
574 struct bonding
*bond
= to_bond(d
);
576 return sprintf(buf
, "%d\n", bond
->params
.arp_interval
);
579 static ssize_t
bonding_store_arp_interval(struct device
*d
,
580 struct device_attribute
*attr
,
581 const char *buf
, size_t count
)
583 int new_value
, ret
= count
;
584 struct bonding
*bond
= to_bond(d
);
586 if (sscanf(buf
, "%d", &new_value
) != 1) {
587 printk(KERN_ERR DRV_NAME
588 ": %s: no arp_interval value specified.\n",
594 printk(KERN_ERR DRV_NAME
595 ": %s: Invalid arp_interval value %d not in range 1-%d; rejected.\n",
596 bond
->dev
->name
, new_value
, INT_MAX
);
601 printk(KERN_INFO DRV_NAME
602 ": %s: Setting ARP monitoring interval to %d.\n",
603 bond
->dev
->name
, new_value
);
604 bond
->params
.arp_interval
= new_value
;
605 if (bond
->params
.arp_interval
)
606 bond
->dev
->priv_flags
|= IFF_MASTER_ARPMON
;
607 if (bond
->params
.miimon
) {
608 printk(KERN_INFO DRV_NAME
609 ": %s: ARP monitoring cannot be used with MII monitoring. "
610 "%s Disabling MII monitoring.\n",
611 bond
->dev
->name
, bond
->dev
->name
);
612 bond
->params
.miimon
= 0;
613 if (delayed_work_pending(&bond
->mii_work
)) {
614 cancel_delayed_work(&bond
->mii_work
);
615 flush_workqueue(bond
->wq
);
618 if (!bond
->params
.arp_targets
[0]) {
619 printk(KERN_INFO DRV_NAME
620 ": %s: ARP monitoring has been set up, "
621 "but no ARP targets have been specified.\n",
624 if (bond
->dev
->flags
& IFF_UP
) {
625 /* If the interface is up, we may need to fire off
626 * the ARP timer. If the interface is down, the
627 * timer will get fired off when the open function
630 if (!delayed_work_pending(&bond
->arp_work
)) {
631 if (bond
->params
.mode
== BOND_MODE_ACTIVEBACKUP
)
632 INIT_DELAYED_WORK(&bond
->arp_work
,
633 bond_activebackup_arp_mon
);
635 INIT_DELAYED_WORK(&bond
->arp_work
,
636 bond_loadbalance_arp_mon
);
638 queue_delayed_work(bond
->wq
, &bond
->arp_work
, 0);
645 static DEVICE_ATTR(arp_interval
, S_IRUGO
| S_IWUSR
, bonding_show_arp_interval
, bonding_store_arp_interval
);
648 * Show and set the arp targets.
650 static ssize_t
bonding_show_arp_targets(struct device
*d
,
651 struct device_attribute
*attr
,
655 struct bonding
*bond
= to_bond(d
);
657 for (i
= 0; i
< BOND_MAX_ARP_TARGETS
; i
++) {
658 if (bond
->params
.arp_targets
[i
])
659 res
+= sprintf(buf
+ res
, "%pI4 ",
660 &bond
->params
.arp_targets
[i
]);
663 buf
[res
-1] = '\n'; /* eat the leftover space */
667 static ssize_t
bonding_store_arp_targets(struct device
*d
,
668 struct device_attribute
*attr
,
669 const char *buf
, size_t count
)
672 int i
= 0, done
= 0, ret
= count
;
673 struct bonding
*bond
= to_bond(d
);
676 targets
= bond
->params
.arp_targets
;
677 newtarget
= in_aton(buf
+ 1);
680 if ((newtarget
== 0) || (newtarget
== htonl(INADDR_BROADCAST
))) {
681 printk(KERN_ERR DRV_NAME
682 ": %s: invalid ARP target %pI4 specified for addition\n",
683 bond
->dev
->name
, &newtarget
);
687 /* look for an empty slot to put the target in, and check for dupes */
688 for (i
= 0; (i
< BOND_MAX_ARP_TARGETS
) && !done
; i
++) {
689 if (targets
[i
] == newtarget
) { /* duplicate */
690 printk(KERN_ERR DRV_NAME
691 ": %s: ARP target %pI4 is already present\n",
692 bond
->dev
->name
, &newtarget
);
696 if (targets
[i
] == 0) {
697 printk(KERN_INFO DRV_NAME
698 ": %s: adding ARP target %pI4.\n",
699 bond
->dev
->name
, &newtarget
);
701 targets
[i
] = newtarget
;
705 printk(KERN_ERR DRV_NAME
706 ": %s: ARP target table is full!\n",
713 else if (buf
[0] == '-') {
714 if ((newtarget
== 0) || (newtarget
== htonl(INADDR_BROADCAST
))) {
715 printk(KERN_ERR DRV_NAME
716 ": %s: invalid ARP target %pI4 specified for removal\n",
717 bond
->dev
->name
, &newtarget
);
722 for (i
= 0; (i
< BOND_MAX_ARP_TARGETS
) && !done
; i
++) {
723 if (targets
[i
] == newtarget
) {
725 printk(KERN_INFO DRV_NAME
726 ": %s: removing ARP target %pI4.\n",
727 bond
->dev
->name
, &newtarget
);
728 for (j
= i
; (j
< (BOND_MAX_ARP_TARGETS
-1)) && targets
[j
+1]; j
++)
729 targets
[j
] = targets
[j
+1];
736 printk(KERN_INFO DRV_NAME
737 ": %s: unable to remove nonexistent ARP target %pI4.\n",
738 bond
->dev
->name
, &newtarget
);
744 printk(KERN_ERR DRV_NAME
": no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
753 static DEVICE_ATTR(arp_ip_target
, S_IRUGO
| S_IWUSR
, bonding_show_arp_targets
, bonding_store_arp_targets
);
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.
760 static ssize_t
bonding_show_downdelay(struct device
*d
,
761 struct device_attribute
*attr
,
764 struct bonding
*bond
= to_bond(d
);
766 return sprintf(buf
, "%d\n", bond
->params
.downdelay
* bond
->params
.miimon
);
769 static ssize_t
bonding_store_downdelay(struct device
*d
,
770 struct device_attribute
*attr
,
771 const char *buf
, size_t count
)
773 int new_value
, ret
= count
;
774 struct bonding
*bond
= to_bond(d
);
776 if (!(bond
->params
.miimon
)) {
777 printk(KERN_ERR DRV_NAME
778 ": %s: Unable to set down delay as MII monitoring is disabled\n",
784 if (sscanf(buf
, "%d", &new_value
) != 1) {
785 printk(KERN_ERR DRV_NAME
786 ": %s: no down delay value specified.\n",
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
);
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
);
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
);
815 static DEVICE_ATTR(downdelay
, S_IRUGO
| S_IWUSR
, bonding_show_downdelay
, bonding_store_downdelay
);
817 static ssize_t
bonding_show_updelay(struct device
*d
,
818 struct device_attribute
*attr
,
821 struct bonding
*bond
= to_bond(d
);
823 return sprintf(buf
, "%d\n", bond
->params
.updelay
* bond
->params
.miimon
);
827 static ssize_t
bonding_store_updelay(struct device
*d
,
828 struct device_attribute
*attr
,
829 const char *buf
, size_t count
)
831 int new_value
, ret
= count
;
832 struct bonding
*bond
= to_bond(d
);
834 if (!(bond
->params
.miimon
)) {
835 printk(KERN_ERR DRV_NAME
836 ": %s: Unable to set up delay as MII monitoring is disabled\n",
842 if (sscanf(buf
, "%d", &new_value
) != 1) {
843 printk(KERN_ERR DRV_NAME
844 ": %s: no up delay value specified.\n",
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
);
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
);
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
);
873 static DEVICE_ATTR(updelay
, S_IRUGO
| S_IWUSR
, bonding_show_updelay
, bonding_store_updelay
);
876 * Show and set the LACP interval. Interface must be down, and the mode
877 * must be set to 802.3ad mode.
879 static ssize_t
bonding_show_lacp(struct device
*d
,
880 struct device_attribute
*attr
,
883 struct bonding
*bond
= to_bond(d
);
885 return sprintf(buf
, "%s %d\n",
886 bond_lacp_tbl
[bond
->params
.lacp_fast
].modename
,
887 bond
->params
.lacp_fast
);
890 static ssize_t
bonding_store_lacp(struct device
*d
,
891 struct device_attribute
*attr
,
892 const char *buf
, size_t count
)
894 int new_value
, ret
= count
;
895 struct bonding
*bond
= to_bond(d
);
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",
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",
913 new_value
= bond_parse_parm(buf
, bond_lacp_tbl
);
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
);
921 printk(KERN_ERR DRV_NAME
922 ": %s: Ignoring invalid LACP rate value %.*s.\n",
923 bond
->dev
->name
, (int)strlen(buf
) - 1, buf
);
929 static DEVICE_ATTR(lacp_rate
, S_IRUGO
| S_IWUSR
, bonding_show_lacp
, bonding_store_lacp
);
931 static ssize_t
bonding_show_ad_select(struct device
*d
,
932 struct device_attribute
*attr
,
935 struct bonding
*bond
= to_bond(d
);
937 return sprintf(buf
, "%s %d\n",
938 ad_select_tbl
[bond
->params
.ad_select
].modename
,
939 bond
->params
.ad_select
);
943 static ssize_t
bonding_store_ad_select(struct device
*d
,
944 struct device_attribute
*attr
,
945 const char *buf
, size_t count
)
947 int new_value
, ret
= count
;
948 struct bonding
*bond
= to_bond(d
);
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
);
958 new_value
= bond_parse_parm(buf
, ad_select_tbl
);
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
,
967 printk(KERN_ERR DRV_NAME
968 ": %s: Ignoring invalid ad_select value %.*s.\n",
969 bond
->dev
->name
, (int)strlen(buf
) - 1, buf
);
976 static DEVICE_ATTR(ad_select
, S_IRUGO
| S_IWUSR
, bonding_show_ad_select
, bonding_store_ad_select
);
979 * Show and set the number of grat ARP to send after a failover event.
981 static ssize_t
bonding_show_n_grat_arp(struct device
*d
,
982 struct device_attribute
*attr
,
985 struct bonding
*bond
= to_bond(d
);
987 return sprintf(buf
, "%d\n", bond
->params
.num_grat_arp
);
990 static ssize_t
bonding_store_n_grat_arp(struct device
*d
,
991 struct device_attribute
*attr
,
992 const char *buf
, size_t count
)
994 int new_value
, ret
= count
;
995 struct bonding
*bond
= to_bond(d
);
997 if (sscanf(buf
, "%d", &new_value
) != 1) {
998 printk(KERN_ERR DRV_NAME
999 ": %s: no num_grat_arp value specified.\n",
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
);
1011 bond
->params
.num_grat_arp
= new_value
;
1016 static DEVICE_ATTR(num_grat_arp
, S_IRUGO
| S_IWUSR
, bonding_show_n_grat_arp
, bonding_store_n_grat_arp
);
1019 * Show and set the number of unsolicted NA's to send after a failover event.
1021 static ssize_t
bonding_show_n_unsol_na(struct device
*d
,
1022 struct device_attribute
*attr
,
1025 struct bonding
*bond
= to_bond(d
);
1027 return sprintf(buf
, "%d\n", bond
->params
.num_unsol_na
);
1030 static ssize_t
bonding_store_n_unsol_na(struct device
*d
,
1031 struct device_attribute
*attr
,
1032 const char *buf
, size_t count
)
1034 int new_value
, ret
= count
;
1035 struct bonding
*bond
= to_bond(d
);
1037 if (sscanf(buf
, "%d", &new_value
) != 1) {
1038 printk(KERN_ERR DRV_NAME
1039 ": %s: no num_unsol_na value specified.\n",
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
);
1051 bond
->params
.num_unsol_na
= new_value
;
1056 static DEVICE_ATTR(num_unsol_na
, S_IRUGO
| S_IWUSR
, bonding_show_n_unsol_na
, bonding_store_n_unsol_na
);
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
1064 static ssize_t
bonding_show_miimon(struct device
*d
,
1065 struct device_attribute
*attr
,
1068 struct bonding
*bond
= to_bond(d
);
1070 return sprintf(buf
, "%d\n", bond
->params
.miimon
);
1073 static ssize_t
bonding_store_miimon(struct device
*d
,
1074 struct device_attribute
*attr
,
1075 const char *buf
, size_t count
)
1077 int new_value
, ret
= count
;
1078 struct bonding
*bond
= to_bond(d
);
1080 if (sscanf(buf
, "%d", &new_value
) != 1) {
1081 printk(KERN_ERR DRV_NAME
1082 ": %s: no miimon value specified.\n",
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
);
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",
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",
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",
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
;
1122 if (delayed_work_pending(&bond
->arp_work
)) {
1123 cancel_delayed_work(&bond
->arp_work
);
1124 flush_workqueue(bond
->wq
);
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
1134 if (!delayed_work_pending(&bond
->mii_work
)) {
1135 INIT_DELAYED_WORK(&bond
->mii_work
,
1137 queue_delayed_work(bond
->wq
,
1138 &bond
->mii_work
, 0);
1145 static DEVICE_ATTR(miimon
, S_IRUGO
| S_IWUSR
, bonding_show_miimon
, bonding_store_miimon
);
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
1154 static ssize_t
bonding_show_primary(struct device
*d
,
1155 struct device_attribute
*attr
,
1159 struct bonding
*bond
= to_bond(d
);
1161 if (bond
->primary_slave
)
1162 count
= sprintf(buf
, "%s\n", bond
->primary_slave
->dev
->name
);
1167 static ssize_t
bonding_store_primary(struct device
*d
,
1168 struct device_attribute
*attr
,
1169 const char *buf
, size_t count
)
1172 struct slave
*slave
;
1173 struct bonding
*bond
= to_bond(d
);
1175 if (!rtnl_trylock())
1176 return restart_syscall();
1177 read_lock(&bond
->lock
);
1178 write_lock_bh(&bond
->curr_slave_lock
);
1180 if (!USES_PRIMARY(bond
->params
.mode
)) {
1181 printk(KERN_INFO DRV_NAME
1182 ": %s: Unable to set primary slave; %s is in mode %d\n",
1183 bond
->dev
->name
, bond
->dev
->name
, bond
->params
.mode
);
1185 bond_for_each_slave(bond
, slave
, i
) {
1187 (slave
->dev
->name
, buf
,
1188 strlen(slave
->dev
->name
)) == 0) {
1189 printk(KERN_INFO DRV_NAME
1190 ": %s: Setting %s as primary slave.\n",
1191 bond
->dev
->name
, slave
->dev
->name
);
1192 bond
->primary_slave
= slave
;
1193 bond_select_active_slave(bond
);
1198 /* if we got here, then we didn't match the name of any slave */
1200 if (strlen(buf
) == 0 || buf
[0] == '\n') {
1201 printk(KERN_INFO DRV_NAME
1202 ": %s: Setting primary slave to None.\n",
1204 bond
->primary_slave
= NULL
;
1205 bond_select_active_slave(bond
);
1207 printk(KERN_INFO DRV_NAME
1208 ": %s: Unable to set %.*s as primary slave as it is not a slave.\n",
1209 bond
->dev
->name
, (int)strlen(buf
) - 1, buf
);
1213 write_unlock_bh(&bond
->curr_slave_lock
);
1214 read_unlock(&bond
->lock
);
1219 static DEVICE_ATTR(primary
, S_IRUGO
| S_IWUSR
, bonding_show_primary
, bonding_store_primary
);
1222 * Show and set the use_carrier flag.
1224 static ssize_t
bonding_show_carrier(struct device
*d
,
1225 struct device_attribute
*attr
,
1228 struct bonding
*bond
= to_bond(d
);
1230 return sprintf(buf
, "%d\n", bond
->params
.use_carrier
);
1233 static ssize_t
bonding_store_carrier(struct device
*d
,
1234 struct device_attribute
*attr
,
1235 const char *buf
, size_t count
)
1237 int new_value
, ret
= count
;
1238 struct bonding
*bond
= to_bond(d
);
1241 if (sscanf(buf
, "%d", &new_value
) != 1) {
1242 printk(KERN_ERR DRV_NAME
1243 ": %s: no use_carrier value specified.\n",
1248 if ((new_value
== 0) || (new_value
== 1)) {
1249 bond
->params
.use_carrier
= new_value
;
1250 printk(KERN_INFO DRV_NAME
": %s: Setting use_carrier to %d.\n",
1251 bond
->dev
->name
, new_value
);
1253 printk(KERN_INFO DRV_NAME
1254 ": %s: Ignoring invalid use_carrier value %d.\n",
1255 bond
->dev
->name
, new_value
);
1260 static DEVICE_ATTR(use_carrier
, S_IRUGO
| S_IWUSR
, bonding_show_carrier
, bonding_store_carrier
);
1264 * Show and set currently active_slave.
1266 static ssize_t
bonding_show_active_slave(struct device
*d
,
1267 struct device_attribute
*attr
,
1271 struct bonding
*bond
= to_bond(d
);
1274 read_lock(&bond
->curr_slave_lock
);
1275 curr
= bond
->curr_active_slave
;
1276 read_unlock(&bond
->curr_slave_lock
);
1278 if (USES_PRIMARY(bond
->params
.mode
) && curr
)
1279 count
= sprintf(buf
, "%s\n", curr
->dev
->name
);
1283 static ssize_t
bonding_store_active_slave(struct device
*d
,
1284 struct device_attribute
*attr
,
1285 const char *buf
, size_t count
)
1288 struct slave
*slave
;
1289 struct slave
*old_active
= NULL
;
1290 struct slave
*new_active
= NULL
;
1291 struct bonding
*bond
= to_bond(d
);
1293 if (!rtnl_trylock())
1294 return restart_syscall();
1295 read_lock(&bond
->lock
);
1296 write_lock_bh(&bond
->curr_slave_lock
);
1298 if (!USES_PRIMARY(bond
->params
.mode
)) {
1299 printk(KERN_INFO DRV_NAME
1300 ": %s: Unable to change active slave; %s is in mode %d\n",
1301 bond
->dev
->name
, bond
->dev
->name
, bond
->params
.mode
);
1303 bond_for_each_slave(bond
, slave
, i
) {
1305 (slave
->dev
->name
, buf
,
1306 strlen(slave
->dev
->name
)) == 0) {
1307 old_active
= bond
->curr_active_slave
;
1309 if (new_active
== old_active
) {
1311 printk(KERN_INFO DRV_NAME
1312 ": %s: %s is already the current active slave.\n",
1313 bond
->dev
->name
, slave
->dev
->name
);
1319 (new_active
->link
== BOND_LINK_UP
) &&
1320 IS_UP(new_active
->dev
)) {
1321 printk(KERN_INFO DRV_NAME
1322 ": %s: Setting %s as active slave.\n",
1323 bond
->dev
->name
, slave
->dev
->name
);
1324 bond_change_active_slave(bond
, new_active
);
1327 printk(KERN_INFO DRV_NAME
1328 ": %s: Could not set %s as active slave; "
1329 "either %s is down or the link is down.\n",
1330 bond
->dev
->name
, slave
->dev
->name
,
1338 /* if we got here, then we didn't match the name of any slave */
1340 if (strlen(buf
) == 0 || buf
[0] == '\n') {
1341 printk(KERN_INFO DRV_NAME
1342 ": %s: Setting active slave to None.\n",
1344 bond
->primary_slave
= NULL
;
1345 bond_select_active_slave(bond
);
1347 printk(KERN_INFO DRV_NAME
1348 ": %s: Unable to set %.*s as active slave as it is not a slave.\n",
1349 bond
->dev
->name
, (int)strlen(buf
) - 1, buf
);
1353 write_unlock_bh(&bond
->curr_slave_lock
);
1354 read_unlock(&bond
->lock
);
1360 static DEVICE_ATTR(active_slave
, S_IRUGO
| S_IWUSR
, bonding_show_active_slave
, bonding_store_active_slave
);
1364 * Show link status of the bond interface.
1366 static ssize_t
bonding_show_mii_status(struct device
*d
,
1367 struct device_attribute
*attr
,
1371 struct bonding
*bond
= to_bond(d
);
1373 read_lock(&bond
->curr_slave_lock
);
1374 curr
= bond
->curr_active_slave
;
1375 read_unlock(&bond
->curr_slave_lock
);
1377 return sprintf(buf
, "%s\n", (curr
) ? "up" : "down");
1379 static DEVICE_ATTR(mii_status
, S_IRUGO
, bonding_show_mii_status
, NULL
);
1383 * Show current 802.3ad aggregator ID.
1385 static ssize_t
bonding_show_ad_aggregator(struct device
*d
,
1386 struct device_attribute
*attr
,
1390 struct bonding
*bond
= to_bond(d
);
1392 if (bond
->params
.mode
== BOND_MODE_8023AD
) {
1393 struct ad_info ad_info
;
1394 count
= sprintf(buf
, "%d\n", (bond_3ad_get_active_agg_info(bond
, &ad_info
)) ? 0 : ad_info
.aggregator_id
);
1399 static DEVICE_ATTR(ad_aggregator
, S_IRUGO
, bonding_show_ad_aggregator
, NULL
);
1403 * Show number of active 802.3ad ports.
1405 static ssize_t
bonding_show_ad_num_ports(struct device
*d
,
1406 struct device_attribute
*attr
,
1410 struct bonding
*bond
= to_bond(d
);
1412 if (bond
->params
.mode
== BOND_MODE_8023AD
) {
1413 struct ad_info ad_info
;
1414 count
= sprintf(buf
, "%d\n", (bond_3ad_get_active_agg_info(bond
, &ad_info
)) ? 0: ad_info
.ports
);
1419 static DEVICE_ATTR(ad_num_ports
, S_IRUGO
, bonding_show_ad_num_ports
, NULL
);
1423 * Show current 802.3ad actor key.
1425 static ssize_t
bonding_show_ad_actor_key(struct device
*d
,
1426 struct device_attribute
*attr
,
1430 struct bonding
*bond
= to_bond(d
);
1432 if (bond
->params
.mode
== BOND_MODE_8023AD
) {
1433 struct ad_info ad_info
;
1434 count
= sprintf(buf
, "%d\n", (bond_3ad_get_active_agg_info(bond
, &ad_info
)) ? 0 : ad_info
.actor_key
);
1439 static DEVICE_ATTR(ad_actor_key
, S_IRUGO
, bonding_show_ad_actor_key
, NULL
);
1443 * Show current 802.3ad partner key.
1445 static ssize_t
bonding_show_ad_partner_key(struct device
*d
,
1446 struct device_attribute
*attr
,
1450 struct bonding
*bond
= to_bond(d
);
1452 if (bond
->params
.mode
== BOND_MODE_8023AD
) {
1453 struct ad_info ad_info
;
1454 count
= sprintf(buf
, "%d\n", (bond_3ad_get_active_agg_info(bond
, &ad_info
)) ? 0 : ad_info
.partner_key
);
1459 static DEVICE_ATTR(ad_partner_key
, S_IRUGO
, bonding_show_ad_partner_key
, NULL
);
1463 * Show current 802.3ad partner mac.
1465 static ssize_t
bonding_show_ad_partner_mac(struct device
*d
,
1466 struct device_attribute
*attr
,
1470 struct bonding
*bond
= to_bond(d
);
1472 if (bond
->params
.mode
== BOND_MODE_8023AD
) {
1473 struct ad_info ad_info
;
1474 if (!bond_3ad_get_active_agg_info(bond
, &ad_info
)) {
1475 count
= sprintf(buf
, "%pM\n", ad_info
.partner_system
);
1481 static DEVICE_ATTR(ad_partner_mac
, S_IRUGO
, bonding_show_ad_partner_mac
, NULL
);
1485 static struct attribute
*per_bond_attrs
[] = {
1486 &dev_attr_slaves
.attr
,
1487 &dev_attr_mode
.attr
,
1488 &dev_attr_fail_over_mac
.attr
,
1489 &dev_attr_arp_validate
.attr
,
1490 &dev_attr_arp_interval
.attr
,
1491 &dev_attr_arp_ip_target
.attr
,
1492 &dev_attr_downdelay
.attr
,
1493 &dev_attr_updelay
.attr
,
1494 &dev_attr_lacp_rate
.attr
,
1495 &dev_attr_ad_select
.attr
,
1496 &dev_attr_xmit_hash_policy
.attr
,
1497 &dev_attr_num_grat_arp
.attr
,
1498 &dev_attr_num_unsol_na
.attr
,
1499 &dev_attr_miimon
.attr
,
1500 &dev_attr_primary
.attr
,
1501 &dev_attr_use_carrier
.attr
,
1502 &dev_attr_active_slave
.attr
,
1503 &dev_attr_mii_status
.attr
,
1504 &dev_attr_ad_aggregator
.attr
,
1505 &dev_attr_ad_num_ports
.attr
,
1506 &dev_attr_ad_actor_key
.attr
,
1507 &dev_attr_ad_partner_key
.attr
,
1508 &dev_attr_ad_partner_mac
.attr
,
1512 static struct attribute_group bonding_group
= {
1514 .attrs
= per_bond_attrs
,
1518 * Initialize sysfs. This sets up the bonding_masters file in
1521 int bond_create_sysfs(void)
1525 ret
= netdev_class_create_file(&class_attr_bonding_masters
);
1527 * Permit multiple loads of the module by ignoring failures to
1528 * create the bonding_masters sysfs file. Bonding devices
1529 * created by second or subsequent loads of the module will
1530 * not be listed in, or controllable by, bonding_masters, but
1531 * will have the usual "bonding" sysfs directory.
1533 * This is done to preserve backwards compatibility for
1534 * initscripts/sysconfig, which load bonding multiple times to
1535 * configure multiple bonding devices.
1537 if (ret
== -EEXIST
) {
1538 /* Is someone being kinky and naming a device bonding_master? */
1539 if (__dev_get_by_name(&init_net
,
1540 class_attr_bonding_masters
.attr
.name
))
1542 "network device named %s already exists in sysfs",
1543 class_attr_bonding_masters
.attr
.name
);
1551 * Remove /sys/class/net/bonding_masters.
1553 void bond_destroy_sysfs(void)
1555 netdev_class_remove_file(&class_attr_bonding_masters
);
1559 * Initialize sysfs for each bond. This sets up and registers
1560 * the 'bondctl' directory for each individual bond under /sys/class/net.
1562 int bond_create_sysfs_entry(struct bonding
*bond
)
1564 struct net_device
*dev
= bond
->dev
;
1567 err
= sysfs_create_group(&(dev
->dev
.kobj
), &bonding_group
);
1569 printk(KERN_EMERG
"eek! didn't create group!\n");
1572 if (expected_refcount
< 1)
1573 expected_refcount
= atomic_read(&bond
->dev
->dev
.kobj
.kref
.refcount
);
1578 * Remove sysfs entries for each bond.
1580 void bond_destroy_sysfs_entry(struct bonding
*bond
)
1582 struct net_device
*dev
= bond
->dev
;
1584 sysfs_remove_group(&(dev
->dev
.kobj
), &bonding_group
);