patch-2.4.26 linux-2.4.26/drivers/net/bonding/bond_main.c
Next file: linux-2.4.26/drivers/net/bonding/bonding.h
Previous file: linux-2.4.26/drivers/net/bonding/bond_alb.h
Back to the patch index
Back to the overall index
- Lines: 6959
- Date:
2004-04-14 06:05:30.000000000 -0700
- Orig file:
linux-2.4.25/drivers/net/bonding/bond_main.c
- Orig date:
2003-11-28 10:26:20.000000000 -0800
diff -urN linux-2.4.25/drivers/net/bonding/bond_main.c linux-2.4.26/drivers/net/bonding/bond_main.c
@@ -1,7 +1,7 @@
/*
* originally based on the dummy device.
*
- * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
+ * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
* Licensed under the GPL. Based on dummy.c, and eql.c devices.
*
* bonding.c: an Ethernet Bonding driver
@@ -15,9 +15,9 @@
*
* How it works:
* ifconfig bond0 ipaddress netmask up
- * will setup a network device, with an ip address. No mac address
- * will be assigned at this time. The hw mac address will come from
- * the first slave bonded to the channel. All slaves will then use
+ * will setup a network device, with an ip address. No mac address
+ * will be assigned at this time. The hw mac address will come from
+ * the first slave bonded to the channel. All slaves will then use
* this hw mac address.
*
* ifconfig bond0 down
@@ -26,7 +26,7 @@
* ifenslave bond0 eth0
* will attach eth0 to bond0 as a slave. eth0 hw mac address will either
* a: be used as initial mac address
- * b: if a hw mac address already is there, eth0's hw mac address
+ * b: if a hw mac address already is there, eth0's hw mac address
* will then be set from bond0.
*
* v0.1 - first working version.
@@ -93,14 +93,14 @@
*
* 2001/4/5 - Chad N. Tindel <ctindel at ieee dot org>
* - Ported to 2.4 Kernel
- *
+ *
* 2001/5/2 - Jeffrey E. Mast <jeff at mastfamily dot com>
* - When a device is detached from a bond, the slave device is no longer
* left thinking that is has a master.
*
* 2001/5/16 - Jeffrey E. Mast <jeff at mastfamily dot com>
- * - memset did not appropriately initialized the bond rw_locks. Used
- * rwlock_init to initialize to unlocked state to prevent deadlock when
+ * - memset did not appropriately initialized the bond rw_locks. Used
+ * rwlock_init to initialize to unlocked state to prevent deadlock when
* first attempting a lock
* - Called SET_MODULE_OWNER for bond device
*
@@ -119,7 +119,7 @@
*
* 2001/6/01 - Chad N. Tindel <ctindel at ieee dot org>
* - Added /proc support for getting bond and slave information.
- * Information is in /proc/net/<bond device>/info.
+ * Information is in /proc/net/<bond device>/info.
* - Changed the locking when calling bond_close to prevent deadlock.
*
* 2001/8/05 - Janice Girouard <girouard at us.ibm.com>
@@ -144,8 +144,8 @@
* but only for an up link.
*
* 2001/9/20 - Chad N. Tindel <ctindel at ieee dot org>
- * - Add the device field to bonding_t. Previously the net_device
- * corresponding to a bond wasn't available from the bonding_t
+ * - Add the device field to bonding_t. Previously the net_device
+ * corresponding to a bond wasn't available from the bonding_t
* structure.
*
* 2001/9/25 - Janice Girouard <girouard at us.ibm.com>
@@ -155,10 +155,10 @@
* - Various memory leak fixes
*
* 2001/11/5 - Mark Huth <mark dot huth at mvista dot com>
- * - Don't take rtnl lock in bond_mii_monitor as it deadlocks under
- * certain hotswap conditions.
+ * - Don't take rtnl lock in bond_mii_monitor as it deadlocks under
+ * certain hotswap conditions.
* Note: this same change may be required in bond_arp_monitor ???
- * - Remove possibility of calling bond_sethwaddr with NULL slave_dev ptr
+ * - Remove possibility of calling bond_sethwaddr with NULL slave_dev ptr
* - Handle hot swap ethernet interface deregistration events to remove
* kernel oops following hot swap of enslaved interface
*
@@ -222,23 +222,23 @@
* - fix deletion of multicast groups after unloading module
*
* 2002/11/06 - Kameshwara Rayaprolu <kameshwara.rao * wipro_com>
- * - Changes to prevent panic from closing the device twice; if we close
- * the device in bond_release, we must set the original_flags to down
+ * - Changes to prevent panic from closing the device twice; if we close
+ * the device in bond_release, we must set the original_flags to down
* so it won't be closed again by the network layer.
*
* 2002/11/07 - Tony Cureington <tony.cureington * hp_com>
* - Fix arp_target_hw_addr memory leak
- * - Created activebackup_arp_monitor function to handle arp monitoring
- * in active backup mode - the bond_arp_monitor had several problems...
- * such as allowing slaves to tx arps sequentially without any delay
+ * - Created activebackup_arp_monitor function to handle arp monitoring
+ * in active backup mode - the bond_arp_monitor had several problems...
+ * such as allowing slaves to tx arps sequentially without any delay
* for a response
* - Renamed bond_arp_monitor to loadbalance_arp_monitor and re-wrote
* this function to just handle arp monitoring in load-balancing mode;
* it is a lot more compact now
- * - Changes to ensure one and only one slave transmits in active-backup
+ * - Changes to ensure one and only one slave transmits in active-backup
* mode
- * - Robustesize parameters; warn users about bad combinations of
- * parameters; also if miimon is specified and a network driver does
+ * - Robustesize parameters; warn users about bad combinations of
+ * parameters; also if miimon is specified and a network driver does
* not support MII or ETHTOOL, inform the user of this
* - Changes to support link_failure_count when in arp monitoring mode
* - Fix up/down delay reported in /proc
@@ -248,7 +248,7 @@
*
* 2002/11/16 - Laurent Deniel <laurent.deniel at free.fr>
* - fix multicast handling in activebackup_arp_monitor
- * - remove one unnecessary and confusing current_slave == slave test
+ * - remove one unnecessary and confusing curr_active_slave == slave test
* in activebackup_arp_monitor
*
* 2002/11/17 - Laurent Deniel <laurent.deniel at free.fr>
@@ -267,7 +267,7 @@
* One change: an invalid choice will cause module load failure,
* rather than the previous behavior of just picking one.
* - Minor cleanups; got rid of dup ctype stuff, atoi function
- *
+ *
* 2003/02/07 - Jay Vosburgh <fubar at us dot ibm dot com>
* - Added use_carrier module parameter that causes miimon to
* use netif_carrier_ok() test instead of MII/ETHTOOL ioctls.
@@ -330,7 +330,7 @@
* new/old ifenslave and new/old bonding.
*
* 2003/05/01 - Shmulik Hen <shmulik.hen at intel dot com>
- * - Fixed bug in bond_release_all(): save old value of current_slave
+ * - Fixed bug in bond_release_all(): save old value of curr_active_slave
* before setting it to NULL.
* - Changed driver versioning scheme to include version number instead
* of release date (that is already in another field). There are 3
@@ -358,7 +358,7 @@
*
* 2003/05/01 - Shmulik Hen <shmulik.hen at intel dot com>
* - Added support for Transmit load balancing mode.
- * - Concentrate all assignments of current_slave to a single point
+ * - Concentrate all assignments of curr_active_slave to a single point
* so specific modes can take actions when the primary adapter is
* changed.
* - Take the updelay parameter into consideration during bond_enslave
@@ -426,8 +426,53 @@
* - Convert /proc to seq_file interface.
* Change /proc/net/bondX/info to /proc/net/bonding/bondX.
* Set version to 2.4.1.
+ *
+ * 2003/11/20 - Amir Noam <amir.noam at intel dot com>
+ * - Fix /proc creation/destruction.
+ *
+ * 2003/12/01 - Shmulik Hen <shmulik.hen at intel dot com>
+ * - Massive cleanup - Set version to 2.5.0
+ * Code changes:
+ * o Consolidate format of prints and debug prints.
+ * o Remove bonding_t/slave_t typedefs and consolidate all casts.
+ * o Remove dead code and unnecessary checks.
+ * o Consolidate starting/stopping timers.
+ * o Consolidate handling of primary module param throughout the code.
+ * o Removed multicast module param support - all settings are done
+ * according to mode.
+ * o Slave list iteration - bond is no longer part of the list,
+ * added cyclic list iteration macros.
+ * o Consolidate error handling in all xmit functions.
+ * Style changes:
+ * o Consolidate function naming and declarations.
+ * o Consolidate function params and local variables names.
+ * o Consolidate return values.
+ * o Consolidate curly braces.
+ * o Consolidate conditionals format.
+ * o Change struct member names and types.
+ * o Chomp trailing spaces, remove empty lines, fix indentations.
+ * o Re-organize code according to context.
+ *
+ * 2003/12/30 - Amir Noam <amir.noam at intel dot com>
+ * - Fixed: Cannot remove and re-enslave the original active slave.
+ * - Fixed: Releasing the original active slave causes mac address
+ * duplication.
+ * - Add support for slaves that use ethtool_ops.
+ * Set version to 2.5.3.
+ *
+ * 2004/01/05 - Amir Noam <amir.noam at intel dot com>
+ * - Save bonding parameters per bond instead of using the global values.
+ * Set version to 2.5.4.
+ *
+ * 2004/01/14 - Shmulik Hen <shmulik.hen at intel dot com>
+ * - Enhance VLAN support:
+ * * Add support for VLAN hardware acceleration capable slaves.
+ * * Add capability to tag self generated packets in ALB/TLB modes.
+ * Set version to 2.6.0.
*/
+//#define BONDING_DEBUG 1
+
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
@@ -452,7 +497,6 @@
#include <asm/dma.h>
#include <asm/uaccess.h>
#include <linux/errno.h>
-
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/etherdevice.h>
@@ -461,58 +505,72 @@
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
-
-#include <linux/if_bonding.h>
#include <linux/smp.h>
#include <linux/if_ether.h>
#include <net/arp.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
+#include <linux/if_vlan.h>
+#include <linux/if_bonding.h>
#include "bonding.h"
#include "bond_3ad.h"
#include "bond_alb.h"
-#define DRV_VERSION "2.4.1"
-#define DRV_RELDATE "September 15, 2003"
-#define DRV_NAME "bonding"
-#define DRV_DESCRIPTION "Ethernet Channel Bonding Driver"
-
-static const char *version =
-DRV_NAME ".c:v" DRV_VERSION " (" DRV_RELDATE ")\n";
+/*---------------------------- Module parameters ----------------------------*/
/* monitor all links that often (in milliseconds). <=0 disables monitoring */
-#ifndef BOND_LINK_MON_INTERV
#define BOND_LINK_MON_INTERV 0
-#endif
-
-#ifndef BOND_LINK_ARP_INTERV
#define BOND_LINK_ARP_INTERV 0
-#endif
-#ifndef MAX_ARP_IP_TARGETS
-#define MAX_ARP_IP_TARGETS 16
-#endif
+static int max_bonds = BOND_DEFAULT_MAX_BONDS;
+static int miimon = BOND_LINK_MON_INTERV;
+static int updelay = 0;
+static int downdelay = 0;
+static int use_carrier = 1;
+static char *mode = NULL;
+static char *primary = NULL;
+static char *lacp_rate = NULL;
+static int arp_interval = BOND_LINK_ARP_INTERV;
+static char *arp_ip_target[BOND_MAX_ARP_TARGETS] = { NULL, };
+
+MODULE_PARM(max_bonds, "i");
+MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
+MODULE_PARM(miimon, "i");
+MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
+MODULE_PARM(updelay, "i");
+MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
+MODULE_PARM(downdelay, "i");
+MODULE_PARM_DESC(downdelay, "Delay before considering link down, in milliseconds");
+MODULE_PARM(use_carrier, "i");
+MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; 0 for off, 1 for on (default)");
+MODULE_PARM(mode, "s");
+MODULE_PARM_DESC(mode, "Mode of operation : 0 for round robin, 1 for active-backup, 2 for xor");
+MODULE_PARM(primary, "s");
+MODULE_PARM_DESC(primary, "Primary network device to use");
+MODULE_PARM(lacp_rate, "s");
+MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner (slow/fast)");
+MODULE_PARM(arp_interval, "i");
+MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
+MODULE_PARM(arp_ip_target, "1-" __MODULE_STRING(BOND_MAX_ARP_TARGETS) "s");
+MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
-#define USES_PRIMARY(mode) \
- (((mode) == BOND_MODE_ACTIVEBACKUP) || \
- ((mode) == BOND_MODE_TLB) || \
- ((mode) == BOND_MODE_ALB))
+/*----------------------------- Global variables ----------------------------*/
-struct bond_parm_tbl {
- char *modename;
- int mode;
-};
+static const char *version =
+ DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n";
-static int arp_interval = BOND_LINK_ARP_INTERV;
-static char *arp_ip_target[MAX_ARP_IP_TARGETS] = { NULL, };
-static u32 arp_target[MAX_ARP_IP_TARGETS] = { 0, } ;
-static int arp_ip_count = 0;
-static u32 my_ip = 0;
-char *arp_target_hw_addr = NULL;
+static LIST_HEAD(bond_dev_list);
-static char *primary= NULL;
+#ifdef CONFIG_PROC_FS
+static struct proc_dir_entry *bond_proc_dir = NULL;
+#endif
-static int app_abi_ver = 0;
+static u32 arp_target[BOND_MAX_ARP_TARGETS] = { 0, } ;
+static int arp_ip_count = 0;
+static u32 my_ip = 0;
+static int bond_mode = BOND_MODE_ROUNDROBIN;
+static int lacp_fast = 0;
+static int app_abi_ver = 0;
static int orig_app_abi_ver = -1; /* This is used to save the first ABI version
* we receive from the application. Once set,
* it won't be changed, and the module will
@@ -521,14 +579,16 @@
* another ABI version.
*/
-static int max_bonds = BOND_DEFAULT_MAX_BONDS;
-static int miimon = BOND_LINK_MON_INTERV;
-static int use_carrier = 1;
-static int bond_mode = BOND_MODE_ROUNDROBIN;
-static int updelay = 0;
-static int downdelay = 0;
+struct bond_parm_tbl {
+ char *modename;
+ int mode;
+};
-static char *mode = NULL;
+static struct bond_parm_tbl bond_lacp_tbl[] = {
+{ "slow", AD_LACP_SLOW},
+{ "fast", AD_LACP_FAST},
+{ NULL, -1},
+};
static struct bond_parm_tbl bond_mode_tbl[] = {
{ "balance-rr", BOND_MODE_ROUNDROBIN},
@@ -541,103 +601,15 @@
{ NULL, -1},
};
-static int multicast_mode = BOND_MULTICAST_ALL;
-static char *multicast = NULL;
-
-static struct bond_parm_tbl bond_mc_tbl[] = {
-{ "disabled", BOND_MULTICAST_DISABLED},
-{ "active", BOND_MULTICAST_ACTIVE},
-{ "all", BOND_MULTICAST_ALL},
-{ NULL, -1},
-};
-
-static int lacp_fast = 0;
-static char *lacp_rate = NULL;
-
-static struct bond_parm_tbl bond_lacp_tbl[] = {
-{ "slow", AD_LACP_SLOW},
-{ "fast", AD_LACP_FAST},
-{ NULL, -1},
-};
-
-static LIST_HEAD(bond_dev_list);
-#ifdef CONFIG_PROC_FS
-static struct proc_dir_entry *bond_proc_dir = NULL;
-#endif
+/*-------------------------- Forward declarations ---------------------------*/
-MODULE_PARM(max_bonds, "i");
-MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
-MODULE_PARM(miimon, "i");
-MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
-MODULE_PARM(use_carrier, "i");
-MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; 0 for off, 1 for on (default)");
-MODULE_PARM(mode, "s");
-MODULE_PARM_DESC(mode, "Mode of operation : 0 for round robin, 1 for active-backup, 2 for xor");
-MODULE_PARM(arp_interval, "i");
-MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
-MODULE_PARM(arp_ip_target, "1-" __MODULE_STRING(MAX_ARP_IP_TARGETS) "s");
-MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
-MODULE_PARM(updelay, "i");
-MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
-MODULE_PARM(downdelay, "i");
-MODULE_PARM_DESC(downdelay, "Delay before considering link down, in milliseconds");
-MODULE_PARM(primary, "s");
-MODULE_PARM_DESC(primary, "Primary network device to use");
-MODULE_PARM(multicast, "s");
-MODULE_PARM_DESC(multicast, "Mode for multicast support : 0 for none, 1 for active slave, 2 for all slaves (default)");
-MODULE_PARM(lacp_rate, "s");
-MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner (slow/fast)");
+static inline void bond_set_mode_ops(struct net_device *bond_dev, int mode);
-static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *dev);
-static int bond_xmit_xor(struct sk_buff *skb, struct net_device *dev);
-static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *dev);
-static struct net_device_stats *bond_get_stats(struct net_device *dev);
-static void bond_mii_monitor(struct net_device *dev);
-static void loadbalance_arp_monitor(struct net_device *dev);
-static void activebackup_arp_monitor(struct net_device *dev);
-static void bond_mc_list_destroy(struct bonding *bond);
-static void bond_mc_add(bonding_t *bond, void *addr, int alen);
-static void bond_mc_delete(bonding_t *bond, void *addr, int alen);
-static int bond_mc_list_copy (struct dev_mc_list *src, struct bonding *dst, int gpf_flag);
-static inline int dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2);
-static void bond_set_promiscuity(bonding_t *bond, int inc);
-static void bond_set_allmulti(bonding_t *bond, int inc);
-static struct dev_mc_list* bond_mc_list_find_dmi(struct dev_mc_list *dmi, struct dev_mc_list *mc_list);
-static void bond_mc_update(bonding_t *bond, slave_t *new, slave_t *old);
-static int bond_enslave(struct net_device *master, struct net_device *slave);
-static int bond_release(struct net_device *master, struct net_device *slave);
-static int bond_release_all(struct net_device *master);
-static int bond_sethwaddr(struct net_device *master, struct net_device *slave);
-static void change_active_interface(struct bonding *bond, struct slave *new);
-static void reselect_active_interface(struct bonding *bond);
-static struct slave *find_best_interface(struct bonding *bond);
-
-
-/* #define BONDING_DEBUG 1 */
-#ifdef BONDING_DEBUG
-#define dprintk(x...) printk(x...)
-#else /* BONDING_DEBUG */
-#define dprintk(x...) do {} while (0)
-#endif /* BONDING_DEBUG */
-
-/* several macros */
-
-static void arp_send_all(slave_t *slave)
-{
- int i;
-
- for (i = 0; (i<MAX_ARP_IP_TARGETS) && arp_target[i]; i++) {
- arp_send(ARPOP_REQUEST, ETH_P_ARP, arp_target[i], slave->dev,
- my_ip, arp_target_hw_addr, slave->dev->dev_addr,
- arp_target_hw_addr);
- }
-}
-
+/*---------------------------- General routines -----------------------------*/
-static const char *
-bond_mode_name(void)
+static const char *bond_mode_name(int mode)
{
- switch (bond_mode) {
+ switch (mode) {
case BOND_MODE_ROUNDROBIN :
return "load balancing (round-robin)";
case BOND_MODE_ACTIVEBACKUP :
@@ -657,767 +629,1070 @@
}
}
-static const char *
-multicast_mode_name(void)
+/*---------------------------------- VLAN -----------------------------------*/
+
+/**
+ * bond_add_vlan - add a new vlan id on bond
+ * @bond: bond that got the notification
+ * @vlan_id: the vlan id to add
+ *
+ * Returns -ENOMEM if allocation failed.
+ */
+static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
{
- switch(multicast_mode) {
- case BOND_MULTICAST_DISABLED :
- return "disabled";
- case BOND_MULTICAST_ACTIVE :
- return "active slave only";
- case BOND_MULTICAST_ALL :
- return "all slaves";
- default :
- return "unknown";
+ struct vlan_entry *vlan;
+
+ dprintk("bond: %s, vlan id %d\n",
+ (bond ? bond->dev->name: "None"), vlan_id);
+
+ vlan = kmalloc(sizeof(struct vlan_entry), GFP_KERNEL);
+ if (!vlan) {
+ return -ENOMEM;
}
-}
-void bond_set_slave_inactive_flags(slave_t *slave)
-{
- slave->state = BOND_STATE_BACKUP;
- slave->dev->flags |= IFF_NOARP;
-}
+ INIT_LIST_HEAD(&vlan->vlan_list);
+ vlan->vlan_id = vlan_id;
-void bond_set_slave_active_flags(slave_t *slave)
-{
- slave->state = BOND_STATE_ACTIVE;
- slave->dev->flags &= ~IFF_NOARP;
+ write_lock_bh(&bond->lock);
+
+ list_add_tail(&vlan->vlan_list, &bond->vlan_list);
+
+ write_unlock_bh(&bond->lock);
+
+ dprintk("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
+
+ return 0;
}
-/*
- * This function counts and verifies the the number of attached
- * slaves, checking the count against the expected value (given that incr
- * is either 1 or -1, for add or removal of a slave). Only
- * bond_xmit_xor() uses the slave_cnt value, but this is still a good
- * consistency check.
+/**
+ * bond_del_vlan - delete a vlan id from bond
+ * @bond: bond that got the notification
+ * @vlan_id: the vlan id to delete
+ *
+ * returns -ENODEV if @vlan_id was not found in @bond.
*/
-static inline void
-update_slave_cnt(bonding_t *bond, int incr)
+static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
{
- slave_t *slave = NULL;
- int expect = bond->slave_cnt + incr;
+ struct vlan_entry *vlan, *next;
+ int res = -ENODEV;
- bond->slave_cnt = 0;
- for (slave = bond->prev; slave != (slave_t*)bond;
- slave = slave->prev) {
- bond->slave_cnt++;
+ dprintk("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
+
+ write_lock_bh(&bond->lock);
+
+ list_for_each_entry_safe(vlan, next, &bond->vlan_list, vlan_list) {
+ if (vlan->vlan_id == vlan_id) {
+ list_del(&vlan->vlan_list);
+
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ bond_alb_clear_vlan(bond, vlan_id);
+ }
+
+ dprintk("removed VLAN ID %d from bond %s\n", vlan_id,
+ bond->dev->name);
+
+ kfree(vlan);
+
+ if (list_empty(&bond->vlan_list) &&
+ (bond->slave_cnt == 0)) {
+ /* Last VLAN removed and no slaves, so
+ * restore block on adding VLANs. This will
+ * be removed once new slaves that are not
+ * VLAN challenged will be added.
+ */
+ bond->dev->features |= NETIF_F_VLAN_CHALLENGED;
+ }
+
+ res = 0;
+ goto out;
+ }
}
- if (expect != bond->slave_cnt)
- BUG();
+ dprintk("couldn't find VLAN ID %d in bond %s\n", vlan_id,
+ bond->dev->name);
+
+out:
+ write_unlock_bh(&bond->lock);
+ return res;
}
-/*
- * This function detaches the slave <slave> from the list <bond>.
- * WARNING: no check is made to verify if the slave effectively
- * belongs to <bond>. It returns <slave> in case it's needed.
- * Nothing is freed on return, structures are just unchained.
- * If the bond->current_slave pointer was pointing to <slave>,
- * it should be changed by the calling function.
+/**
+ * bond_has_challenged_slaves
+ * @bond: the bond we're working on
*
- * bond->lock held for writing by caller.
+ * Searches the slave list. Returns 1 if a vlan challenged slave
+ * was found, 0 otherwise.
+ *
+ * Assumes bond->lock is held.
*/
-static slave_t *
-bond_detach_slave(bonding_t *bond, slave_t *slave)
+static int bond_has_challenged_slaves(struct bonding *bond)
{
- if ((bond == NULL) || (slave == NULL) ||
- ((void *)bond == (void *)slave)) {
- printk(KERN_ERR
- "bond_detach_slave(): trying to detach "
- "slave %p from bond %p\n", bond, slave);
- return slave;
- }
-
- if (bond->next == slave) { /* is the slave at the head ? */
- if (bond->prev == slave) { /* is the slave alone ? */
- bond->prev = bond->next = (slave_t *)bond;
- } else { /* not alone */
- bond->next = slave->next;
- slave->next->prev = (slave_t *)bond;
- bond->prev->next = slave->next;
- }
- } else {
- slave->prev->next = slave->next;
- if (bond->prev == slave) { /* is this slave the last one ? */
- bond->prev = slave->prev;
- } else {
- slave->next->prev = slave->prev;
+ struct slave *slave;
+ int i;
+
+ bond_for_each_slave(bond, slave, i) {
+ if (slave->dev->features & NETIF_F_VLAN_CHALLENGED) {
+ dprintk("found VLAN challenged slave - %s\n",
+ slave->dev->name);
+ return 1;
}
}
- update_slave_cnt(bond, -1);
-
- return slave;
+ dprintk("no VLAN challenged slaves found\n");
+ return 0;
}
-/*
- * This function attaches the slave <slave> to the list <bond>.
+/**
+ * bond_next_vlan - safely skip to the next item in the vlans list.
+ * @bond: the bond we're working on
+ * @curr: item we're advancing from
*
- * bond->lock held for writing by caller.
+ * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
+ * or @curr->next otherwise (even if it is @curr itself again).
+ *
+ * Caller must hold bond->lock
*/
-static void
-bond_attach_slave(struct bonding *bond, struct slave *new_slave)
+struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
{
- /*
- * queue to the end of the slaves list, make the first element its
- * successor, the last one its predecessor, and make it the bond's
- * predecessor.
- *
- * Just to clarify, so future bonding driver hackers don't go through
- * the same confusion stage I did trying to figure this out, the
- * slaves are stored in a double linked circular list, sortof.
- * In the ->next direction, the last slave points to the first slave,
- * bypassing bond; only the slaves are in the ->next direction.
- * In the ->prev direction, however, the first slave points to bond
- * and bond points to the last slave.
- *
- * It looks like a circle with a little bubble hanging off one side
- * in the ->prev direction only.
- *
- * When going through the list once, its best to start at bond->prev
- * and go in the ->prev direction, testing for bond. Doing this
- * in the ->next direction doesn't work. Trust me, I know this now.
- * :) -mts 2002.03.14
- */
- new_slave->prev = bond->prev;
- new_slave->prev->next = new_slave;
- bond->prev = new_slave;
- new_slave->next = bond->next;
+ struct vlan_entry *next, *last;
- update_slave_cnt(bond, 1);
-}
+ if (list_empty(&bond->vlan_list)) {
+ return NULL;
+ }
+ if (!curr) {
+ next = list_entry(bond->vlan_list.next,
+ struct vlan_entry, vlan_list);
+ } else {
+ last = list_entry(bond->vlan_list.prev,
+ struct vlan_entry, vlan_list);
+ if (last == curr) {
+ next = list_entry(bond->vlan_list.next,
+ struct vlan_entry, vlan_list);
+ } else {
+ next = list_entry(curr->vlan_list.next,
+ struct vlan_entry, vlan_list);
+ }
+ }
-/*
- * Less bad way to call ioctl from within the kernel; this needs to be
- * done some other way to get the call out of interrupt context.
- * Needs "ioctl" variable to be supplied by calling context.
- */
-#define IOCTL(dev, arg, cmd) ({ \
- int ret; \
- mm_segment_t fs = get_fs(); \
- set_fs(get_ds()); \
- ret = ioctl(dev, arg, cmd); \
- set_fs(fs); \
- ret; })
+ return next;
+}
-/*
- * Get link speed and duplex from the slave's base driver
- * using ethtool. If for some reason the call fails or the
- * values are invalid, fake speed and duplex to 100/Full
- * and return error.
+/**
+ * bond_dev_queue_xmit - Prepare skb for xmit.
+ *
+ * @bond: bond device that got this skb for tx.
+ * @skb: hw accel VLAN tagged skb to transmit
+ * @slave_dev: slave that is supposed to xmit this skbuff
+ *
+ * When the bond gets an skb to tarnsmit that is
+ * already hardware accelerated VLAN tagged, and it
+ * needs to relay this skb to a slave that is not
+ * hw accel capable, the skb needs to be "unaccelerated",
+ * i.e. strip the hwaccel tag and re-insert it as part
+ * of the payload.
+ *
+ * Assumption - once a VLAN device is created over the bond device, all
+ * packets are going to be hardware accelerated VLAN tagged since the IP
+ * binding is done over the VLAN device
*/
-static int bond_update_speed_duplex(struct slave *slave)
+int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev)
{
- struct net_device *dev = slave->dev;
- static int (* ioctl)(struct net_device *, struct ifreq *, int);
- struct ifreq ifr;
- struct ethtool_cmd etool;
+ unsigned short vlan_id;
+ int res;
- ioctl = dev->do_ioctl;
- if (ioctl) {
- etool.cmd = ETHTOOL_GSET;
- ifr.ifr_data = (char*)&etool;
- if (IOCTL(dev, &ifr, SIOCETHTOOL) == 0) {
- slave->speed = etool.speed;
- slave->duplex = etool.duplex;
- } else {
- goto err_out;
+ if (!list_empty(&bond->vlan_list) &&
+ !(slave_dev->features & NETIF_F_HW_VLAN_TX)) {
+ res = vlan_get_tag(skb, &vlan_id);
+ if (res) {
+ return -EINVAL;
}
- } else {
- goto err_out;
- }
- switch (slave->speed) {
- case SPEED_10:
- case SPEED_100:
- case SPEED_1000:
- break;
- default:
- goto err_out;
+ skb->dev = slave_dev;
+ skb = vlan_put_tag(skb, vlan_id);
+ if (!skb) {
+ /* vlan_put_tag() frees the skb in case of error,
+ * so return success here so the calling functions
+ * won't attempt to free is again.
+ */
+ return 0;
+ }
+ } else {
+ skb->dev = slave_dev;
}
- switch (slave->duplex) {
- case DUPLEX_FULL:
- case DUPLEX_HALF:
- break;
- default:
- goto err_out;
- }
+ skb->priority = 1;
+ dev_queue_xmit(skb);
return 0;
-
-err_out:
- /* Fake speed and duplex */
- slave->speed = SPEED_100;
- slave->duplex = DUPLEX_FULL;
- return -1;
}
-/*
- * if <dev> supports MII link status reporting, check its link status.
- *
- * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
- * depening upon the setting of the use_carrier parameter.
- *
- * Return either BMSR_LSTATUS, meaning that the link is up (or we
- * can't tell and just pretend it is), or 0, meaning that the link is
- * down.
- *
- * If reporting is non-zero, instead of faking link up, return -1 if
- * both ETHTOOL and MII ioctls fail (meaning the device does not
- * support them). If use_carrier is set, return whatever it says.
- * It'd be nice if there was a good way to tell if a driver supports
- * netif_carrier, but there really isn't.
+/*
+ * In the following 3 functions, bond_vlan_rx_register(), bond_vlan_rx_add_vid
+ * and bond_vlan_rx_kill_vid, We don't protect the slave list iteration with a
+ * lock because:
+ * a. This operation is performed in IOCTL context,
+ * b. The operation is protected by the RTNL semaphore in the 8021q code,
+ * c. Holding a lock with BH disabled while directly calling a base driver
+ * entry point is generally a BAD idea.
+ *
+ * The design of synchronization/protection for this operation in the 8021q
+ * module is good for one or more VLAN devices over a single physical device
+ * and cannot be extended for a teaming solution like bonding, so there is a
+ * potential race condition here where a net device from the vlan group might
+ * be referenced (either by a base driver or the 8021q code) while it is being
+ * removed from the system. However, it turns out we're not making matters
+ * worse, and if it works for regular VLAN usage it will work here too.
+*/
+
+/**
+ * bond_vlan_rx_register - Propagates registration to slaves
+ * @bond_dev: bonding net device that got called
+ * @grp: vlan group being registered
*/
-static int
-bond_check_dev_link(struct net_device *dev, int reporting)
+static void bond_vlan_rx_register(struct net_device *bond_dev, struct vlan_group *grp)
{
- static int (* ioctl)(struct net_device *, struct ifreq *, int);
- struct ifreq ifr;
- struct mii_ioctl_data *mii;
- struct ethtool_value etool;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
+ int i;
- if (use_carrier) {
- return netif_carrier_ok(dev) ? BMSR_LSTATUS : 0;
+ bond->vlgrp = grp;
+
+ bond_for_each_slave(bond, slave, i) {
+ struct net_device *slave_dev = slave->dev;
+
+ if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
+ slave_dev->vlan_rx_register) {
+ slave_dev->vlan_rx_register(slave_dev, grp);
+ }
}
+}
- ioctl = dev->do_ioctl;
- if (ioctl) {
- /* TODO: set pointer to correct ioctl on a per team member */
- /* bases to make this more efficient. that is, once */
- /* we determine the correct ioctl, we will always */
- /* call it and not the others for that team */
- /* member. */
+/**
+ * bond_vlan_rx_add_vid - Propagates adding an id to slaves
+ * @bond_dev: bonding net device that got called
+ * @vid: vlan id being added
+ */
+static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
+ int i, res;
- /*
- * We cannot assume that SIOCGMIIPHY will also read a
- * register; not all network drivers (e.g., e100)
- * support that.
- */
+ bond_for_each_slave(bond, slave, i) {
+ struct net_device *slave_dev = slave->dev;
- /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
- mii = (struct mii_ioctl_data *)&ifr.ifr_data;
- if (IOCTL(dev, &ifr, SIOCGMIIPHY) == 0) {
- mii->reg_num = MII_BMSR;
- if (IOCTL(dev, &ifr, SIOCGMIIREG) == 0) {
- return mii->val_out & BMSR_LSTATUS;
- }
- }
-
- /* try SIOCETHTOOL ioctl, some drivers cache ETHTOOL_GLINK */
- /* for a period of time so we attempt to get link status */
- /* from it last if the above MII ioctls fail... */
- etool.cmd = ETHTOOL_GLINK;
- ifr.ifr_data = (char*)&etool;
- if (IOCTL(dev, &ifr, SIOCETHTOOL) == 0) {
- if (etool.data == 1) {
- return BMSR_LSTATUS;
- } else {
-#ifdef BONDING_DEBUG
- printk(KERN_INFO
- ":: SIOCETHTOOL shows link down \n");
-#endif
- return 0;
- }
+ if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
+ slave_dev->vlan_rx_add_vid) {
+ slave_dev->vlan_rx_add_vid(slave_dev, vid);
}
+ }
+ res = bond_add_vlan(bond, vid);
+ if (res) {
+ printk(KERN_ERR DRV_NAME
+ ": %s: Failed to add vlan id %d\n",
+ bond_dev->name, vid);
}
-
- /*
- * If reporting, report that either there's no dev->do_ioctl,
- * or both SIOCGMIIREG and SIOCETHTOOL failed (meaning that we
- * cannot report link status). If not reporting, pretend
- * we're ok.
- */
- return reporting ? -1 : BMSR_LSTATUS;
}
-static u16 bond_check_mii_link(bonding_t *bond)
+/**
+ * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
+ * @bond_dev: bonding net device that got called
+ * @vid: vlan id being removed
+ */
+static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid)
{
- int has_active_interface = 0;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
+ struct net_device *vlan_dev;
+ int i, res;
- read_lock_bh(&bond->lock);
- read_lock(&bond->ptrlock);
- has_active_interface = (bond->current_slave != NULL);
- read_unlock(&bond->ptrlock);
- read_unlock_bh(&bond->lock);
+ bond_for_each_slave(bond, slave, i) {
+ struct net_device *slave_dev = slave->dev;
+
+ if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
+ slave_dev->vlan_rx_kill_vid) {
+ /* Save and then restore vlan_dev in the grp array,
+ * since the slave's driver might clear it.
+ */
+ vlan_dev = bond->vlgrp->vlan_devices[vid];
+ slave_dev->vlan_rx_kill_vid(slave_dev, vid);
+ bond->vlgrp->vlan_devices[vid] = vlan_dev;
+ }
+ }
- return (has_active_interface ? BMSR_LSTATUS : 0);
+ res = bond_del_vlan(bond, vid);
+ if (res) {
+ printk(KERN_ERR DRV_NAME
+ ": %s: Failed to remove vlan id %d\n",
+ bond_dev->name, vid);
+ }
}
-/* register to receive lacpdus on a bond */
-static void bond_register_lacpdu(struct bonding *bond)
+static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
{
- struct packet_type* pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);
+ struct vlan_entry *vlan;
- /* initialize packet type */
- pk_type->type = PKT_TYPE_LACPDU;
- pk_type->dev = bond->device;
- pk_type->func = bond_3ad_lacpdu_recv;
- pk_type->data = (void*)1; /* understand shared skbs */
+ write_lock_bh(&bond->lock);
- dev_add_pack(pk_type);
+ if (list_empty(&bond->vlan_list)) {
+ goto out;
+ }
+
+ if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
+ slave_dev->vlan_rx_register) {
+ slave_dev->vlan_rx_register(slave_dev, bond->vlgrp);
+ }
+
+ if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
+ !(slave_dev->vlan_rx_add_vid)) {
+ goto out;
+ }
+
+ list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
+ slave_dev->vlan_rx_add_vid(slave_dev, vlan->vlan_id);
+ }
+
+out:
+ write_unlock_bh(&bond->lock);
}
-/* unregister to receive lacpdus on a bond */
-static void bond_unregister_lacpdu(struct bonding *bond)
+static void bond_del_vlans_from_slave(struct bonding *bond, struct net_device *slave_dev)
{
- dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
+ struct vlan_entry *vlan;
+ struct net_device *vlan_dev;
+
+ write_lock_bh(&bond->lock);
+
+ if (list_empty(&bond->vlan_list)) {
+ goto out;
+ }
+
+ if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
+ !(slave_dev->vlan_rx_kill_vid)) {
+ goto unreg;
+ }
+
+ list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
+ /* Save and then restore vlan_dev in the grp array,
+ * since the slave's driver might clear it.
+ */
+ vlan_dev = bond->vlgrp->vlan_devices[vlan->vlan_id];
+ slave_dev->vlan_rx_kill_vid(slave_dev, vlan->vlan_id);
+ bond->vlgrp->vlan_devices[vlan->vlan_id] = vlan_dev;
+ }
+
+unreg:
+ if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
+ slave_dev->vlan_rx_register) {
+ slave_dev->vlan_rx_register(slave_dev, NULL);
+ }
+
+out:
+ write_unlock_bh(&bond->lock);
}
-static int bond_open(struct net_device *dev)
+/*------------------------------- Link status -------------------------------*/
+
+/*
+ * Get link speed and duplex from the slave's base driver
+ * using ethtool. If for some reason the call fails or the
+ * values are invalid, fake speed and duplex to 100/Full
+ * and return error.
+ */
+static int bond_update_speed_duplex(struct slave *slave)
{
- struct bonding *bond = (struct bonding *)(dev->priv);
- struct timer_list *timer = &((struct bonding *)(dev->priv))->mii_timer;
- struct timer_list *arp_timer = &((struct bonding *)(dev->priv))->arp_timer;
+ struct net_device *slave_dev = slave->dev;
+ static int (* ioctl)(struct net_device *, struct ifreq *, int);
+ struct ifreq ifr;
+ struct ethtool_cmd etool;
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- struct timer_list *alb_timer = &(BOND_ALB_INFO(bond).alb_timer);
+ /* Fake speed and duplex */
+ slave->speed = SPEED_100;
+ slave->duplex = DUPLEX_FULL;
- /* bond_alb_initialize must be called before the timer
- * is started.
- */
- if (bond_alb_initialize(bond, (bond_mode == BOND_MODE_ALB))) {
- /* something went wrong - fail the open operation */
+ if (slave_dev->ethtool_ops) {
+ u32 res;
+
+ if (!slave_dev->ethtool_ops->get_settings) {
return -1;
}
- init_timer(alb_timer);
- alb_timer->expires = jiffies + 1;
- alb_timer->data = (unsigned long)bond;
- alb_timer->function = (void *)&bond_alb_monitor;
- add_timer(alb_timer);
- }
+ res = slave_dev->ethtool_ops->get_settings(slave_dev, &etool);
+ if (res < 0) {
+ return -1;
+ }
- if (miimon > 0) { /* link check interval, in milliseconds. */
- init_timer(timer);
- timer->expires = jiffies + (miimon * HZ / 1000);
- timer->data = (unsigned long)dev;
- timer->function = (void *)&bond_mii_monitor;
- add_timer(timer);
+ goto verify;
}
- if (arp_interval> 0) { /* arp interval, in milliseconds. */
- init_timer(arp_timer);
- arp_timer->expires = jiffies + (arp_interval * HZ / 1000);
- arp_timer->data = (unsigned long)dev;
- if (bond_mode == BOND_MODE_ACTIVEBACKUP) {
- arp_timer->function = (void *)&activebackup_arp_monitor;
- } else {
- arp_timer->function = (void *)&loadbalance_arp_monitor;
- }
- add_timer(arp_timer);
+ ioctl = slave_dev->do_ioctl;
+ strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
+ etool.cmd = ETHTOOL_GSET;
+ ifr.ifr_data = (char*)&etool;
+ if (!ioctl || (IOCTL(slave_dev, &ifr, SIOCETHTOOL) < 0)) {
+ return -1;
+ }
+
+verify:
+ switch (etool.speed) {
+ case SPEED_10:
+ case SPEED_100:
+ case SPEED_1000:
+ break;
+ default:
+ return -1;
}
- if (bond_mode == BOND_MODE_8023AD) {
- struct timer_list *ad_timer = &(BOND_AD_INFO(bond).ad_timer);
- init_timer(ad_timer);
- ad_timer->expires = jiffies + (AD_TIMER_INTERVAL * HZ / 1000);
- ad_timer->data = (unsigned long)bond;
- ad_timer->function = (void *)&bond_3ad_state_machine_handler;
- add_timer(ad_timer);
-
- /* register to receive LACPDUs */
- bond_register_lacpdu(bond);
+ switch (etool.duplex) {
+ case DUPLEX_FULL:
+ case DUPLEX_HALF:
+ break;
+ default:
+ return -1;
}
+ slave->speed = etool.speed;
+ slave->duplex = etool.duplex;
+
return 0;
}
-static int bond_close(struct net_device *master)
+/*
+ * if <dev> supports MII link status reporting, check its link status.
+ *
+ * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
+ * depening upon the setting of the use_carrier parameter.
+ *
+ * Return either BMSR_LSTATUS, meaning that the link is up (or we
+ * can't tell and just pretend it is), or 0, meaning that the link is
+ * down.
+ *
+ * If reporting is non-zero, instead of faking link up, return -1 if
+ * both ETHTOOL and MII ioctls fail (meaning the device does not
+ * support them). If use_carrier is set, return whatever it says.
+ * It'd be nice if there was a good way to tell if a driver supports
+ * netif_carrier, but there really isn't.
+ */
+static int bond_check_dev_link(struct bonding *bond, struct net_device *slave_dev, int reporting)
{
- bonding_t *bond = (struct bonding *) master->priv;
-
- write_lock_bh(&bond->lock);
+ static int (* ioctl)(struct net_device *, struct ifreq *, int);
+ struct ifreq ifr;
+ struct mii_ioctl_data *mii;
+ struct ethtool_value etool;
- if (miimon > 0) { /* link check interval, in milliseconds. */
- del_timer(&bond->mii_timer);
- }
- if (arp_interval> 0) { /* arp interval, in milliseconds. */
- del_timer(&bond->arp_timer);
- if (arp_target_hw_addr != NULL) {
- kfree(arp_target_hw_addr);
- arp_target_hw_addr = NULL;
- }
+ if (bond->params.use_carrier) {
+ return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;
}
- if (bond_mode == BOND_MODE_8023AD) {
- del_timer_sync(&(BOND_AD_INFO(bond).ad_timer));
+ ioctl = slave_dev->do_ioctl;
+ if (ioctl) {
+ /* TODO: set pointer to correct ioctl on a per team member */
+ /* bases to make this more efficient. that is, once */
+ /* we determine the correct ioctl, we will always */
+ /* call it and not the others for that team */
+ /* member. */
- /* Unregister the receive of LACPDUs */
- bond_unregister_lacpdu(bond);
- }
+ /*
+ * We cannot assume that SIOCGMIIPHY will also read a
+ * register; not all network drivers (e.g., e100)
+ * support that.
+ */
- bond_mc_list_destroy (bond);
+ /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
+ strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
+ mii = (struct mii_ioctl_data *)&ifr.ifr_data;
+ if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
+ mii->reg_num = MII_BMSR;
+ if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0) {
+ return (mii->val_out & BMSR_LSTATUS);
+ }
+ }
+ }
- write_unlock_bh(&bond->lock);
+ /* try SIOCETHTOOL ioctl, some drivers cache ETHTOOL_GLINK */
+ /* for a period of time so we attempt to get link status */
+ /* from it last if the above MII ioctls fail... */
+ if (slave_dev->ethtool_ops) {
+ if (slave_dev->ethtool_ops->get_link) {
+ u32 link;
- /* Release the bonded slaves */
- bond_release_all(master);
+ link = slave_dev->ethtool_ops->get_link(slave_dev);
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- del_timer_sync(&(BOND_ALB_INFO(bond).alb_timer));
+ return link ? BMSR_LSTATUS : 0;
+ }
+ }
- bond_alb_deinitialize(bond);
+ if (ioctl) {
+ strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
+ etool.cmd = ETHTOOL_GLINK;
+ ifr.ifr_data = (char*)&etool;
+ if (IOCTL(slave_dev, &ifr, SIOCETHTOOL) == 0) {
+ if (etool.data == 1) {
+ return BMSR_LSTATUS;
+ } else {
+ dprintk("SIOCETHTOOL shows link down\n");
+ return 0;
+ }
+ }
}
- return 0;
+ /*
+ * If reporting, report that either there's no dev->do_ioctl,
+ * or both SIOCGMIIREG and SIOCETHTOOL failed (meaning that we
+ * cannot report link status). If not reporting, pretend
+ * we're ok.
+ */
+ return (reporting ? -1 : BMSR_LSTATUS);
}
-/*
- * flush all members of flush->mc_list from device dev->mc_list
+/*----------------------------- Multicast list ------------------------------*/
+
+/*
+ * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise
*/
-static void bond_mc_list_flush(struct net_device *dev, struct net_device *flush)
-{
- struct dev_mc_list *dmi;
-
- for (dmi = flush->mc_list; dmi != NULL; dmi = dmi->next)
- dev_mc_delete(dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
+static inline int bond_is_dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2)
+{
+ return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 &&
+ dmi1->dmi_addrlen == dmi2->dmi_addrlen;
+}
- if (bond_mode == BOND_MODE_8023AD) {
- /* del lacpdu mc addr from mc list */
- u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
+/*
+ * returns dmi entry if found, NULL otherwise
+ */
+static struct dev_mc_list *bond_mc_list_find_dmi(struct dev_mc_list *dmi, struct dev_mc_list *mc_list)
+{
+ struct dev_mc_list *idmi;
- dev_mc_delete(dev, lacpdu_multicast, ETH_ALEN, 0);
+ for (idmi = mc_list; idmi; idmi = idmi->next) {
+ if (bond_is_dmi_same(dmi, idmi)) {
+ return idmi;
+ }
}
+
+ return NULL;
}
/*
- * Totally destroys the mc_list in bond
+ * Push the promiscuity flag down to appropriate slaves
*/
-static void bond_mc_list_destroy(struct bonding *bond)
+static void bond_set_promiscuity(struct bonding *bond, int inc)
{
- struct dev_mc_list *dmi;
+ if (USES_PRIMARY(bond->params.mode)) {
+ /* write lock already acquired */
+ if (bond->curr_active_slave) {
+ dev_set_promiscuity(bond->curr_active_slave->dev, inc);
+ }
+ } else {
+ struct slave *slave;
+ int i;
+ bond_for_each_slave(bond, slave, i) {
+ dev_set_promiscuity(slave->dev, inc);
+ }
+ }
+}
- dmi = bond->mc_list;
- while (dmi) {
- bond->mc_list = dmi->next;
- kfree(dmi);
- dmi = bond->mc_list;
+/*
+ * Push the allmulti flag down to all slaves
+ */
+static void bond_set_allmulti(struct bonding *bond, int inc)
+{
+ if (USES_PRIMARY(bond->params.mode)) {
+ /* write lock already acquired */
+ if (bond->curr_active_slave) {
+ dev_set_allmulti(bond->curr_active_slave->dev, inc);
+ }
+ } else {
+ struct slave *slave;
+ int i;
+ bond_for_each_slave(bond, slave, i) {
+ dev_set_allmulti(slave->dev, inc);
+ }
}
}
/*
- * Add a Multicast address to every slave in the bonding group
+ * Add a Multicast address to slaves
+ * according to mode
*/
-static void bond_mc_add(bonding_t *bond, void *addr, int alen)
-{
- slave_t *slave;
- switch (multicast_mode) {
- case BOND_MULTICAST_ACTIVE :
+static void bond_mc_add(struct bonding *bond, void *addr, int alen)
+{
+ if (USES_PRIMARY(bond->params.mode)) {
/* write lock already acquired */
- if (bond->current_slave != NULL)
- dev_mc_add(bond->current_slave->dev, addr, alen, 0);
- break;
- case BOND_MULTICAST_ALL :
- for (slave = bond->prev; slave != (slave_t*)bond; slave = slave->prev)
+ if (bond->curr_active_slave) {
+ dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0);
+ }
+ } else {
+ struct slave *slave;
+ int i;
+ bond_for_each_slave(bond, slave, i) {
dev_mc_add(slave->dev, addr, alen, 0);
- break;
- case BOND_MULTICAST_DISABLED :
- break;
+ }
}
-}
+}
/*
- * Remove a multicast address from every slave in the bonding group
+ * Remove a multicast address from slave
+ * according to mode
*/
-static void bond_mc_delete(bonding_t *bond, void *addr, int alen)
-{
- slave_t *slave;
- switch (multicast_mode) {
- case BOND_MULTICAST_ACTIVE :
+static void bond_mc_delete(struct bonding *bond, void *addr, int alen)
+{
+ if (USES_PRIMARY(bond->params.mode)) {
/* write lock already acquired */
- if (bond->current_slave != NULL)
- dev_mc_delete(bond->current_slave->dev, addr, alen, 0);
- break;
- case BOND_MULTICAST_ALL :
- for (slave = bond->prev; slave != (slave_t*)bond; slave = slave->prev)
+ if (bond->curr_active_slave) {
+ dev_mc_delete(bond->curr_active_slave->dev, addr, alen, 0);
+ }
+ } else {
+ struct slave *slave;
+ int i;
+ bond_for_each_slave(bond, slave, i) {
dev_mc_delete(slave->dev, addr, alen, 0);
- break;
- case BOND_MULTICAST_DISABLED :
- break;
+ }
+ }
+}
+
+/*
+ * Totally destroys the mc_list in bond
+ */
+static void bond_mc_list_destroy(struct bonding *bond)
+{
+ struct dev_mc_list *dmi;
+
+ dmi = bond->mc_list;
+ while (dmi) {
+ bond->mc_list = dmi->next;
+ kfree(dmi);
+ dmi = bond->mc_list;
}
-}
+}
/*
* Copy all the Multicast addresses from src to the bonding device dst
*/
-static int bond_mc_list_copy (struct dev_mc_list *src, struct bonding *dst,
- int gpf_flag)
+static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond, int gpf_flag)
{
struct dev_mc_list *dmi, *new_dmi;
- for (dmi = src; dmi != NULL; dmi = dmi->next) {
+ for (dmi = mc_list; dmi; dmi = dmi->next) {
new_dmi = kmalloc(sizeof(struct dev_mc_list), gpf_flag);
- if (new_dmi == NULL) {
- return -ENOMEM;
+ if (!new_dmi) {
+ /* FIXME: Potential memory leak !!! */
+ return -ENOMEM;
}
- new_dmi->next = dst->mc_list;
- dst->mc_list = new_dmi;
-
- new_dmi->dmi_addrlen = dmi->dmi_addrlen;
- memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen);
+ new_dmi->next = bond->mc_list;
+ bond->mc_list = new_dmi;
+ new_dmi->dmi_addrlen = dmi->dmi_addrlen;
+ memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen);
new_dmi->dmi_users = dmi->dmi_users;
- new_dmi->dmi_gusers = dmi->dmi_gusers;
- }
+ new_dmi->dmi_gusers = dmi->dmi_gusers;
+ }
+
return 0;
}
/*
- * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise
- */
-static inline int dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2)
-{
- return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 &&
- dmi1->dmi_addrlen == dmi2->dmi_addrlen;
-}
-
-/*
- * Push the promiscuity flag down to appropriate slaves
+ * flush all members of flush->mc_list from device dev->mc_list
*/
-static void bond_set_promiscuity(bonding_t *bond, int inc)
-{
- slave_t *slave;
-
- if (USES_PRIMARY(bond_mode)) {
- if (bond->current_slave) {
- dev_set_promiscuity(bond->current_slave->dev, inc);
- }
+static void bond_mc_list_flush(struct net_device *bond_dev, struct net_device *slave_dev)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct dev_mc_list *dmi;
- } else {
- for (slave = bond->prev; slave != (slave_t*)bond;
- slave = slave->prev) {
- dev_set_promiscuity(slave->dev, inc);
- }
+ for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
+ dev_mc_delete(slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
}
-}
-/*
- * Push the allmulti flag down to all slaves
- */
-static void bond_set_allmulti(bonding_t *bond, int inc)
-{
- slave_t *slave;
- switch (multicast_mode) {
- case BOND_MULTICAST_ACTIVE :
- /* write lock already acquired */
- if (bond->current_slave != NULL)
- dev_set_allmulti(bond->current_slave->dev, inc);
- break;
- case BOND_MULTICAST_ALL :
- for (slave = bond->prev; slave != (slave_t*)bond; slave = slave->prev)
- dev_set_allmulti(slave->dev, inc);
- break;
- case BOND_MULTICAST_DISABLED :
- break;
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ /* del lacpdu mc addr from mc list */
+ u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
+
+ dev_mc_delete(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
}
-}
+}
+
+/*--------------------------- Active slave change ---------------------------*/
-/*
- * returns dmi entry if found, NULL otherwise
+/*
+ * Update the mc list and multicast-related flags for the new and
+ * old active slaves (if any) according to the multicast mode, and
+ * promiscuous flags unconditionally.
*/
-static struct dev_mc_list* bond_mc_list_find_dmi(struct dev_mc_list *dmi,
- struct dev_mc_list *mc_list)
-{
- struct dev_mc_list *idmi;
+static void bond_mc_swap(struct bonding *bond, struct slave *new_active, struct slave *old_active)
+{
+ struct dev_mc_list *dmi;
+
+ if (!USES_PRIMARY(bond->params.mode)) {
+ /* nothing to do - mc list is already up-to-date on
+ * all slaves
+ */
+ return;
+ }
+
+ if (old_active) {
+ if (bond->dev->flags & IFF_PROMISC) {
+ dev_set_promiscuity(old_active->dev, -1);
+ }
- for (idmi = mc_list; idmi != NULL; idmi = idmi->next) {
- if (dmi_same(dmi, idmi)) {
- return idmi;
+ if (bond->dev->flags & IFF_ALLMULTI) {
+ dev_set_allmulti(old_active->dev, -1);
+ }
+
+ for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
+ dev_mc_delete(old_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
}
}
- return NULL;
-}
-static void set_multicast_list(struct net_device *master)
+ if (new_active) {
+ if (bond->dev->flags & IFF_PROMISC) {
+ dev_set_promiscuity(new_active->dev, 1);
+ }
+
+ if (bond->dev->flags & IFF_ALLMULTI) {
+ dev_set_allmulti(new_active->dev, 1);
+ }
+
+ for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
+ dev_mc_add(new_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
+ }
+ }
+}
+
+/**
+ * find_best_interface - select the best available slave to be the active one
+ * @bond: our bonding struct
+ *
+ * Warning: Caller must hold curr_slave_lock for writing.
+ */
+static struct slave *bond_find_best_slave(struct bonding *bond)
{
- bonding_t *bond = master->priv;
- struct dev_mc_list *dmi;
+ struct slave *new_active, *old_active;
+ struct slave *bestslave = NULL;
+ int mintime = bond->params.updelay;
+ int i;
- write_lock_bh(&bond->lock);
+ new_active = old_active = bond->curr_active_slave;
- /*
- * Do promisc before checking multicast_mode
+ if (!new_active) { /* there were no active slaves left */
+ if (bond->slave_cnt > 0) { /* found one slave */
+ new_active = bond->first_slave;
+ } else {
+ return NULL; /* still no slave, return NULL */
+ }
+ }
+
+ /* first try the primary link; if arping, a link must tx/rx traffic
+ * before it can be considered the curr_active_slave - also, we would skip
+ * slaves between the curr_active_slave and primary_slave that may be up
+ * and able to arp
*/
- if ( (master->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC) )
- bond_set_promiscuity(bond, 1);
+ if ((bond->primary_slave) &&
+ (!bond->params.arp_interval) &&
+ (IS_UP(bond->primary_slave->dev))) {
+ new_active = bond->primary_slave;
+ }
- if ( !(master->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC) )
- bond_set_promiscuity(bond, -1);
+ /* remember where to stop iterating over the slaves */
+ old_active = new_active;
- if (multicast_mode == BOND_MULTICAST_DISABLED) {
- bond->flags = master->flags;
- write_unlock_bh(&bond->lock);
+ bond_for_each_slave_from(bond, new_active, i, old_active) {
+ if (IS_UP(new_active->dev)) {
+ if (new_active->link == BOND_LINK_UP) {
+ return new_active;
+ } else if (new_active->link == BOND_LINK_BACK) {
+ /* link up, but waiting for stabilization */
+ if (new_active->delay < mintime) {
+ mintime = new_active->delay;
+ bestslave = new_active;
+ }
+ }
+ }
+ }
+
+ return bestslave;
+}
+
+/**
+ * change_active_interface - change the active slave into the specified one
+ * @bond: our bonding struct
+ * @new: the new slave to make the active one
+ *
+ * Set the new slave to the bond's settings and unset them on the old
+ * curr_active_slave.
+ * Setting include flags, mc-list, promiscuity, allmulti, etc.
+ *
+ * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
+ * because it is apparently the best available slave we have, even though its
+ * updelay hasn't timed out yet.
+ *
+ * Warning: Caller must hold curr_slave_lock for writing.
+ */
+static void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
+{
+ struct slave *old_active = bond->curr_active_slave;
+
+ if (old_active == new_active) {
return;
}
- /* set allmulti flag to slaves */
- if ( (master->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI) )
- bond_set_allmulti(bond, 1);
+ if (new_active) {
+ if (new_active->link == BOND_LINK_BACK) {
+ if (USES_PRIMARY(bond->params.mode)) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: making interface %s the new "
+ "active one %d ms earlier.\n",
+ bond->dev->name, new_active->dev->name,
+ (bond->params.updelay - new_active->delay) * bond->params.miimon);
+ }
+
+ new_active->delay = 0;
+ new_active->link = BOND_LINK_UP;
+ new_active->jiffies = jiffies;
- if ( !(master->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI) )
- bond_set_allmulti(bond, -1);
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ bond_3ad_handle_link_change(new_active, BOND_LINK_UP);
+ }
- bond->flags = master->flags;
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
+ }
+ } else {
+ if (USES_PRIMARY(bond->params.mode)) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: making interface %s the new "
+ "active one.\n",
+ bond->dev->name, new_active->dev->name);
+ }
+ }
+ }
- /* looking for addresses to add to slaves' mc list */
- for (dmi = master->mc_list; dmi != NULL; dmi = dmi->next) {
- if (bond_mc_list_find_dmi(dmi, bond->mc_list) == NULL)
- bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
- }
+ if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
+ if (old_active) {
+ bond_set_slave_inactive_flags(old_active);
+ }
- /* looking for addresses to delete from slaves' list */
- for (dmi = bond->mc_list; dmi != NULL; dmi = dmi->next) {
- if (bond_mc_list_find_dmi(dmi, master->mc_list) == NULL)
- bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
+ if (new_active) {
+ bond_set_slave_active_flags(new_active);
+ }
}
+ if (USES_PRIMARY(bond->params.mode)) {
+ bond_mc_swap(bond, new_active, old_active);
+ }
- /* save master's multicast list */
- bond_mc_list_destroy (bond);
- bond_mc_list_copy (master->mc_list, bond, GFP_ATOMIC);
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ bond_alb_handle_active_change(bond, new_active);
+ } else {
+ bond->curr_active_slave = new_active;
+ }
+}
- write_unlock_bh(&bond->lock);
+/**
+ * bond_select_active_slave - select a new active slave, if needed
+ * @bond: our bonding struct
+ *
+ * This functions shoud be called when one of the following occurs:
+ * - The old curr_active_slave has been released or lost its link.
+ * - The primary_slave has got its link back.
+ * - A slave has got its link back and there's no old curr_active_slave.
+ *
+ * Warning: Caller must hold curr_slave_lock for writing.
+ */
+static void bond_select_active_slave(struct bonding *bond)
+{
+ struct slave *best_slave;
+
+ best_slave = bond_find_best_slave(bond);
+ if (best_slave != bond->curr_active_slave) {
+ bond_change_active_slave(bond, best_slave);
+ }
}
+/*--------------------------- slave list handling ---------------------------*/
+
/*
- * Update the mc list and multicast-related flags for the new and
- * old active slaves (if any) according to the multicast mode, and
- * promiscuous flags unconditionally.
+ * This function attaches the slave to the end of list.
+ *
+ * bond->lock held for writing by caller.
*/
-static void bond_mc_update(bonding_t *bond, slave_t *new, slave_t *old)
+static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
{
- struct dev_mc_list *dmi;
+ if (bond->first_slave == NULL) { /* attaching the first slave */
+ new_slave->next = new_slave;
+ new_slave->prev = new_slave;
+ bond->first_slave = new_slave;
+ } else {
+ new_slave->next = bond->first_slave;
+ new_slave->prev = bond->first_slave->prev;
+ new_slave->next->prev = new_slave;
+ new_slave->prev->next = new_slave;
+ }
- if (USES_PRIMARY(bond_mode)) {
- if (bond->device->flags & IFF_PROMISC) {
- if (old)
- dev_set_promiscuity(old->dev, -1);
- if (new)
- dev_set_promiscuity(new->dev, 1);
- }
+ bond->slave_cnt++;
+}
+
+/*
+ * This function detaches the slave from the list.
+ * WARNING: no check is made to verify if the slave effectively
+ * belongs to <bond>.
+ * Nothing is freed on return, structures are just unchained.
+ * If any slave pointer in bond was pointing to <slave>,
+ * it should be changed by the calling function.
+ *
+ * bond->lock held for writing by caller.
+ */
+static void bond_detach_slave(struct bonding *bond, struct slave *slave)
+{
+ if (slave->next) {
+ slave->next->prev = slave->prev;
}
- switch(multicast_mode) {
- case BOND_MULTICAST_ACTIVE :
- if (bond->device->flags & IFF_ALLMULTI) {
- if (old)
- dev_set_allmulti(old->dev, -1);
- if (new)
- dev_set_allmulti(new->dev, 1);
- }
- /* first remove all mc addresses from old slave if any,
- and _then_ add them to new active slave */
- if (old) {
- for (dmi = bond->device->mc_list; dmi != NULL; dmi = dmi->next)
- dev_mc_delete(old->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
- }
- if (new) {
- for (dmi = bond->device->mc_list; dmi != NULL; dmi = dmi->next)
- dev_mc_add(new->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
+ if (slave->prev) {
+ slave->prev->next = slave->next;
+ }
+
+ if (bond->first_slave == slave) { /* slave is the first slave */
+ if (bond->slave_cnt > 1) { /* there are more slave */
+ bond->first_slave = slave->next;
+ } else {
+ bond->first_slave = NULL; /* slave was the last one */
}
- break;
- case BOND_MULTICAST_ALL :
- /* nothing to do: mc list is already up-to-date on all slaves */
- break;
- case BOND_MULTICAST_DISABLED :
- break;
}
+
+ slave->next = NULL;
+ slave->prev = NULL;
+ bond->slave_cnt--;
+}
+
+/*---------------------------------- IOCTL ----------------------------------*/
+
+static int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev)
+{
+ dprintk("bond_dev=%p\n", bond_dev);
+ dprintk("slave_dev=%p\n", slave_dev);
+ dprintk("slave_dev->addr_len=%d\n", slave_dev->addr_len);
+ memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
+ return 0;
}
/* enslave device <slave> to bond device <master> */
-static int bond_enslave(struct net_device *master_dev,
- struct net_device *slave_dev)
+static int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
{
- bonding_t *bond = NULL;
- slave_t *new_slave = NULL;
- unsigned long rflags = 0;
- int err = 0;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *new_slave = NULL;
struct dev_mc_list *dmi;
- struct in_ifaddr **ifap;
- struct in_ifaddr *ifa;
- int link_reporting;
struct sockaddr addr;
-
- if (master_dev == NULL || slave_dev == NULL) {
- return -ENODEV;
- }
- bond = (struct bonding *) master_dev->priv;
+ int link_reporting;
+ int old_features = bond_dev->features;
+ int res = 0;
if (slave_dev->do_ioctl == NULL) {
- printk(KERN_DEBUG
- "Warning : no link monitoring support for %s\n",
- slave_dev->name);
+ printk(KERN_WARNING DRV_NAME
+ ": Warning : no link monitoring support for %s\n",
+ slave_dev->name);
}
-
/* bond must be initialized by bond_open() before enslaving */
- if (!(master_dev->flags & IFF_UP)) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error, master_dev is not up\n");
-#endif
+ if (!(bond_dev->flags & IFF_UP)) {
+ dprintk("Error, master_dev is not up\n");
return -EPERM;
}
/* already enslaved */
- if (master_dev->flags & IFF_SLAVE || slave_dev->flags & IFF_SLAVE) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error, Device was already enslaved\n");
-#endif
+ if (slave_dev->flags & IFF_SLAVE) {
+ dprintk("Error, Device was already enslaved\n");
return -EBUSY;
}
+ /* vlan challenged mutual exclusion */
+ /* no need to lock since we're protected by rtnl_lock */
+ if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
+ dprintk("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
+ if (!list_empty(&bond->vlan_list)) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: cannot enslave VLAN "
+ "challenged slave %s on VLAN enabled "
+ "bond %s\n", slave_dev->name,
+ bond_dev->name);
+ return -EPERM;
+ } else {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: enslaved VLAN challenged "
+ "slave %s. Adding VLANs will be blocked as "
+ "long as %s is part of bond %s\n",
+ slave_dev->name, slave_dev->name,
+ bond_dev->name);
+ bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
+ }
+ } else {
+ dprintk("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
+ if (bond->slave_cnt == 0) {
+ /* First slave, and it is not VLAN challenged,
+ * so remove the block of adding VLANs over the bond.
+ */
+ bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
+ }
+ }
+
if (app_abi_ver >= 1) {
/* The application is using an ABI, which requires the
* slave interface to be closed.
*/
if ((slave_dev->flags & IFF_UP)) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error, slave_dev is up\n");
-#endif
- return -EPERM;
+ printk(KERN_ERR DRV_NAME
+ ": Error: %s is up\n",
+ slave_dev->name);
+ res = -EPERM;
+ goto err_undo_flags;
}
if (slave_dev->set_mac_address == NULL) {
- printk(KERN_CRIT
- "The slave device you specified does not support"
- " setting the MAC address.\n");
- printk(KERN_CRIT
- "Your kernel likely does not support slave"
- " devices.\n");
+ printk(KERN_ERR DRV_NAME
+ ": Error: The slave device you specified does "
+ "not support setting the MAC address.\n");
+ printk(KERN_ERR
+ "Your kernel likely does not support slave "
+ "devices.\n");
- return -EOPNOTSUPP;
+ res = -EOPNOTSUPP;
+ goto err_undo_flags;
}
} else {
/* The application is not using an ABI, which requires the
* slave interface to be open.
*/
if (!(slave_dev->flags & IFF_UP)) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error, slave_dev is not running\n");
-#endif
- return -EINVAL;
+ printk(KERN_ERR DRV_NAME
+ ": Error: %s is not running\n",
+ slave_dev->name);
+ res = -EINVAL;
+ goto err_undo_flags;
}
- if ((bond_mode == BOND_MODE_8023AD) ||
- (bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- printk(KERN_ERR
- "bonding: Error: to use %s mode, you must "
- "upgrade ifenslave.\n", bond_mode_name());
- return -EOPNOTSUPP;
+ if ((bond->params.mode == BOND_MODE_8023AD) ||
+ (bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: to use %s mode, you must upgrade "
+ "ifenslave.\n",
+ bond_mode_name(bond->params.mode));
+ res = -EOPNOTSUPP;
+ goto err_undo_flags;
}
}
- if ((new_slave = kmalloc(sizeof(slave_t), GFP_KERNEL)) == NULL) {
- return -ENOMEM;
+ new_slave = kmalloc(sizeof(struct slave), GFP_KERNEL);
+ if (!new_slave) {
+ res = -ENOMEM;
+ goto err_undo_flags;
}
- memset(new_slave, 0, sizeof(slave_t));
+
+ memset(new_slave, 0, sizeof(struct slave));
/* save slave's original flags before calling
* netdev_set_master and dev_open
@@ -1431,37 +1706,29 @@
*/
memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
- if (bond->slave_cnt > 0) {
- /* set slave to master's mac address
- * The application already set the master's
- * mac address to that of the first slave
- */
- memcpy(addr.sa_data, master_dev->dev_addr, master_dev->addr_len);
- addr.sa_family = slave_dev->type;
- err = slave_dev->set_mac_address(slave_dev, &addr);
- if (err) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error %d calling set_mac_address\n", err);
-#endif
- goto err_free;
- }
+ /* set slave to master's mac address
+ * The application already set the master's
+ * mac address to that of the first slave
+ */
+ memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
+ addr.sa_family = slave_dev->type;
+ res = slave_dev->set_mac_address(slave_dev, &addr);
+ if (res) {
+ dprintk("Error %d calling set_mac_address\n", res);
+ goto err_free;
}
/* open the slave since the application closed it */
- err = dev_open(slave_dev);
- if (err) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Openning slave %s failed\n", slave_dev->name);
-#endif
+ res = dev_open(slave_dev);
+ if (res) {
+ dprintk("Openning slave %s failed\n", slave_dev->name);
goto err_restore_mac;
}
}
- err = netdev_set_master(slave_dev, master_dev);
- if (err) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Error %d calling netdev_set_master\n", err);
-#endif
+ res = netdev_set_master(slave_dev, bond_dev);
+ if (res) {
+ dprintk("Error %d calling netdev_set_master\n", res);
if (app_abi_ver < 1) {
goto err_free;
} else {
@@ -1471,56 +1738,59 @@
new_slave->dev = slave_dev;
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
/* bond_alb_init_slave() must be called before all other stages since
* it might fail and we do not want to have to undo everything
*/
- err = bond_alb_init_slave(bond, new_slave);
- if (err) {
+ res = bond_alb_init_slave(bond, new_slave);
+ if (res) {
goto err_unset_master;
}
}
- /* set promiscuity level to new slave */
- if (master_dev->flags & IFF_PROMISC) {
- /* If the mode USES_PRIMARY, then the new slave gets the
- * master's promisc (and mc) settings only if it becomes the
- * current_slave, and that is taken care of later when calling
- * bond_change_active()
- */
- if (!USES_PRIMARY(bond_mode)) {
- dev_set_promiscuity(slave_dev, 1);
+ /* If the mode USES_PRIMARY, then the new slave gets the
+ * master's promisc (and mc) settings only if it becomes the
+ * curr_active_slave, and that is taken care of later when calling
+ * bond_change_active()
+ */
+ if (!USES_PRIMARY(bond->params.mode)) {
+ /* set promiscuity level to new slave */
+ if (bond_dev->flags & IFF_PROMISC) {
+ dev_set_promiscuity(slave_dev, 1);
}
- }
-
- if (multicast_mode == BOND_MULTICAST_ALL) {
+
/* set allmulti level to new slave */
- if (master_dev->flags & IFF_ALLMULTI)
- dev_set_allmulti(slave_dev, 1);
-
- /* upload master's mc_list to new slave */
- for (dmi = master_dev->mc_list; dmi != NULL; dmi = dmi->next)
+ if (bond_dev->flags & IFF_ALLMULTI) {
+ dev_set_allmulti(slave_dev, 1);
+ }
+
+ /* upload master's mc_list to new slave */
+ for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
dev_mc_add (slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
+ }
}
- if (bond_mode == BOND_MODE_8023AD) {
+ if (bond->params.mode == BOND_MODE_8023AD) {
/* add lacpdu mc addr to mc list */
u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
dev_mc_add(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
}
+ bond_add_vlans_on_slave(bond, slave_dev);
+
write_lock_bh(&bond->lock);
-
+
bond_attach_slave(bond, new_slave);
+
new_slave->delay = 0;
new_slave->link_failure_count = 0;
- if (miimon > 0 && !use_carrier) {
- link_reporting = bond_check_dev_link(slave_dev, 1);
+ if (bond->params.miimon && !bond->params.use_carrier) {
+ link_reporting = bond_check_dev_link(bond, slave_dev, 1);
- if ((link_reporting == -1) && (arp_interval == 0)) {
+ if ((link_reporting == -1) && !bond->params.arp_interval) {
/*
* miimon is set but a bonded network driver
* does not support ETHTOOL/MII and
@@ -1529,157 +1799,136 @@
* here (because netif_carrier is always
* supported); thus, we don't need to change
* the messages for netif_carrier.
- */
- printk(KERN_ERR
- "bond_enslave(): MII and ETHTOOL support not "
- "available for interface %s, and "
- "arp_interval/arp_ip_target module parameters "
- "not specified, thus bonding will not detect "
- "link failures! see bonding.txt for details.\n",
- slave_dev->name);
+ */
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: MII and ETHTOOL support not "
+ "available for interface %s, and "
+ "arp_interval/arp_ip_target module parameters "
+ "not specified, thus bonding will not detect "
+ "link failures! see bonding.txt for details.\n",
+ slave_dev->name);
} else if (link_reporting == -1) {
- /* unable get link status using mii/ethtool */
- printk(KERN_WARNING
- "bond_enslave: can't get link status from "
+ /* unable get link status using mii/ethtool */
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: can't get link status from "
"interface %s; the network driver associated "
- "with this interface does not support "
- "MII or ETHTOOL link status reporting, thus "
- "miimon has no effect on this interface.\n",
+ "with this interface does not support MII or "
+ "ETHTOOL link status reporting, thus miimon "
+ "has no effect on this interface.\n",
slave_dev->name);
}
}
/* check for initial state */
- if ((miimon <= 0) ||
- (bond_check_dev_link(slave_dev, 0) == BMSR_LSTATUS)) {
- if (updelay) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Initial state of slave_dev is "
- "BOND_LINK_BACK\n");
-#endif
+ if (!bond->params.miimon ||
+ (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) {
+ if (bond->params.updelay) {
+ dprintk("Initial state of slave_dev is "
+ "BOND_LINK_BACK\n");
new_slave->link = BOND_LINK_BACK;
- new_slave->delay = updelay;
- }
- else {
-#ifdef BONDING_DEBUG
- printk(KERN_DEBUG "Initial state of slave_dev is "
+ new_slave->delay = bond->params.updelay;
+ } else {
+ dprintk("Initial state of slave_dev is "
"BOND_LINK_UP\n");
-#endif
new_slave->link = BOND_LINK_UP;
}
new_slave->jiffies = jiffies;
- }
- else {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "Initial state of slave_dev is "
+ } else {
+ dprintk("Initial state of slave_dev is "
"BOND_LINK_DOWN\n");
-#endif
new_slave->link = BOND_LINK_DOWN;
}
if (bond_update_speed_duplex(new_slave) &&
(new_slave->link != BOND_LINK_DOWN)) {
-
- printk(KERN_WARNING
- "bond_enslave(): failed to get speed/duplex from %s, "
- "speed forced to 100Mbps, duplex forced to Full.\n",
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: failed to get speed/duplex from %s, speed "
+ "forced to 100Mbps, duplex forced to Full.\n",
new_slave->dev->name);
- if (bond_mode == BOND_MODE_8023AD) {
+
+ if (bond->params.mode == BOND_MODE_8023AD) {
printk(KERN_WARNING
- "Operation of 802.3ad mode requires ETHTOOL support "
- "in base driver for proper aggregator selection.\n");
+ "Operation of 802.3ad mode requires ETHTOOL "
+ "support in base driver for proper aggregator "
+ "selection.\n");
}
}
- /* if we're in active-backup mode, we need one and only one active
- * interface. The backup interfaces will have their NOARP flag set
- * because we need them to be completely deaf and not to respond to
- * any ARP request on the network to avoid fooling a switch. Thus,
- * since we guarantee that current_slave always point to the last
- * usable interface, we just have to verify this interface's flag.
- */
- if (bond_mode == BOND_MODE_ACTIVEBACKUP) {
- if (((bond->current_slave == NULL)
- || (bond->current_slave->dev->flags & IFF_NOARP))
- && (new_slave->link != BOND_LINK_DOWN)) {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "This is the first active slave\n");
-#endif
+ if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
+ /* if there is a primary slave, remember it */
+ if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
+ bond->primary_slave = new_slave;
+ }
+ }
+
+ switch (bond->params.mode) {
+ case BOND_MODE_ACTIVEBACKUP:
+ /* if we're in active-backup mode, we need one and only one active
+ * interface. The backup interfaces will have their NOARP flag set
+ * because we need them to be completely deaf and not to respond to
+ * any ARP request on the network to avoid fooling a switch. Thus,
+ * since we guarantee that curr_active_slave always point to the last
+ * usable interface, we just have to verify this interface's flag.
+ */
+ if (((!bond->curr_active_slave) ||
+ (bond->curr_active_slave->dev->flags & IFF_NOARP)) &&
+ (new_slave->link != BOND_LINK_DOWN)) {
+ dprintk("This is the first active slave\n");
/* first slave or no active slave yet, and this link
is OK, so make this interface the active one */
- change_active_interface(bond, new_slave);
- }
- else {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "This is just a backup slave\n");
-#endif
+ bond_change_active_slave(bond, new_slave);
+ } else {
+ dprintk("This is just a backup slave\n");
bond_set_slave_inactive_flags(new_slave);
}
- if (((struct in_device *)slave_dev->ip_ptr) != NULL) {
- read_lock_irqsave(&(((struct in_device *)slave_dev->ip_ptr)->lock), rflags);
- ifap= &(((struct in_device *)slave_dev->ip_ptr)->ifa_list);
- ifa = *ifap;
- if (ifa != NULL)
- my_ip = ifa->ifa_address;
- read_unlock_irqrestore(&(((struct in_device *)slave_dev->ip_ptr)->lock), rflags);
- }
-
- /* if there is a primary slave, remember it */
- if (primary != NULL) {
- if (strcmp(primary, new_slave->dev->name) == 0) {
- bond->primary_slave = new_slave;
- }
- }
- } else if (bond_mode == BOND_MODE_8023AD) {
+ break;
+ case BOND_MODE_8023AD:
/* in 802.3ad mode, the internal mechanism
* will activate the slaves in the selected
* aggregator
*/
bond_set_slave_inactive_flags(new_slave);
/* if this is the first slave */
- if (new_slave == bond->next) {
+ if (bond->slave_cnt == 1) {
SLAVE_AD_INFO(new_slave).id = 1;
/* Initialize AD with the number of times that the AD timer is called in 1 second
* can be called only after the mac address of the bond is set
*/
bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL,
- lacp_fast);
+ bond->params.lacp_fast);
} else {
SLAVE_AD_INFO(new_slave).id =
- SLAVE_AD_INFO(new_slave->prev).id + 1;
+ SLAVE_AD_INFO(new_slave->prev).id + 1;
}
bond_3ad_bind_slave(new_slave);
- } else if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
+ break;
+ case BOND_MODE_TLB:
+ case BOND_MODE_ALB:
new_slave->state = BOND_STATE_ACTIVE;
- if ((bond->current_slave == NULL) && (new_slave->link != BOND_LINK_DOWN)) {
+ if ((!bond->curr_active_slave) &&
+ (new_slave->link != BOND_LINK_DOWN)) {
/* first slave or no active slave yet, and this link
* is OK, so make this interface the active one
*/
- change_active_interface(bond, new_slave);
+ bond_change_active_slave(bond, new_slave);
}
+ break;
+ default:
+ dprintk("This slave is always active in trunk mode\n");
- /* if there is a primary slave, remember it */
- if (primary != NULL) {
- if (strcmp(primary, new_slave->dev->name) == 0) {
- bond->primary_slave = new_slave;
- }
- }
- } else {
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "This slave is always active in trunk mode\n");
-#endif
/* always active in trunk mode */
new_slave->state = BOND_STATE_ACTIVE;
- /* In trunking mode there is little meaning to current_slave
+ /* In trunking mode there is little meaning to curr_active_slave
* anyway (it holds no special properties of the bond device),
* so we can change it without calling change_active_interface()
*/
- if (bond->current_slave == NULL)
- bond->current_slave = new_slave;
- }
+ if (!bond->curr_active_slave) {
+ bond->curr_active_slave = new_slave;
+ }
+ break;
+ } /* switch(bond_mode) */
write_unlock_bh(&bond->lock);
@@ -1693,38 +1942,34 @@
*/
int ndx = 0;
- for (ndx = 0; ndx < slave_dev->addr_len; ndx++) {
-#ifdef BONDING_DEBUG
- printk(KERN_DEBUG
- "Checking ndx=%d of master_dev->dev_addr\n", ndx);
-#endif
- if (master_dev->dev_addr[ndx] != 0) {
-#ifdef BONDING_DEBUG
- printk(KERN_DEBUG
- "Found non-zero byte at ndx=%d\n", ndx);
-#endif
+ for (ndx = 0; ndx < bond_dev->addr_len; ndx++) {
+ dprintk("Checking ndx=%d of bond_dev->dev_addr\n",
+ ndx);
+ if (bond_dev->dev_addr[ndx] != 0) {
+ dprintk("Found non-zero byte at ndx=%d\n",
+ ndx);
break;
}
}
- if (ndx == slave_dev->addr_len) {
+
+ if (ndx == bond_dev->addr_len) {
/*
* We got all the way through the address and it was
* all 0's.
*/
-#ifdef BONDING_DEBUG
- printk(KERN_DEBUG "%s doesn't have a MAC address yet. ",
- master_dev->name);
- printk(KERN_DEBUG "Going to give assign it from %s.\n",
- slave_dev->name);
-#endif
- bond_sethwaddr(master_dev, slave_dev);
+ dprintk("%s doesn't have a MAC address yet. \n",
+ bond_dev->name);
+ dprintk("Going to give assign it from %s.\n",
+ slave_dev->name);
+ bond_sethwaddr(bond_dev, slave_dev);
}
}
- printk (KERN_INFO "%s: enslaving %s as a%s interface with a%s link.\n",
- master_dev->name, slave_dev->name,
- new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
- new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
+ printk(KERN_INFO DRV_NAME
+ ": %s: enslaving %s as a%s interface with a%s link.\n",
+ bond_dev->name, slave_dev->name,
+ new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
+ new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
/* enslave is successful */
return 0;
@@ -1743,435 +1988,235 @@
err_free:
kfree(new_slave);
- return err;
+
+err_undo_flags:
+ bond_dev->features = old_features;
+
+ return res;
}
-/*
- * This function changes the active slave to slave <slave_dev>.
- * It returns -EINVAL in the following cases.
- * - <slave_dev> is not found in the list.
- * - There is not active slave now.
- * - <slave_dev> is already active.
- * - The link state of <slave_dev> is not BOND_LINK_UP.
- * - <slave_dev> is not running.
- * In these cases, this fuction does nothing.
- * In the other cases, currnt_slave pointer is changed and 0 is returned.
+/*
+ * Try to release the slave device <slave> from the bond device <master>
+ * It is legal to access curr_active_slave without a lock because all the function
+ * is write-locked.
+ *
+ * The rules for slave state should be:
+ * for Active/Backup:
+ * Active stays on all backups go down
+ * for Bonded connections:
+ * The first up interface should be left on and all others downed.
*/
-static int bond_change_active(struct net_device *master_dev, struct net_device *slave_dev)
+static int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
{
- bonding_t *bond;
- slave_t *slave;
- slave_t *oldactive = NULL;
- slave_t *newactive = NULL;
- int ret = 0;
-
- if (master_dev == NULL || slave_dev == NULL) {
- return -ENODEV;
- }
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *oldcurrent;
+ struct sockaddr addr;
+ int mac_addr_differ;
- /* Verify that master_dev is indeed the master of slave_dev */
+ /* slave is not a slave or master is not master of this slave */
if (!(slave_dev->flags & IFF_SLAVE) ||
- (slave_dev->master != master_dev)) {
-
+ (slave_dev->master != bond_dev)) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: %s: cannot release %s.\n",
+ bond_dev->name, slave_dev->name);
return -EINVAL;
}
- bond = (struct bonding *) master_dev->priv;
write_lock_bh(&bond->lock);
- slave = (slave_t *)bond;
- oldactive = bond->current_slave;
-
- while ((slave = slave->prev) != (slave_t *)bond) {
- if(slave_dev == slave->dev) {
- newactive = slave;
- break;
- }
- }
- /*
- * Changing to the current active: do nothing; return success.
- */
- if (newactive && (newactive == oldactive)) {
- write_unlock_bh(&bond->lock);
- return 0;
+ slave = bond_get_slave_by_dev(bond, slave_dev);
+ if (!slave) {
+ /* not a slave of this bond */
+ printk(KERN_INFO DRV_NAME
+ ": %s: %s not enslaved\n",
+ bond_dev->name, slave_dev->name);
+ return -EINVAL;
}
- if ((newactive != NULL)&&
- (oldactive != NULL)&&
- (newactive->link == BOND_LINK_UP)&&
- IS_UP(newactive->dev)) {
- change_active_interface(bond, newactive);
- } else {
- ret = -EINVAL;
+ mac_addr_differ = memcmp(bond_dev->dev_addr,
+ slave->perm_hwaddr,
+ ETH_ALEN);
+ if (!mac_addr_differ && (bond->slave_cnt > 1)) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: the permanent HWaddr of %s "
+ "- %02X:%02X:%02X:%02X:%02X:%02X - is "
+ "still in use by %s. Set the HWaddr of "
+ "%s to a different address to avoid "
+ "conflicts.\n",
+ slave_dev->name,
+ slave->perm_hwaddr[0],
+ slave->perm_hwaddr[1],
+ slave->perm_hwaddr[2],
+ slave->perm_hwaddr[3],
+ slave->perm_hwaddr[4],
+ slave->perm_hwaddr[5],
+ bond_dev->name,
+ slave_dev->name);
+ }
+
+ /* Inform AD package of unbinding of slave. */
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ /* must be called before the slave is
+ * detached from the list
+ */
+ bond_3ad_unbind_slave(slave);
}
- write_unlock_bh(&bond->lock);
- return ret;
-}
-/**
- * find_best_interface - select the best available slave to be the active one
- * @bond: our bonding struct
- *
- * Warning: Caller must hold ptrlock for writing.
- */
-static struct slave *find_best_interface(struct bonding *bond)
-{
- struct slave *newslave, *oldslave;
- struct slave *bestslave = NULL;
- int mintime;
+ printk(KERN_INFO DRV_NAME
+ ": %s: releasing %s interface %s\n",
+ bond_dev->name,
+ (slave->state == BOND_STATE_ACTIVE)
+ ? "active" : "backup",
+ slave_dev->name);
- newslave = oldslave = bond->current_slave;
+ oldcurrent = bond->curr_active_slave;
- if (newslave == NULL) { /* there were no active slaves left */
- if (bond->next != (slave_t *)bond) { /* found one slave */
- newslave = bond->next;
- } else {
- return NULL; /* still no slave, return NULL */
- }
- }
+ bond->current_arp_slave = NULL;
- mintime = updelay;
+ /* release the slave from its bond */
+ bond_detach_slave(bond, slave);
- /* first try the primary link; if arping, a link must tx/rx traffic
- * before it can be considered the current_slave - also, we would skip
- * slaves between the current_slave and primary_slave that may be up
- * and able to arp
- */
- if ((bond->primary_slave != NULL) && (arp_interval == 0)) {
- if (IS_UP(bond->primary_slave->dev))
- newslave = bond->primary_slave;
+ if (bond->primary_slave == slave) {
+ bond->primary_slave = NULL;
}
- /* remember where to stop iterating over the slaves */
- oldslave = newslave;
-
- do {
- if (IS_UP(newslave->dev)) {
- if (newslave->link == BOND_LINK_UP) {
- return newslave;
- }
- else if (newslave->link == BOND_LINK_BACK) {
- /* link up, but waiting for stabilization */
- if (newslave->delay < mintime) {
- mintime = newslave->delay;
- bestslave = newslave;
- }
- }
- }
- } while ((newslave = newslave->next) != oldslave);
-
- return bestslave;
-}
-
-/**
- * change_active_interface - change the active slave into the specified one
- * @bond: our bonding struct
- * @new: the new slave to make the active one
- *
- * Set the new slave to the bond's settings and unset them on the old
- * current_slave.
- * Setting include flags, mc-list, promiscuity, allmulti, etc.
- *
- * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
- * because it is apparently the best available slave we have, even though its
- * updelay hasn't timed out yet.
- *
- * Warning: Caller must hold ptrlock for writing.
- */
-static void change_active_interface(struct bonding *bond, struct slave *new)
-{
- struct slave *old = bond->current_slave;
-
- if (old == new) {
- return;
+ if (oldcurrent == slave) {
+ bond_change_active_slave(bond, NULL);
}
- if (new) {
- if (new->link == BOND_LINK_BACK) {
- if (USES_PRIMARY(bond_mode)) {
- printk (KERN_INFO
- "%s: making interface %s the new "
- "active one %d ms earlier.\n",
- bond->device->name, new->dev->name,
- (updelay - new->delay) * miimon);
- }
-
- new->delay = 0;
- new->link = BOND_LINK_UP;
- new->jiffies = jiffies;
-
- if (bond_mode == BOND_MODE_8023AD) {
- bond_3ad_handle_link_change(new, BOND_LINK_UP);
- }
-
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- bond_alb_handle_link_change(bond, new, BOND_LINK_UP);
- }
- } else {
- if (USES_PRIMARY(bond_mode)) {
- printk (KERN_INFO
- "%s: making interface %s the new active one.\n",
- bond->device->name, new->dev->name);
- }
- }
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ /* Must be called only after the slave has been
+ * detached from the list and the curr_active_slave
+ * has been cleared (if our_slave == old_current),
+ * but before a new active slave is selected.
+ */
+ bond_alb_deinit_slave(bond, slave);
}
- if (bond_mode == BOND_MODE_ACTIVEBACKUP) {
- if (old) {
- bond_set_slave_inactive_flags(old);
- }
+ if (oldcurrent == slave) {
+ bond_select_active_slave(bond);
- if (new) {
- bond_set_slave_active_flags(new);
+ if (!bond->curr_active_slave) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: now running without any active "
+ "interface !\n",
+ bond_dev->name);
}
}
- if (USES_PRIMARY(bond_mode)) {
- bond_mc_update(bond, new, old);
- }
-
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- bond_alb_assign_current_slave(bond, new);
- } else {
- bond->current_slave = new;
- }
-}
-
-/**
- * reselect_active_interface - select a new active slave, if needed
- * @bond: our bonding struct
- *
- * This functions shoud be called when one of the following occurs:
- * - The old current_slave has been released or lost its link.
- * - The primary_slave has got its link back.
- * - A slave has got its link back and there's no old current_slave.
- *
- * Warning: Caller must hold ptrlock for writing.
- */
-static void reselect_active_interface(struct bonding *bond)
-{
- struct slave *best_slave;
-
- best_slave = find_best_interface(bond);
-
- if (best_slave != bond->current_slave) {
- change_active_interface(bond, best_slave);
- }
-}
-
-/*
- * Try to release the slave device <slave> from the bond device <master>
- * It is legal to access current_slave without a lock because all the function
- * is write-locked.
- *
- * The rules for slave state should be:
- * for Active/Backup:
- * Active stays on all backups go down
- * for Bonded connections:
- * The first up interface should be left on and all others downed.
- */
-static int bond_release(struct net_device *master, struct net_device *slave)
-{
- bonding_t *bond;
- slave_t *our_slave, *old_current;
- struct sockaddr addr;
-
- if (master == NULL || slave == NULL) {
- return -ENODEV;
- }
-
- bond = (struct bonding *) master->priv;
+ if (bond->slave_cnt == 0) {
+ /* if the last slave was removed, zero the mac address
+ * of the master so it will be set by the application
+ * to the mac address of the first slave
+ */
+ memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
- /* master already enslaved, or slave not enslaved,
- or no slave for this master */
- if ((master->flags & IFF_SLAVE) || !(slave->flags & IFF_SLAVE)) {
- printk (KERN_DEBUG "%s: cannot release %s.\n", master->name, slave->name);
- return -EINVAL;
+ if (list_empty(&bond->vlan_list)) {
+ bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
+ } else {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: clearing HW address of %s while it "
+ "still has VLANs.\n",
+ bond_dev->name);
+ printk(KERN_WARNING DRV_NAME
+ ": When re-adding slaves, make sure the bond's "
+ "HW address matches its VLANs'.\n");
+ }
+ } else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
+ !bond_has_challenged_slaves(bond)) {
+ printk(KERN_INFO DRV_NAME
+ ": last VLAN challenged slave %s "
+ "left bond %s. VLAN blocking is removed\n",
+ slave_dev->name, bond_dev->name);
+ bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
}
- write_lock_bh(&bond->lock);
- bond->current_arp_slave = NULL;
- our_slave = (slave_t *)bond;
- old_current = bond->current_slave;
- while ((our_slave = our_slave->prev) != (slave_t *)bond) {
- if (our_slave->dev == slave) {
- int mac_addr_differ = memcmp(bond->device->dev_addr,
- our_slave->perm_hwaddr,
- ETH_ALEN);
- if (!mac_addr_differ && (bond->slave_cnt > 1)) {
- printk(KERN_WARNING "WARNING: the permanent HWaddr of %s "
- "- %02X:%02X:%02X:%02X:%02X:%02X - "
- "is still in use by %s. Set the HWaddr "
- "of %s to a different address "
- "to avoid conflicts.\n",
- slave->name,
- our_slave->perm_hwaddr[0],
- our_slave->perm_hwaddr[1],
- our_slave->perm_hwaddr[2],
- our_slave->perm_hwaddr[3],
- our_slave->perm_hwaddr[4],
- our_slave->perm_hwaddr[5],
- bond->device->name,
- slave->name);
- }
-
- /* Inform AD package of unbinding of slave. */
- if (bond_mode == BOND_MODE_8023AD) {
- /* must be called before the slave is
- * detached from the list
- */
- bond_3ad_unbind_slave(our_slave);
- }
-
- printk (KERN_INFO "%s: releasing %s interface %s\n",
- master->name,
- (our_slave->state == BOND_STATE_ACTIVE) ? "active" : "backup",
- slave->name);
-
- /* release the slave from its bond */
- bond_detach_slave(bond, our_slave);
-
- if (bond->primary_slave == our_slave) {
- bond->primary_slave = NULL;
- }
-
- if (bond->current_slave == our_slave) {
- change_active_interface(bond, NULL);
- reselect_active_interface(bond);
- }
-
- if (bond->current_slave == NULL) {
- printk(KERN_INFO
- "%s: now running without any active interface !\n",
- master->name);
- }
+ write_unlock_bh(&bond->lock);
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- /* must be called only after the slave has been
- * detached from the list and the current_slave
- * has been replaced (if our_slave == old_current)
- */
- bond_alb_deinit_slave(bond, our_slave);
- }
+ bond_del_vlans_from_slave(bond, slave_dev);
- break;
+ /* If the mode USES_PRIMARY, then we should only remove its
+ * promisc and mc settings if it was the curr_active_slave, but that was
+ * already taken care of above when we detached the slave
+ */
+ if (!USES_PRIMARY(bond->params.mode)) {
+ /* unset promiscuity level from slave */
+ if (bond_dev->flags & IFF_PROMISC) {
+ dev_set_promiscuity(slave_dev, -1);
}
- }
- write_unlock_bh(&bond->lock);
-
- if (our_slave == (slave_t *)bond) {
- /* if we get here, it's because the device was not found */
- printk (KERN_INFO "%s: %s not enslaved\n", master->name, slave->name);
- return -EINVAL;
- }
-
- /* unset promiscuity level from slave */
- if (master->flags & IFF_PROMISC) {
- /* If the mode USES_PRIMARY, then we should only remove its
- * promisc settings if it was the current_slave, but that was
- * already taken care of above when we detached the slave
- */
- if (!USES_PRIMARY(bond_mode)) {
- dev_set_promiscuity(slave, -1);
+ /* unset allmulti level from slave */
+ if (bond_dev->flags & IFF_ALLMULTI) {
+ dev_set_allmulti(slave_dev, -1);
}
- }
-
- /* undo settings and restore original values */
- if (multicast_mode == BOND_MULTICAST_ALL) {
- /* flush master's mc_list from slave */
- bond_mc_list_flush (slave, master);
- /* unset allmulti level from slave */
- if (master->flags & IFF_ALLMULTI)
- dev_set_allmulti(slave, -1);
+ /* flush master's mc_list from slave */
+ bond_mc_list_flush(bond_dev, slave_dev);
}
- netdev_set_master(slave, NULL);
+ netdev_set_master(slave_dev, NULL);
/* close slave before restoring its mac address */
- dev_close(slave);
+ dev_close(slave_dev);
if (app_abi_ver >= 1) {
/* restore original ("permanent") mac address */
- memcpy(addr.sa_data, our_slave->perm_hwaddr, ETH_ALEN);
- addr.sa_family = slave->type;
- slave->set_mac_address(slave, &addr);
+ memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
+ addr.sa_family = slave_dev->type;
+ slave_dev->set_mac_address(slave_dev, &addr);
}
/* restore the original state of the
* IFF_NOARP flag that might have been
* set by bond_set_slave_inactive_flags()
*/
- if ((our_slave->original_flags & IFF_NOARP) == 0) {
- slave->flags &= ~IFF_NOARP;
+ if ((slave->original_flags & IFF_NOARP) == 0) {
+ slave_dev->flags &= ~IFF_NOARP;
}
- kfree(our_slave);
-
- /* if the last slave was removed, zero the mac address
- * of the master so it will be set by the application
- * to the mac address of the first slave
- */
- if (bond->next == (slave_t*)bond) {
- memset(master->dev_addr, 0, master->addr_len);
- }
+ kfree(slave);
return 0; /* deletion OK */
}
-/*
+/*
* This function releases all slaves.
*/
-static int bond_release_all(struct net_device *master)
+static int bond_release_all(struct net_device *bond_dev)
{
- bonding_t *bond;
- slave_t *our_slave, *old_current;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
struct net_device *slave_dev;
struct sockaddr addr;
- int err = 0;
-
- if (master == NULL) {
- return -ENODEV;
- }
-
- if (master->flags & IFF_SLAVE) {
- return -EINVAL;
- }
-
- bond = (struct bonding *) master->priv;
write_lock_bh(&bond->lock);
- if (bond->next == (struct slave *) bond) {
- err = -EINVAL;
+
+ if (bond->slave_cnt == 0) {
goto out;
}
- old_current = bond->current_slave;
- change_active_interface(bond, NULL);
bond->current_arp_slave = NULL;
bond->primary_slave = NULL;
+ bond_change_active_slave(bond, NULL);
- while ((our_slave = bond->prev) != (slave_t *)bond) {
+ while ((slave = bond->first_slave) != NULL) {
/* Inform AD package of unbinding of slave
* before slave is detached from the list.
*/
- if (bond_mode == BOND_MODE_8023AD) {
- bond_3ad_unbind_slave(our_slave);
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ bond_3ad_unbind_slave(slave);
}
- slave_dev = our_slave->dev;
- bond_detach_slave(bond, our_slave);
+ slave_dev = slave->dev;
+ bond_detach_slave(bond, slave);
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
/* must be called only after the slave
* has been detached from the list
*/
- bond_alb_deinit_slave(bond, our_slave);
+ bond_alb_deinit_slave(bond, slave);
}
/* now that the slave is detached, unlock and perform
@@ -2180,20 +2225,25 @@
*/
write_unlock_bh(&bond->lock);
- /* unset promiscuity level from slave */
- if (master->flags & IFF_PROMISC) {
- if (!USES_PRIMARY(bond_mode)) {
- dev_set_promiscuity(slave_dev, -1);
+ bond_del_vlans_from_slave(bond, slave_dev);
+
+ /* If the mode USES_PRIMARY, then we should only remove its
+ * promisc and mc settings if it was the curr_active_slave, but that was
+ * already taken care of above when we detached the slave
+ */
+ if (!USES_PRIMARY(bond->params.mode)) {
+ /* unset promiscuity level from slave */
+ if (bond_dev->flags & IFF_PROMISC) {
+ dev_set_promiscuity(slave_dev, -1);
}
- }
- if (multicast_mode == BOND_MULTICAST_ALL) {
- /* flush master's mc_list from slave */
- bond_mc_list_flush (slave_dev, master);
-
- /* unset allmulti level from slave */
- if (master->flags & IFF_ALLMULTI)
- dev_set_allmulti(slave_dev, -1);
+ /* unset allmulti level from slave */
+ if (bond_dev->flags & IFF_ALLMULTI) {
+ dev_set_allmulti(slave_dev, -1);
+ }
+
+ /* flush master's mc_list from slave */
+ bond_mc_list_flush(bond_dev, slave_dev);
}
netdev_set_master(slave_dev, NULL);
@@ -2203,7 +2253,7 @@
if (app_abi_ver >= 1) {
/* restore original ("permanent") mac address*/
- memcpy(addr.sa_data, our_slave->perm_hwaddr, ETH_ALEN);
+ memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
addr.sa_family = slave_dev->type;
slave_dev->set_mac_address(slave_dev, &addr);
}
@@ -2211,11 +2261,11 @@
/* restore the original state of the IFF_NOARP flag that might have
* been set by bond_set_slave_inactive_flags()
*/
- if ((our_slave->original_flags & IFF_NOARP) == 0) {
+ if ((slave->original_flags & IFF_NOARP) == 0) {
slave_dev->flags &= ~IFF_NOARP;
}
- kfree(our_slave);
+ kfree(slave);
/* re-acquire the lock before getting the next slave */
write_lock_bh(&bond->lock);
@@ -2225,124 +2275,304 @@
* set by the application to the mac address of the
* first slave
*/
- memset(master->dev_addr, 0, master->addr_len);
+ memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
+
+ if (list_empty(&bond->vlan_list)) {
+ bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
+ } else {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: clearing HW address of %s while it "
+ "still has VLANs.\n",
+ bond_dev->name);
+ printk(KERN_WARNING DRV_NAME
+ ": When re-adding slaves, make sure the bond's "
+ "HW address matches its VLANs'.\n");
+ }
- printk (KERN_INFO "%s: released all slaves\n", master->name);
+ printk(KERN_INFO DRV_NAME
+ ": %s: released all slaves\n",
+ bond_dev->name);
out:
write_unlock_bh(&bond->lock);
- return err;
+ return 0;
}
-/* this function is called regularly to monitor each slave's link. */
-static void bond_mii_monitor(struct net_device *master)
+/*
+ * This function changes the active slave to slave <slave_dev>.
+ * It returns -EINVAL in the following cases.
+ * - <slave_dev> is not found in the list.
+ * - There is not active slave now.
+ * - <slave_dev> is already active.
+ * - The link state of <slave_dev> is not BOND_LINK_UP.
+ * - <slave_dev> is not running.
+ * In these cases, this fuction does nothing.
+ * In the other cases, currnt_slave pointer is changed and 0 is returned.
+ */
+static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev)
{
- bonding_t *bond = (struct bonding *) master->priv;
- slave_t *slave, *oldcurrent;
- int slave_died = 0;
- int do_failover = 0;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *old_active = NULL;
+ struct slave *new_active = NULL;
+ int res = 0;
- read_lock(&bond->lock);
+ if (!USES_PRIMARY(bond->params.mode)) {
+ return -EINVAL;
+ }
- /* we will try to read the link status of each of our slaves, and
- * set their IFF_RUNNING flag appropriately. For each slave not
- * supporting MII status, we won't do anything so that a user-space
- * program could monitor the link itself if needed.
- */
+ /* Verify that master_dev is indeed the master of slave_dev */
+ if (!(slave_dev->flags & IFF_SLAVE) ||
+ (slave_dev->master != bond_dev)) {
+ return -EINVAL;
+ }
- slave = (slave_t *)bond;
+ write_lock_bh(&bond->lock);
- read_lock(&bond->ptrlock);
- oldcurrent = bond->current_slave;
- read_unlock(&bond->ptrlock);
+ old_active = bond->curr_active_slave;
+ new_active = bond_get_slave_by_dev(bond, slave_dev);
- while ((slave = slave->prev) != (slave_t *)bond) {
- struct net_device *dev = slave->dev;
- int link_state;
- u16 old_speed = slave->speed;
- u8 old_duplex = slave->duplex;
-
- link_state = bond_check_dev_link(dev, 0);
+ /*
+ * Changing to the current active: do nothing; return success.
+ */
+ if (new_active && (new_active == old_active)) {
+ write_unlock_bh(&bond->lock);
+ return 0;
+ }
- switch (slave->link) {
- case BOND_LINK_UP: /* the link was up */
- if (link_state == BMSR_LSTATUS) {
- /* link stays up, nothing more to do */
- break;
- }
- else { /* link going down */
- slave->link = BOND_LINK_FAIL;
- slave->delay = downdelay;
- if (slave->link_failure_count < UINT_MAX) {
- slave->link_failure_count++;
- }
- if (downdelay > 0) {
- printk (KERN_INFO
- "%s: link status down for %sinterface "
- "%s, disabling it in %d ms.\n",
- master->name,
- IS_UP(dev)
- ? ((bond_mode == BOND_MODE_ACTIVEBACKUP)
- ? ((slave == oldcurrent)
- ? "active " : "backup ")
- : "")
- : "idle ",
- dev->name,
- downdelay * miimon);
- }
- }
- /* no break ! fall through the BOND_LINK_FAIL test to
- ensure proper action to be taken
- */
- case BOND_LINK_FAIL: /* the link has just gone down */
- if (link_state != BMSR_LSTATUS) {
- /* link stays down */
- if (slave->delay <= 0) {
- /* link down for too long time */
- slave->link = BOND_LINK_DOWN;
- /* in active/backup mode, we must
- * completely disable this interface
- */
- if ((bond_mode == BOND_MODE_ACTIVEBACKUP) ||
- (bond_mode == BOND_MODE_8023AD)) {
- bond_set_slave_inactive_flags(slave);
- }
+ if ((new_active) &&
+ (old_active) &&
+ (new_active->link == BOND_LINK_UP) &&
+ IS_UP(new_active->dev)) {
+ bond_change_active_slave(bond, new_active);
+ } else {
+ res = -EINVAL;
+ }
- printk(KERN_INFO
- "%s: link status definitely down "
- "for interface %s, disabling it",
- master->name,
- dev->name);
+ write_unlock_bh(&bond->lock);
- /* notify ad that the link status has changed */
- if (bond_mode == BOND_MODE_8023AD) {
- bond_3ad_handle_link_change(slave, BOND_LINK_DOWN);
- }
+ return res;
+}
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
- bond_alb_handle_link_change(bond, slave, BOND_LINK_DOWN);
- }
+static int bond_ethtool_ioctl(struct net_device *bond_dev, struct ifreq *ifr)
+{
+ struct ethtool_drvinfo info;
+ void *addr = ifr->ifr_data;
+ uint32_t cmd;
- if (slave == oldcurrent) {
- do_failover = 1;
- }
+ if (get_user(cmd, (uint32_t *)addr)) {
+ return -EFAULT;
+ }
- slave_died = 1;
- } else {
- slave->delay--;
- }
+ switch (cmd) {
+ case ETHTOOL_GDRVINFO:
+ if (copy_from_user(&info, addr, sizeof(info))) {
+ return -EFAULT;
+ }
+
+ if (strcmp(info.driver, "ifenslave") == 0) {
+ int new_abi_ver;
+ char *endptr;
+
+ new_abi_ver = simple_strtoul(info.fw_version,
+ &endptr, 0);
+ if (*endptr) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: got invalid ABI "
+ "version from application\n");
+
+ return -EINVAL;
+ }
+
+ if (orig_app_abi_ver == -1) {
+ orig_app_abi_ver = new_abi_ver;
+ }
+
+ app_abi_ver = new_abi_ver;
+ }
+
+ strncpy(info.driver, DRV_NAME, 32);
+ strncpy(info.version, DRV_VERSION, 32);
+ snprintf(info.fw_version, 32, "%d", BOND_ABI_VERSION);
+
+ if (copy_to_user(addr, &info, sizeof(info))) {
+ return -EFAULT;
+ }
+
+ return 0;
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
+{
+ struct bonding *bond = bond_dev->priv;
+
+ info->bond_mode = bond->params.mode;
+ info->miimon = bond->params.miimon;
+
+ read_lock_bh(&bond->lock);
+ info->num_slaves = bond->slave_cnt;
+ read_unlock_bh(&bond->lock);
+
+ return 0;
+}
+
+static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
+ int i, found = 0;
+
+ if (info->slave_id < 0) {
+ return -ENODEV;
+ }
+
+ read_lock_bh(&bond->lock);
+
+ bond_for_each_slave(bond, slave, i) {
+ if (i == (int)info->slave_id) {
+ found = 1;
+ break;
+ }
+ }
+
+ read_unlock_bh(&bond->lock);
+
+ if (found) {
+ strcpy(info->slave_name, slave->dev->name);
+ info->link = slave->link;
+ info->state = slave->state;
+ info->link_failure_count = slave->link_failure_count;
+ } else {
+ return -ENODEV;
+ }
+
+ return 0;
+}
+
+/*-------------------------------- Monitoring -------------------------------*/
+
+/* this function is called regularly to monitor each slave's link. */
+static void bond_mii_monitor(struct net_device *bond_dev)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *oldcurrent;
+ int do_failover = 0;
+ int delta_in_ticks;
+ int i;
+
+ read_lock(&bond->lock);
+
+ delta_in_ticks = (bond->params.miimon * HZ) / 1000;
+
+ if (bond->kill_timers) {
+ goto out;
+ }
+
+ if (bond->slave_cnt == 0) {
+ goto re_arm;
+ }
+
+ /* we will try to read the link status of each of our slaves, and
+ * set their IFF_RUNNING flag appropriately. For each slave not
+ * supporting MII status, we won't do anything so that a user-space
+ * program could monitor the link itself if needed.
+ */
+
+ read_lock(&bond->curr_slave_lock);
+ oldcurrent = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
+
+ bond_for_each_slave(bond, slave, i) {
+ struct net_device *slave_dev = slave->dev;
+ int link_state;
+ u16 old_speed = slave->speed;
+ u8 old_duplex = slave->duplex;
+
+ link_state = bond_check_dev_link(bond, slave_dev, 0);
+
+ switch (slave->link) {
+ case BOND_LINK_UP: /* the link was up */
+ if (link_state == BMSR_LSTATUS) {
+ /* link stays up, nothing more to do */
+ break;
+ } else { /* link going down */
+ slave->link = BOND_LINK_FAIL;
+ slave->delay = bond->params.downdelay;
+
+ if (slave->link_failure_count < UINT_MAX) {
+ slave->link_failure_count++;
+ }
+
+ if (bond->params.downdelay) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status down for %s "
+ "interface %s, disabling it in "
+ "%d ms.\n",
+ bond_dev->name,
+ IS_UP(slave_dev)
+ ? ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
+ ? ((slave == oldcurrent)
+ ? "active " : "backup ")
+ : "")
+ : "idle ",
+ slave_dev->name,
+ bond->params.downdelay * bond->params.miimon);
+ }
+ }
+ /* no break ! fall through the BOND_LINK_FAIL test to
+ ensure proper action to be taken
+ */
+ case BOND_LINK_FAIL: /* the link has just gone down */
+ if (link_state != BMSR_LSTATUS) {
+ /* link stays down */
+ if (slave->delay <= 0) {
+ /* link down for too long time */
+ slave->link = BOND_LINK_DOWN;
+
+ /* in active/backup mode, we must
+ * completely disable this interface
+ */
+ if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP) ||
+ (bond->params.mode == BOND_MODE_8023AD)) {
+ bond_set_slave_inactive_flags(slave);
+ }
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status definitely "
+ "down for interface %s, "
+ "disabling it\n",
+ bond_dev->name,
+ slave_dev->name);
+
+ /* notify ad that the link status has changed */
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ bond_3ad_handle_link_change(slave, BOND_LINK_DOWN);
+ }
+
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ bond_alb_handle_link_change(bond, slave, BOND_LINK_DOWN);
+ }
+
+ if (slave == oldcurrent) {
+ do_failover = 1;
+ }
+ } else {
+ slave->delay--;
+ }
} else {
/* link up again */
slave->link = BOND_LINK_UP;
slave->jiffies = jiffies;
- printk(KERN_INFO
- "%s: link status up again after %d ms "
- "for interface %s.\n",
- master->name,
- (downdelay - slave->delay) * miimon,
- dev->name);
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status up again after %d "
+ "ms for interface %s.\n",
+ bond_dev->name,
+ (bond->params.downdelay - slave->delay) * bond->params.miimon,
+ slave_dev->name);
}
break;
case BOND_LINK_DOWN: /* the link was down */
@@ -2351,17 +2581,18 @@
break;
} else { /* link going up */
slave->link = BOND_LINK_BACK;
- slave->delay = updelay;
-
- if (updelay > 0) {
+ slave->delay = bond->params.updelay;
+
+ if (bond->params.updelay) {
/* if updelay == 0, no need to
advertise about a 0 ms delay */
- printk (KERN_INFO
- "%s: link status up for interface"
- " %s, enabling it in %d ms.\n",
- master->name,
- dev->name,
- updelay * miimon);
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status up for "
+ "interface %s, enabling it "
+ "in %d ms.\n",
+ bond_dev->name,
+ slave_dev->name,
+ bond->params.updelay * bond->params.miimon);
}
}
/* no break ! fall through the BOND_LINK_BACK state in
@@ -2371,12 +2602,13 @@
if (link_state != BMSR_LSTATUS) {
/* link down again */
slave->link = BOND_LINK_DOWN;
- printk(KERN_INFO
- "%s: link status down again after %d ms "
- "for interface %s.\n",
- master->name,
- (updelay - slave->delay) * miimon,
- dev->name);
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status down again after %d "
+ "ms for interface %s.\n",
+ bond_dev->name,
+ (bond->params.updelay - slave->delay) * bond->params.miimon,
+ slave_dev->name);
} else {
/* link stays up */
if (slave->delay == 0) {
@@ -2384,11 +2616,10 @@
slave->link = BOND_LINK_UP;
slave->jiffies = jiffies;
- if (bond_mode == BOND_MODE_8023AD) {
+ if (bond->params.mode == BOND_MODE_8023AD) {
/* prevent it from being the active one */
slave->state = BOND_STATE_BACKUP;
- }
- else if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
+ } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
/* make it immediately active */
slave->state = BOND_STATE_ACTIVE;
} else if (slave != bond->primary_slave) {
@@ -2396,23 +2627,23 @@
slave->state = BOND_STATE_BACKUP;
}
- printk(KERN_INFO
- "%s: link status definitely up "
- "for interface %s.\n",
- master->name,
- dev->name);
-
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status definitely "
+ "up for interface %s.\n",
+ bond_dev->name,
+ slave_dev->name);
+
/* notify ad that the link status has changed */
- if (bond_mode == BOND_MODE_8023AD) {
+ if (bond->params.mode == BOND_MODE_8023AD) {
bond_3ad_handle_link_change(slave, BOND_LINK_UP);
}
- if ((bond_mode == BOND_MODE_TLB) ||
- (bond_mode == BOND_MODE_ALB)) {
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
bond_alb_handle_link_change(bond, slave, BOND_LINK_UP);
}
- if ((oldcurrent == NULL) ||
+ if ((!oldcurrent) ||
(slave == bond->primary_slave)) {
do_failover = 1;
}
@@ -2421,120 +2652,128 @@
}
}
break;
- } /* end of switch */
+ default:
+ /* Should not happen */
+ printk(KERN_ERR "bonding: Error: %s Illegal value (link=%d)\n",
+ slave->dev->name, slave->link);
+ goto out;
+ } /* end of switch (slave->link) */
bond_update_speed_duplex(slave);
- if (bond_mode == BOND_MODE_8023AD) {
+ if (bond->params.mode == BOND_MODE_8023AD) {
if (old_speed != slave->speed) {
bond_3ad_adapter_speed_changed(slave);
}
+
if (old_duplex != slave->duplex) {
bond_3ad_adapter_duplex_changed(slave);
}
}
- } /* end of while */
+ } /* end of for */
if (do_failover) {
- write_lock(&bond->ptrlock);
+ write_lock(&bond->curr_slave_lock);
- reselect_active_interface(bond);
- if (oldcurrent && !bond->current_slave) {
- printk(KERN_INFO
- "%s: now running without any active interface !\n",
- master->name);
+ bond_select_active_slave(bond);
+
+ if (oldcurrent && !bond->curr_active_slave) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: now running without any active "
+ "interface !\n",
+ bond_dev->name);
}
- write_unlock(&bond->ptrlock);
+ write_unlock(&bond->curr_slave_lock);
}
+re_arm:
+ if (bond->params.miimon) {
+ mod_timer(&bond->mii_timer, jiffies + delta_in_ticks);
+ }
+out:
read_unlock(&bond->lock);
- /* re-arm the timer */
- mod_timer(&bond->mii_timer, jiffies + (miimon * HZ / 1000));
}
-/*
- * this function is called regularly to monitor each slave's link
+static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
+{
+ int i;
+ u32 *targets = bond->params.arp_targets;
+
+ for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) {
+ arp_send(ARPOP_REQUEST, ETH_P_ARP, targets[i], slave->dev,
+ my_ip, NULL, slave->dev->dev_addr,
+ NULL);
+ }
+}
+
+/*
+ * this function is called regularly to monitor each slave's link
* ensuring that traffic is being sent and received when arp monitoring
- * is used in load-balancing mode. if the adapter has been dormant, then an
- * arp is transmitted to generate traffic. see activebackup_arp_monitor for
- * arp monitoring in active backup mode.
- */
-static void loadbalance_arp_monitor(struct net_device *master)
-{
- bonding_t *bond;
- slave_t *slave, *oldcurrent;
- int the_delta_in_ticks = arp_interval * HZ / 1000;
- int next_timer = jiffies + (arp_interval * HZ / 1000);
+ * is used in load-balancing mode. if the adapter has been dormant, then an
+ * arp is transmitted to generate traffic. see activebackup_arp_monitor for
+ * arp monitoring in active backup mode.
+ */
+static void bond_loadbalance_arp_mon(struct net_device *bond_dev)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *oldcurrent;
int do_failover = 0;
+ int delta_in_ticks;
+ int i;
- bond = (struct bonding *) master->priv;
- if (master->priv == NULL) {
- mod_timer(&bond->arp_timer, next_timer);
- return;
- }
+ read_lock(&bond->lock);
- /* TODO: investigate why rtnl_shlock_nowait and rtnl_exlock_nowait
- * are called below and add comment why they are required...
- */
- if ((!IS_UP(master)) || rtnl_shlock_nowait()) {
- mod_timer(&bond->arp_timer, next_timer);
- return;
- }
+ delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
- if (rtnl_exlock_nowait()) {
- rtnl_shunlock();
- mod_timer(&bond->arp_timer, next_timer);
- return;
+ if (bond->kill_timers) {
+ goto out;
}
- read_lock(&bond->lock);
+ if (bond->slave_cnt == 0) {
+ goto re_arm;
+ }
- read_lock(&bond->ptrlock);
- oldcurrent = bond->current_slave;
- read_unlock(&bond->ptrlock);
+ read_lock(&bond->curr_slave_lock);
+ oldcurrent = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
/* see if any of the previous devices are up now (i.e. they have
- * xmt and rcv traffic). the current_slave does not come into
+ * xmt and rcv traffic). the curr_active_slave does not come into
* the picture unless it is null. also, slave->jiffies is not needed
* here because we send an arp on each slave and give a slave as
* long as it needs to get the tx/rx within the delta.
* TODO: what about up/down delay in arp mode? it wasn't here before
- * so it can wait
+ * so it can wait
*/
- slave = (slave_t *)bond;
- while ((slave = slave->prev) != (slave_t *)bond) {
-
- if (slave->link != BOND_LINK_UP) {
-
- if (((jiffies - slave->dev->trans_start) <=
- the_delta_in_ticks) &&
- ((jiffies - slave->dev->last_rx) <=
- the_delta_in_ticks)) {
+ bond_for_each_slave(bond, slave, i) {
+ if (slave->link != BOND_LINK_UP) {
+ if (((jiffies - slave->dev->trans_start) <= delta_in_ticks) &&
+ ((jiffies - slave->dev->last_rx) <= delta_in_ticks)) {
slave->link = BOND_LINK_UP;
slave->state = BOND_STATE_ACTIVE;
/* primary_slave has no meaning in round-robin
- * mode. the window of a slave being up and
- * current_slave being null after enslaving
+ * mode. the window of a slave being up and
+ * curr_active_slave being null after enslaving
* is closed.
*/
- if (oldcurrent == NULL) {
- printk(KERN_INFO
- "%s: link status definitely up "
- "for interface %s, ",
- master->name,
- slave->dev->name);
+ if (!oldcurrent) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status definitely "
+ "up for interface %s, ",
+ bond_dev->name,
+ slave->dev->name);
do_failover = 1;
} else {
- printk(KERN_INFO
- "%s: interface %s is now up\n",
- master->name,
- slave->dev->name);
+ printk(KERN_INFO DRV_NAME
+ ": %s: interface %s is now up\n",
+ bond_dev->name,
+ slave->dev->name);
}
- }
+ }
} else {
/* slave->link == BOND_LINK_UP */
@@ -2542,224 +2781,237 @@
* when the source ip is 0, so don't take the link down
* if we don't know our ip yet
*/
- if (((jiffies - slave->dev->trans_start) >=
- (2*the_delta_in_ticks)) ||
- (((jiffies - slave->dev->last_rx) >=
- (2*the_delta_in_ticks)) && my_ip !=0)) {
+ if (((jiffies - slave->dev->trans_start) >= (2*delta_in_ticks)) ||
+ (((jiffies - slave->dev->last_rx) >= (2*delta_in_ticks)) &&
+ my_ip)) {
+
slave->link = BOND_LINK_DOWN;
slave->state = BOND_STATE_BACKUP;
+
if (slave->link_failure_count < UINT_MAX) {
slave->link_failure_count++;
}
- printk(KERN_INFO
- "%s: interface %s is now down.\n",
- master->name,
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: interface %s is now down.\n",
+ bond_dev->name,
slave->dev->name);
if (slave == oldcurrent) {
do_failover = 1;
}
}
- }
+ }
- /* note: if switch is in round-robin mode, all links
+ /* note: if switch is in round-robin mode, all links
* must tx arp to ensure all links rx an arp - otherwise
- * links may oscillate or not come up at all; if switch is
- * in something like xor mode, there is nothing we can
- * do - all replies will be rx'ed on same link causing slaves
+ * links may oscillate or not come up at all; if switch is
+ * in something like xor mode, there is nothing we can
+ * do - all replies will be rx'ed on same link causing slaves
* to be unstable during low/no traffic periods
*/
if (IS_UP(slave->dev)) {
- arp_send_all(slave);
+ bond_arp_send_all(bond, slave);
}
}
if (do_failover) {
- write_lock(&bond->ptrlock);
+ write_lock(&bond->curr_slave_lock);
+
+ bond_select_active_slave(bond);
- reselect_active_interface(bond);
- if (oldcurrent && !bond->current_slave) {
- printk(KERN_INFO
- "%s: now running without any active interface !\n",
- master->name);
+ if (oldcurrent && !bond->curr_active_slave) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: now running without any active "
+ "interface !\n",
+ bond_dev->name);
}
- write_unlock(&bond->ptrlock);
+ write_unlock(&bond->curr_slave_lock);
}
+re_arm:
+ if (bond->params.arp_interval) {
+ mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
+ }
+out:
read_unlock(&bond->lock);
- rtnl_exunlock();
- rtnl_shunlock();
-
- /* re-arm the timer */
- mod_timer(&bond->arp_timer, next_timer);
}
-/*
+/*
* When using arp monitoring in active-backup mode, this function is
* called to determine if any backup slaves have went down or a new
* current slave needs to be found.
- * The backup slaves never generate traffic, they are considered up by merely
- * receiving traffic. If the current slave goes down, each backup slave will
- * be given the opportunity to tx/rx an arp before being taken down - this
- * prevents all slaves from being taken down due to the current slave not
+ * The backup slaves never generate traffic, they are considered up by merely
+ * receiving traffic. If the current slave goes down, each backup slave will
+ * be given the opportunity to tx/rx an arp before being taken down - this
+ * prevents all slaves from being taken down due to the current slave not
* sending any traffic for the backups to receive. The arps are not necessarily
- * necessary, any tx and rx traffic will keep the current slave up. While any
- * rx traffic will keep the backup slaves up, the current slave is responsible
- * for generating traffic to keep them up regardless of any other traffic they
+ * necessary, any tx and rx traffic will keep the current slave up. While any
+ * rx traffic will keep the backup slaves up, the current slave is responsible
+ * for generating traffic to keep them up regardless of any other traffic they
* may have received.
* see loadbalance_arp_monitor for arp monitoring in load balancing mode
*/
-static void activebackup_arp_monitor(struct net_device *master)
+static void bond_activebackup_arp_mon(struct net_device *bond_dev)
{
- bonding_t *bond;
- slave_t *slave;
- int the_delta_in_ticks = arp_interval * HZ / 1000;
- int next_timer = jiffies + (arp_interval * HZ / 1000);
-
- bond = (struct bonding *) master->priv;
- if (master->priv == NULL) {
- mod_timer(&bond->arp_timer, next_timer);
- return;
- }
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave;
+ int delta_in_ticks;
+ int i;
- if (!IS_UP(master)) {
- mod_timer(&bond->arp_timer, next_timer);
- return;
+ read_lock(&bond->lock);
+
+ delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
+
+ if (bond->kill_timers) {
+ goto out;
}
- read_lock(&bond->lock);
+ if (bond->slave_cnt == 0) {
+ goto re_arm;
+ }
- /* determine if any slave has come up or any backup slave has
- * gone down
+ /* determine if any slave has come up or any backup slave has
+ * gone down
* TODO: what about up/down delay in arp mode? it wasn't here before
- * so it can wait
+ * so it can wait
*/
- slave = (slave_t *)bond;
- while ((slave = slave->prev) != (slave_t *)bond) {
-
- if (slave->link != BOND_LINK_UP) {
- if ((jiffies - slave->dev->last_rx) <=
- the_delta_in_ticks) {
+ bond_for_each_slave(bond, slave, i) {
+ if (slave->link != BOND_LINK_UP) {
+ if ((jiffies - slave->dev->last_rx) <= delta_in_ticks) {
slave->link = BOND_LINK_UP;
- write_lock(&bond->ptrlock);
- if ((bond->current_slave == NULL) &&
- ((jiffies - slave->dev->trans_start) <=
- the_delta_in_ticks)) {
- change_active_interface(bond, slave);
+
+ write_lock(&bond->curr_slave_lock);
+
+ if ((!bond->curr_active_slave) &&
+ ((jiffies - slave->dev->trans_start) <= delta_in_ticks)) {
+ bond_change_active_slave(bond, slave);
bond->current_arp_slave = NULL;
- } else if (bond->current_slave != slave) {
- /* this slave has just come up but we
+ } else if (bond->curr_active_slave != slave) {
+ /* this slave has just come up but we
* already have a current slave; this
* can also happen if bond_enslave adds
- * a new slave that is up while we are
+ * a new slave that is up while we are
* searching for a new slave
*/
bond_set_slave_inactive_flags(slave);
bond->current_arp_slave = NULL;
}
- if (slave == bond->current_slave) {
- printk(KERN_INFO
- "%s: %s is up and now the "
- "active interface\n",
- master->name,
- slave->dev->name);
+ if (slave == bond->curr_active_slave) {
+ printk(KERN_INFO DRV_NAME
+ ": %s: %s is up and now the "
+ "active interface\n",
+ bond_dev->name,
+ slave->dev->name);
} else {
- printk(KERN_INFO
- "%s: backup interface %s is "
- "now up\n",
- master->name,
- slave->dev->name);
+ printk(KERN_INFO DRV_NAME
+ ": %s: backup interface %s is "
+ "now up\n",
+ bond_dev->name,
+ slave->dev->name);
}
- write_unlock(&bond->ptrlock);
+ write_unlock(&bond->curr_slave_lock);
}
} else {
- read_lock(&bond->ptrlock);
- if ((slave != bond->current_slave) &&
- (bond->current_arp_slave == NULL) &&
- (((jiffies - slave->dev->last_rx) >=
- 3*the_delta_in_ticks) && (my_ip != 0))) {
- /* a backup slave has gone down; three times
- * the delta allows the current slave to be
+ read_lock(&bond->curr_slave_lock);
+
+ if ((slave != bond->curr_active_slave) &&
+ (!bond->current_arp_slave) &&
+ (((jiffies - slave->dev->last_rx) >= 3*delta_in_ticks) &&
+ my_ip)) {
+ /* a backup slave has gone down; three times
+ * the delta allows the current slave to be
* taken out before the backup slave.
* note: a non-null current_arp_slave indicates
- * the current_slave went down and we are
- * searching for a new one; under this
- * condition we only take the current_slave
- * down - this gives each slave a chance to
+ * the curr_active_slave went down and we are
+ * searching for a new one; under this
+ * condition we only take the curr_active_slave
+ * down - this gives each slave a chance to
* tx/rx traffic before being taken out
*/
- read_unlock(&bond->ptrlock);
+
+ read_unlock(&bond->curr_slave_lock);
+
slave->link = BOND_LINK_DOWN;
+
if (slave->link_failure_count < UINT_MAX) {
slave->link_failure_count++;
}
+
bond_set_slave_inactive_flags(slave);
- printk(KERN_INFO
- "%s: backup interface %s is now down\n",
- master->name,
- slave->dev->name);
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: backup interface %s is now down\n",
+ bond_dev->name,
+ slave->dev->name);
} else {
- read_unlock(&bond->ptrlock);
+ read_unlock(&bond->curr_slave_lock);
}
}
}
- read_lock(&bond->ptrlock);
- slave = bond->current_slave;
- read_unlock(&bond->ptrlock);
-
- if (slave != NULL) {
+ read_lock(&bond->curr_slave_lock);
+ slave = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
+ if (slave) {
/* if we have sent traffic in the past 2*arp_intervals but
- * haven't xmit and rx traffic in that time interval, select
+ * haven't xmit and rx traffic in that time interval, select
* a different slave. slave->jiffies is only updated when
- * a slave first becomes the current_slave - not necessarily
- * after every arp; this ensures the slave has a full 2*delta
- * before being taken out. if a primary is being used, check
- * if it is up and needs to take over as the current_slave
+ * a slave first becomes the curr_active_slave - not necessarily
+ * after every arp; this ensures the slave has a full 2*delta
+ * before being taken out. if a primary is being used, check
+ * if it is up and needs to take over as the curr_active_slave
*/
- if ((((jiffies - slave->dev->trans_start) >=
- (2*the_delta_in_ticks)) ||
- (((jiffies - slave->dev->last_rx) >=
- (2*the_delta_in_ticks)) && (my_ip != 0))) &&
- ((jiffies - slave->jiffies) >= 2*the_delta_in_ticks)) {
+ if ((((jiffies - slave->dev->trans_start) >= (2*delta_in_ticks)) ||
+ (((jiffies - slave->dev->last_rx) >= (2*delta_in_ticks)) &&
+ my_ip)) &&
+ ((jiffies - slave->jiffies) >= 2*delta_in_ticks)) {
slave->link = BOND_LINK_DOWN;
+
if (slave->link_failure_count < UINT_MAX) {
slave->link_failure_count++;
}
- printk(KERN_INFO "%s: link status down for "
- "active interface %s, disabling it",
- master->name,
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: link status down for active interface "
+ "%s, disabling it\n",
+ bond_dev->name,
slave->dev->name);
- write_lock(&bond->ptrlock);
- reselect_active_interface(bond);
- slave = bond->current_slave;
- write_unlock(&bond->ptrlock);
+
+ write_lock(&bond->curr_slave_lock);
+
+ bond_select_active_slave(bond);
+ slave = bond->curr_active_slave;
+
+ write_unlock(&bond->curr_slave_lock);
+
bond->current_arp_slave = slave;
- if (slave != NULL) {
+
+ if (slave) {
slave->jiffies = jiffies;
}
-
- } else if ((bond->primary_slave != NULL) &&
- (bond->primary_slave != slave) &&
+ } else if ((bond->primary_slave) &&
+ (bond->primary_slave != slave) &&
(bond->primary_slave->link == BOND_LINK_UP)) {
- /* at this point, slave is the current_slave */
- printk(KERN_INFO
- "%s: changing from interface %s to primary "
+ /* at this point, slave is the curr_active_slave */
+ printk(KERN_INFO DRV_NAME
+ ": %s: changing from interface %s to primary "
"interface %s\n",
- master->name,
- slave->dev->name,
+ bond_dev->name,
+ slave->dev->name,
bond->primary_slave->dev->name);
-
+
/* primary is up so switch to it */
- write_lock(&bond->ptrlock);
- change_active_interface(bond, bond->primary_slave);
- write_unlock(&bond->ptrlock);
+ write_lock(&bond->curr_slave_lock);
+ bond_change_active_slave(bond, bond->primary_slave);
+ write_unlock(&bond->curr_slave_lock);
+
slave = bond->primary_slave;
slave->jiffies = jiffies;
} else {
@@ -2769,567 +3021,618 @@
/* the current slave must tx an arp to ensure backup slaves
* rx traffic
*/
- if ((slave != NULL) && (my_ip != 0)) {
- arp_send_all(slave);
+ if (slave && my_ip) {
+ bond_arp_send_all(bond, slave);
}
}
- /* if we don't have a current_slave, search for the next available
- * backup slave from the current_arp_slave and make it the candidate
- * for becoming the current_slave
+ /* if we don't have a curr_active_slave, search for the next available
+ * backup slave from the current_arp_slave and make it the candidate
+ * for becoming the curr_active_slave
*/
- if (slave == NULL) {
-
- if ((bond->current_arp_slave == NULL) ||
- (bond->current_arp_slave == (slave_t *)bond)) {
- bond->current_arp_slave = bond->prev;
- }
+ if (!slave) {
+ if (!bond->current_arp_slave) {
+ bond->current_arp_slave = bond->first_slave;
+ }
- if (bond->current_arp_slave != (slave_t *)bond) {
+ if (bond->current_arp_slave) {
bond_set_slave_inactive_flags(bond->current_arp_slave);
- slave = bond->current_arp_slave->next;
/* search for next candidate */
- do {
+ bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave) {
if (IS_UP(slave->dev)) {
slave->link = BOND_LINK_BACK;
bond_set_slave_active_flags(slave);
- arp_send_all(slave);
+ bond_arp_send_all(bond, slave);
slave->jiffies = jiffies;
bond->current_arp_slave = slave;
break;
}
- /* if the link state is up at this point, we
- * mark it down - this can happen if we have
- * simultaneous link failures and
- * reselect_active_interface doesn't make this
- * one the current slave so it is still marked
+ /* if the link state is up at this point, we
+ * mark it down - this can happen if we have
+ * simultaneous link failures and
+ * reselect_active_interface doesn't make this
+ * one the current slave so it is still marked
* up when it is actually down
*/
if (slave->link == BOND_LINK_UP) {
slave->link = BOND_LINK_DOWN;
- if (slave->link_failure_count <
- UINT_MAX) {
+ if (slave->link_failure_count < UINT_MAX) {
slave->link_failure_count++;
}
bond_set_slave_inactive_flags(slave);
- printk(KERN_INFO
- "%s: backup interface "
- "%s is now down.\n",
- master->name,
- slave->dev->name);
+
+ printk(KERN_INFO DRV_NAME
+ ": %s: backup interface %s is "
+ "now down.\n",
+ bond_dev->name,
+ slave->dev->name);
}
- } while ((slave = slave->next) !=
- bond->current_arp_slave->next);
+ }
}
}
+re_arm:
+ if (bond->params.arp_interval) {
+ mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
+ }
+out:
read_unlock(&bond->lock);
- mod_timer(&bond->arp_timer, next_timer);
-}
-
-static int bond_sethwaddr(struct net_device *master, struct net_device *slave)
-{
-#ifdef BONDING_DEBUG
- printk(KERN_CRIT "bond_sethwaddr: master=%x\n", (unsigned int)master);
- printk(KERN_CRIT "bond_sethwaddr: slave=%x\n", (unsigned int)slave);
- printk(KERN_CRIT "bond_sethwaddr: slave->addr_len=%d\n", slave->addr_len);
-#endif
- memcpy(master->dev_addr, slave->dev_addr, slave->addr_len);
- return 0;
}
-static int bond_info_query(struct net_device *master, struct ifbond *info)
-{
- bonding_t *bond = (struct bonding *) master->priv;
- slave_t *slave;
-
- info->bond_mode = bond_mode;
- info->num_slaves = 0;
- info->miimon = miimon;
+/*------------------------------ proc/seq_file-------------------------------*/
- read_lock_bh(&bond->lock);
- for (slave = bond->prev; slave != (slave_t *)bond; slave = slave->prev) {
- info->num_slaves++;
- }
- read_unlock_bh(&bond->lock);
+#ifdef CONFIG_PROC_FS
- return 0;
-}
+#define SEQ_START_TOKEN ((void *)1)
-static int bond_slave_info_query(struct net_device *master,
- struct ifslave *info)
+static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
{
- bonding_t *bond = (struct bonding *) master->priv;
- slave_t *slave;
- int cur_ndx = 0;
-
- if (info->slave_id < 0) {
- return -ENODEV;
- }
+ struct bonding *bond = seq->private;
+ loff_t off = 0;
+ struct slave *slave;
+ int i;
+ /* make sure the bond won't be taken away */
+ read_lock(&dev_base_lock);
read_lock_bh(&bond->lock);
- for (slave = bond->prev;
- slave != (slave_t *)bond && cur_ndx < info->slave_id;
- slave = slave->prev) {
- cur_ndx++;
+
+ if (*pos == 0) {
+ return SEQ_START_TOKEN;
}
- read_unlock_bh(&bond->lock);
- if (slave != (slave_t *)bond) {
- strcpy(info->slave_name, slave->dev->name);
- info->link = slave->link;
- info->state = slave->state;
- info->link_failure_count = slave->link_failure_count;
- } else {
- return -ENODEV;
+ bond_for_each_slave(bond, slave, i) {
+ if (++off == *pos) {
+ return slave;
+ }
}
- return 0;
+ return NULL;
}
-static int bond_ethtool_ioctl(struct net_device *master_dev, struct ifreq *ifr)
+static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
- void *addr = ifr->ifr_data;
- uint32_t cmd;
-
- if (get_user(cmd, (uint32_t *) addr))
- return -EFAULT;
+ struct bonding *bond = seq->private;
+ struct slave *slave = v;
- switch (cmd) {
+ ++*pos;
+ if (v == SEQ_START_TOKEN) {
+ return bond->first_slave;
+ }
- case ETHTOOL_GDRVINFO:
- {
- struct ethtool_drvinfo info;
- char *endptr;
+ slave = slave->next;
- if (copy_from_user(&info, addr, sizeof(info)))
- return -EFAULT;
+ return (slave == bond->first_slave) ? NULL : slave;
+}
- if (strcmp(info.driver, "ifenslave") == 0) {
- int new_abi_ver;
+static void bond_info_seq_stop(struct seq_file *seq, void *v)
+{
+ struct bonding *bond = seq->private;
- new_abi_ver = simple_strtoul(info.fw_version,
- &endptr, 0);
- if (*endptr) {
- printk(KERN_ERR
- "bonding: Error: got invalid ABI"
- " version from application\n");
+ read_unlock_bh(&bond->lock);
+ read_unlock(&dev_base_lock);
+}
- return -EINVAL;
- }
+static void bond_info_show_master(struct seq_file *seq)
+{
+ struct bonding *bond = seq->private;
+ struct slave *curr;
- if (orig_app_abi_ver == -1) {
- orig_app_abi_ver = new_abi_ver;
- }
+ read_lock(&bond->curr_slave_lock);
+ curr = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
+
+ seq_printf(seq, "Bonding Mode: %s\n",
+ bond_mode_name(bond->params.mode));
+
+ if (USES_PRIMARY(bond->params.mode)) {
+ seq_printf(seq, "Primary Slave: %s\n",
+ (bond->params.primary[0]) ?
+ bond->params.primary : "None");
- app_abi_ver = new_abi_ver;
- }
+ seq_printf(seq, "Currently Active Slave: %s\n",
+ (curr) ? curr->dev->name : "None");
+ }
- strncpy(info.driver, DRV_NAME, 32);
- strncpy(info.version, DRV_VERSION, 32);
- snprintf(info.fw_version, 32, "%d", BOND_ABI_VERSION);
+ seq_printf(seq, "MII Status: %s\n", (curr) ? "up" : "down");
+ seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
+ seq_printf(seq, "Up Delay (ms): %d\n",
+ bond->params.updelay * bond->params.miimon);
+ seq_printf(seq, "Down Delay (ms): %d\n",
+ bond->params.downdelay * bond->params.miimon);
- if (copy_to_user(addr, &info, sizeof(info)))
- return -EFAULT;
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ struct ad_info ad_info;
- return 0;
+ seq_puts(seq, "\n802.3ad info\n");
+ seq_printf(seq, "LACP rate: %s\n",
+ (bond->params.lacp_fast) ? "fast" : "slow");
+
+ if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
+ seq_printf(seq, "bond %s has no active aggregator\n",
+ bond->dev->name);
+ } else {
+ seq_printf(seq, "Active Aggregator Info:\n");
+
+ seq_printf(seq, "\tAggregator ID: %d\n",
+ ad_info.aggregator_id);
+ seq_printf(seq, "\tNumber of ports: %d\n",
+ ad_info.ports);
+ seq_printf(seq, "\tActor Key: %d\n",
+ ad_info.actor_key);
+ seq_printf(seq, "\tPartner Key: %d\n",
+ ad_info.partner_key);
+ seq_printf(seq, "\tPartner Mac Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
+ ad_info.partner_system[0],
+ ad_info.partner_system[1],
+ ad_info.partner_system[2],
+ ad_info.partner_system[3],
+ ad_info.partner_system[4],
+ ad_info.partner_system[5]);
}
- break;
- default:
- return -EOPNOTSUPP;
}
}
-static int bond_ioctl(struct net_device *master_dev, struct ifreq *ifr, int cmd)
+static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave)
{
- struct net_device *slave_dev = NULL;
- struct ifbond *u_binfo = NULL, k_binfo;
- struct ifslave *u_sinfo = NULL, k_sinfo;
- struct mii_ioctl_data *mii = NULL;
- int prev_abi_ver = orig_app_abi_ver;
- int ret = 0;
+ struct bonding *bond = seq->private;
-#ifdef BONDING_DEBUG
- printk(KERN_INFO "bond_ioctl: master=%s, cmd=%d\n",
- master_dev->name, cmd);
-#endif
+ seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
+ seq_printf(seq, "MII Status: %s\n",
+ (slave->link == BOND_LINK_UP) ? "up" : "down");
+ seq_printf(seq, "Link Failure Count: %d\n",
+ slave->link_failure_count);
- switch (cmd) {
- case SIOCETHTOOL:
- return bond_ethtool_ioctl(master_dev, ifr);
+ if (app_abi_ver >= 1) {
+ seq_printf(seq,
+ "Permanent HW addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
+ slave->perm_hwaddr[0],
+ slave->perm_hwaddr[1],
+ slave->perm_hwaddr[2],
+ slave->perm_hwaddr[3],
+ slave->perm_hwaddr[4],
+ slave->perm_hwaddr[5]);
+ }
- case SIOCGMIIPHY:
- mii = (struct mii_ioctl_data *)&ifr->ifr_data;
- if (mii == NULL) {
- return -EINVAL;
- }
- mii->phy_id = 0;
- /* Fall Through */
- case SIOCGMIIREG:
- /*
- * We do this again just in case we were called by SIOCGMIIREG
- * instead of SIOCGMIIPHY.
- */
- mii = (struct mii_ioctl_data *)&ifr->ifr_data;
- if (mii == NULL) {
- return -EINVAL;
- }
- if (mii->reg_num == 1) {
- mii->val_out = bond_check_mii_link(
- (struct bonding *)master_dev->priv);
- }
- return 0;
- case BOND_INFO_QUERY_OLD:
- case SIOCBONDINFOQUERY:
- u_binfo = (struct ifbond *)ifr->ifr_data;
- if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) {
- return -EFAULT;
- }
- ret = bond_info_query(master_dev, &k_binfo);
- if (ret == 0) {
- if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) {
- return -EFAULT;
- }
- }
- return ret;
- case BOND_SLAVE_INFO_QUERY_OLD:
- case SIOCBONDSLAVEINFOQUERY:
- u_sinfo = (struct ifslave *)ifr->ifr_data;
- if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) {
- return -EFAULT;
- }
- ret = bond_slave_info_query(master_dev, &k_sinfo);
- if (ret == 0) {
- if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) {
- return -EFAULT;
- }
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ const struct aggregator *agg
+ = SLAVE_AD_INFO(slave).port.aggregator;
+
+ if (agg) {
+ seq_printf(seq, "Aggregator ID: %d\n",
+ agg->aggregator_identifier);
+ } else {
+ seq_puts(seq, "Aggregator ID: N/A\n");
}
- return ret;
}
+}
- if (!capable(CAP_NET_ADMIN)) {
- return -EPERM;
+static int bond_info_seq_show(struct seq_file *seq, void *v)
+{
+ if (v == SEQ_START_TOKEN) {
+ seq_printf(seq, "%s\n", version);
+ bond_info_show_master(seq);
+ } else {
+ bond_info_show_slave(seq, v);
}
- if (orig_app_abi_ver == -1) {
- /* no orig_app_abi_ver was provided yet, so we'll use the
- * current one from now on, even if it's 0
- */
- orig_app_abi_ver = app_abi_ver;
+ return 0;
+}
- } else if (orig_app_abi_ver != app_abi_ver) {
- printk(KERN_ERR
- "bonding: Error: already using ifenslave ABI "
- "version %d; to upgrade ifenslave to version %d, "
- "you must first reload bonding.\n",
- orig_app_abi_ver, app_abi_ver);
- return -EINVAL;
+static struct seq_operations bond_info_seq_ops = {
+ .start = bond_info_seq_start,
+ .next = bond_info_seq_next,
+ .stop = bond_info_seq_stop,
+ .show = bond_info_seq_show,
+};
+
+static int bond_info_open(struct inode *inode, struct file *file)
+{
+ struct seq_file *seq;
+ struct proc_dir_entry *proc;
+ int res;
+
+ res = seq_open(file, &bond_info_seq_ops);
+ if (!res) {
+ /* recover the pointer buried in proc_dir_entry data */
+ seq = file->private_data;
+ proc = PDE(inode);
+ seq->private = proc->data;
}
- slave_dev = dev_get_by_name(ifr->ifr_slave);
+ return res;
+}
-#ifdef BONDING_DEBUG
- printk(KERN_INFO "slave_dev=%x: \n", (unsigned int)slave_dev);
- printk(KERN_INFO "slave_dev->name=%s: \n", slave_dev->name);
-#endif
+static struct file_operations bond_info_fops = {
+ .owner = THIS_MODULE,
+ .open = bond_info_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
- if (slave_dev == NULL) {
- ret = -ENODEV;
- } else {
- switch (cmd) {
- case BOND_ENSLAVE_OLD:
- case SIOCBONDENSLAVE:
- ret = bond_enslave(master_dev, slave_dev);
- break;
- case BOND_RELEASE_OLD:
- case SIOCBONDRELEASE:
- ret = bond_release(master_dev, slave_dev);
- break;
- case BOND_SETHWADDR_OLD:
- case SIOCBONDSETHWADDR:
- ret = bond_sethwaddr(master_dev, slave_dev);
+static int bond_create_proc_entry(struct bonding *bond)
+{
+ struct net_device *bond_dev = bond->dev;
+
+ if (bond_proc_dir) {
+ bond->proc_entry = create_proc_entry(bond_dev->name,
+ S_IRUGO,
+ bond_proc_dir);
+ if (bond->proc_entry == NULL) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: Cannot create /proc/net/%s/%s\n",
+ DRV_NAME, bond_dev->name);
+ } else {
+ bond->proc_entry->data = bond;
+ bond->proc_entry->proc_fops = &bond_info_fops;
+ bond->proc_entry->owner = THIS_MODULE;
+ memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
+ }
+ }
+
+ return 0;
+}
+
+static void bond_remove_proc_entry(struct bonding *bond)
+{
+ if (bond_proc_dir && bond->proc_entry) {
+ remove_proc_entry(bond->proc_file_name, bond_proc_dir);
+ memset(bond->proc_file_name, 0, IFNAMSIZ);
+ bond->proc_entry = NULL;
+ }
+}
+
+/* Create the bonding directory under /proc/net, if doesn't exist yet.
+ * Caller must hold rtnl_lock.
+ */
+static void bond_create_proc_dir(void)
+{
+ int len = strlen(DRV_NAME);
+
+ for (bond_proc_dir = proc_net->subdir; bond_proc_dir;
+ bond_proc_dir = bond_proc_dir->next) {
+ if ((bond_proc_dir->namelen == len) &&
+ !memcmp(bond_proc_dir->name, DRV_NAME, len)) {
break;
- case BOND_CHANGE_ACTIVE_OLD:
- case SIOCBONDCHANGEACTIVE:
- if (USES_PRIMARY(bond_mode)) {
- ret = bond_change_active(master_dev, slave_dev);
- }
- else {
- ret = -EINVAL;
- }
+ }
+ }
+
+ if (!bond_proc_dir) {
+ bond_proc_dir = proc_mkdir(DRV_NAME, proc_net);
+ if (bond_proc_dir) {
+ bond_proc_dir->owner = THIS_MODULE;
+ } else {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: cannot create /proc/net/%s\n",
+ DRV_NAME);
+ }
+ }
+}
+
+/* Destroy the bonding directory under /proc/net, if empty.
+ * Caller must hold rtnl_lock.
+ */
+static void bond_destroy_proc_dir(void)
+{
+ struct proc_dir_entry *de;
+
+ if (!bond_proc_dir) {
+ return;
+ }
+
+ /* verify that the /proc dir is empty */
+ for (de = bond_proc_dir->subdir; de; de = de->next) {
+ /* ignore . and .. */
+ if (*(de->name) != '.') {
break;
- default:
- ret = -EOPNOTSUPP;
}
- dev_put(slave_dev);
}
- if (ret < 0) {
- /* The ioctl failed, so there's no point in changing the
- * orig_app_abi_ver. We'll restore it's value just in case
- * we've changed it earlier in this function.
+ if (de) {
+ if (bond_proc_dir->owner == THIS_MODULE) {
+ bond_proc_dir->owner = NULL;
+ }
+ } else {
+ remove_proc_entry(DRV_NAME, proc_net);
+ bond_proc_dir = NULL;
+ }
+}
+#endif /* CONFIG_PROC_FS */
+
+/*-------------------------- netdev event handling --------------------------*/
+
+/*
+ * Change device name
+ */
+static int bond_event_changename(struct bonding *bond)
+{
+#ifdef CONFIG_PROC_FS
+ bond_remove_proc_entry(bond);
+ bond_create_proc_entry(bond);
+#endif
+
+ return NOTIFY_DONE;
+}
+
+static int bond_master_netdev_event(unsigned long event, struct net_device *bond_dev)
+{
+ struct bonding *event_bond = bond_dev->priv;
+
+ switch (event) {
+ case NETDEV_CHANGENAME:
+ return bond_event_changename(event_bond);
+ case NETDEV_UNREGISTER:
+ /*
+ * TODO: remove a bond from the list?
*/
- orig_app_abi_ver = prev_abi_ver;
+ break;
+ default:
+ break;
}
- return ret;
+ return NOTIFY_DONE;
}
-#ifdef CONFIG_NET_FASTROUTE
-static int bond_accept_fastpath(struct net_device *dev, struct dst_entry *dst)
+static int bond_slave_netdev_event(unsigned long event, struct net_device *slave_dev)
{
- return -1;
+ struct net_device *bond_dev = slave_dev->master;
+
+ switch (event) {
+ case NETDEV_UNREGISTER:
+ if (bond_dev) {
+ bond_release(bond_dev, slave_dev);
+ }
+ break;
+ case NETDEV_CHANGE:
+ /*
+ * TODO: is this what we get if somebody
+ * sets up a hierarchical bond, then rmmod's
+ * one of the slave bonding devices?
+ */
+ break;
+ case NETDEV_DOWN:
+ /*
+ * ... Or is it this?
+ */
+ break;
+ case NETDEV_CHANGEMTU:
+ /*
+ * TODO: Should slaves be allowed to
+ * independently alter their MTU? For
+ * an active-backup bond, slaves need
+ * not be the same type of device, so
+ * MTUs may vary. For other modes,
+ * slaves arguably should have the
+ * same MTUs. To do this, we'd need to
+ * take over the slave's change_mtu
+ * function for the duration of their
+ * servitude.
+ */
+ break;
+ case NETDEV_CHANGENAME:
+ /*
+ * TODO: handle changing the primary's name
+ */
+ break;
+ default:
+ break;
+ }
+
+ return NOTIFY_DONE;
}
-#endif
-/*
- * in broadcast mode, we send everything to all usable interfaces.
+/*
+ * bond_netdev_event: handle netdev notifier chain events.
+ *
+ * This function receives events for the netdev chain. The caller (an
+ * ioctl handler calling notifier_call_chain) holds the necessary
+ * locks for us to safely manipulate the slave devices (RTNL lock,
+ * dev_probe_lock).
*/
-static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *dev)
+static int bond_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
- slave_t *slave, *start_at;
- struct bonding *bond = (struct bonding *) dev->priv;
- struct net_device *device_we_should_send_to = 0;
+ struct net_device *event_dev = (struct net_device *)ptr;
+
+ dprintk("event_dev: %s, event: %lx\n",
+ (event_dev ? event_dev->name : "None"),
+ event);
+
+ if (event_dev->flags & IFF_MASTER) {
+ dprintk("IFF_MASTER\n");
+ return bond_master_netdev_event(event, event_dev);
+ }
- if (!IS_UP(dev)) { /* bond down */
- dev_kfree_skb(skb);
- return 0;
+ if (event_dev->flags & IFF_SLAVE) {
+ dprintk("IFF_SLAVE\n");
+ return bond_slave_netdev_event(event, event_dev);
}
- read_lock(&bond->lock);
+ return NOTIFY_DONE;
+}
- read_lock(&bond->ptrlock);
- slave = start_at = bond->current_slave;
- read_unlock(&bond->ptrlock);
+static struct notifier_block bond_netdev_notifier = {
+ .notifier_call = bond_netdev_event,
+};
- if (slave == NULL) { /* we're at the root, get the first slave */
- /* no suitable interface, frame not sent */
- read_unlock(&bond->lock);
- dev_kfree_skb(skb);
- return 0;
- }
+/*-------------------------- Packet type handling ---------------------------*/
- do {
- if (IS_UP(slave->dev)
- && (slave->link == BOND_LINK_UP)
- && (slave->state == BOND_STATE_ACTIVE)) {
- if (device_we_should_send_to) {
- struct sk_buff *skb2;
- if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL) {
- printk(KERN_ERR "bond_xmit_broadcast: skb_clone() failed\n");
- continue;
- }
+/* register to receive lacpdus on a bond */
+static void bond_register_lacpdu(struct bonding *bond)
+{
+ struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);
- skb2->dev = device_we_should_send_to;
- skb2->priority = 1;
- dev_queue_xmit(skb2);
- }
- device_we_should_send_to = slave->dev;
- }
- } while ((slave = slave->next) != start_at);
+ /* initialize packet type */
+ pk_type->type = PKT_TYPE_LACPDU;
+ pk_type->dev = bond->dev;
+ pk_type->func = bond_3ad_lacpdu_recv;
+ pk_type->data = (void*)1; /* understand shared skbs */
- if (device_we_should_send_to) {
- skb->dev = device_we_should_send_to;
- skb->priority = 1;
- dev_queue_xmit(skb);
- } else
- dev_kfree_skb(skb);
+ dev_add_pack(pk_type);
+}
- /* frame sent to all suitable interfaces */
- read_unlock(&bond->lock);
- return 0;
+/* unregister to receive lacpdus on a bond */
+static void bond_unregister_lacpdu(struct bonding *bond)
+{
+ dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
}
-static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *dev)
+/*-------------------------- Device entry points ----------------------------*/
+
+static int bond_open(struct net_device *bond_dev)
{
- slave_t *slave, *start_at;
- struct bonding *bond = (struct bonding *) dev->priv;
+ struct bonding *bond = bond_dev->priv;
+ struct timer_list *mii_timer = &bond->mii_timer;
+ struct timer_list *arp_timer = &bond->arp_timer;
- if (!IS_UP(dev)) { /* bond down */
- dev_kfree_skb(skb);
- return 0;
- }
+ bond->kill_timers = 0;
- read_lock(&bond->lock);
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ struct timer_list *alb_timer = &(BOND_ALB_INFO(bond).alb_timer);
- read_lock(&bond->ptrlock);
- slave = start_at = bond->current_slave;
- read_unlock(&bond->ptrlock);
+ /* bond_alb_initialize must be called before the timer
+ * is started.
+ */
+ if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
+ /* something went wrong - fail the open operation */
+ return -1;
+ }
- if (slave == NULL) { /* we're at the root, get the first slave */
- /* no suitable interface, frame not sent */
- dev_kfree_skb(skb);
- read_unlock(&bond->lock);
- return 0;
+ init_timer(alb_timer);
+ alb_timer->expires = jiffies + 1;
+ alb_timer->data = (unsigned long)bond;
+ alb_timer->function = (void *)&bond_alb_monitor;
+ add_timer(alb_timer);
}
- do {
- if (IS_UP(slave->dev)
- && (slave->link == BOND_LINK_UP)
- && (slave->state == BOND_STATE_ACTIVE)) {
-
- skb->dev = slave->dev;
- skb->priority = 1;
- dev_queue_xmit(skb);
-
- write_lock(&bond->ptrlock);
- bond->current_slave = slave->next;
- write_unlock(&bond->ptrlock);
+ if (bond->params.miimon) { /* link check interval, in milliseconds. */
+ init_timer(mii_timer);
+ mii_timer->expires = jiffies + 1;
+ mii_timer->data = (unsigned long)bond_dev;
+ mii_timer->function = (void *)&bond_mii_monitor;
+ add_timer(mii_timer);
+ }
- read_unlock(&bond->lock);
- return 0;
+ if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
+ init_timer(arp_timer);
+ arp_timer->expires = jiffies + 1;
+ arp_timer->data = (unsigned long)bond_dev;
+ if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
+ arp_timer->function = (void *)&bond_activebackup_arp_mon;
+ } else {
+ arp_timer->function = (void *)&bond_loadbalance_arp_mon;
}
- } while ((slave = slave->next) != start_at);
+ add_timer(arp_timer);
+ }
+
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ struct timer_list *ad_timer = &(BOND_AD_INFO(bond).ad_timer);
+ init_timer(ad_timer);
+ ad_timer->expires = jiffies + 1;
+ ad_timer->data = (unsigned long)bond;
+ ad_timer->function = (void *)&bond_3ad_state_machine_handler;
+ add_timer(ad_timer);
+
+ /* register to receive LACPDUs */
+ bond_register_lacpdu(bond);
+ }
- /* no suitable interface, frame not sent */
- dev_kfree_skb(skb);
- read_unlock(&bond->lock);
return 0;
}
-/*
- * in XOR mode, we determine the output device by performing xor on
- * the source and destination hw adresses. If this device is not
- * enabled, find the next slave following this xor slave.
- */
-static int bond_xmit_xor(struct sk_buff *skb, struct net_device *dev)
+static int bond_close(struct net_device *bond_dev)
{
- slave_t *slave, *start_at;
- struct bonding *bond = (struct bonding *) dev->priv;
- struct ethhdr *data = (struct ethhdr *)skb->data;
- int slave_no;
+ struct bonding *bond = bond_dev->priv;
- if (!IS_UP(dev)) { /* bond down */
- dev_kfree_skb(skb);
- return 0;
- }
+ write_lock_bh(&bond->lock);
- read_lock(&bond->lock);
- slave = bond->prev;
+ bond_mc_list_destroy(bond);
- /* we're at the root, get the first slave */
- if (bond->slave_cnt == 0) {
- /* no suitable interface, frame not sent */
- dev_kfree_skb(skb);
- read_unlock(&bond->lock);
- return 0;
+ if (bond->params.mode == BOND_MODE_8023AD) {
+ /* Unregister the receive of LACPDUs */
+ bond_unregister_lacpdu(bond);
}
- slave_no = (data->h_dest[5]^slave->dev->dev_addr[5]) % bond->slave_cnt;
-
- while ( (slave_no > 0) && (slave != (slave_t *)bond) ) {
- slave = slave->prev;
- slave_no--;
- }
- start_at = slave;
-
- do {
- if (IS_UP(slave->dev)
- && (slave->link == BOND_LINK_UP)
- && (slave->state == BOND_STATE_ACTIVE)) {
-
- skb->dev = slave->dev;
- skb->priority = 1;
- dev_queue_xmit(skb);
-
- read_unlock(&bond->lock);
- return 0;
- }
- } while ((slave = slave->next) != start_at);
+ /* signal timers not to re-arm */
+ bond->kill_timers = 1;
- /* no suitable interface, frame not sent */
- dev_kfree_skb(skb);
- read_unlock(&bond->lock);
- return 0;
-}
+ write_unlock_bh(&bond->lock);
-/*
- * in active-backup mode, we know that bond->current_slave is always valid if
- * the bond has a usable interface.
- */
-static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *dev)
-{
- struct bonding *bond = (struct bonding *) dev->priv;
- int ret;
+ /* del_timer_sync must run without holding the bond->lock
+ * because a running timer might be trying to hold it too
+ */
- if (!IS_UP(dev)) { /* bond down */
- dev_kfree_skb(skb);
- return 0;
+ if (bond->params.miimon) { /* link check interval, in milliseconds. */
+ del_timer_sync(&bond->mii_timer);
}
- /* if we are sending arp packets, try to at least
- identify our own ip address */
- if ( (arp_interval > 0) && (my_ip == 0) &&
- (skb->protocol == __constant_htons(ETH_P_ARP) ) ) {
- char *the_ip = (((char *)skb->data))
- + sizeof(struct ethhdr)
- + sizeof(struct arphdr) +
- ETH_ALEN;
- memcpy(&my_ip, the_ip, 4);
+ if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
+ del_timer_sync(&bond->arp_timer);
}
- /* if we are sending arp packets and don't know
- * the target hw address, save it so we don't need
- * to use a broadcast address.
- * don't do this if in active backup mode because the slaves must
- * receive packets to stay up, and the only ones they receive are
- * broadcasts.
- */
- if ( (bond_mode != BOND_MODE_ACTIVEBACKUP) &&
- (arp_ip_count == 1) &&
- (arp_interval > 0) && (arp_target_hw_addr == NULL) &&
- (skb->protocol == __constant_htons(ETH_P_IP) ) ) {
- struct ethhdr *eth_hdr =
- (struct ethhdr *) (((char *)skb->data));
- struct iphdr *ip_hdr = (struct iphdr *)(eth_hdr + 1);
-
- if (arp_target[0] == ip_hdr->daddr) {
- arp_target_hw_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
- if (arp_target_hw_addr != NULL)
- memcpy(arp_target_hw_addr, eth_hdr->h_dest, ETH_ALEN);
- }
+ switch (bond->params.mode) {
+ case BOND_MODE_8023AD:
+ del_timer_sync(&(BOND_AD_INFO(bond).ad_timer));
+ break;
+ case BOND_MODE_TLB:
+ case BOND_MODE_ALB:
+ del_timer_sync(&(BOND_ALB_INFO(bond).alb_timer));
+ break;
+ default:
+ break;
}
- read_lock(&bond->lock);
+ /* Release the bonded slaves */
+ bond_release_all(bond_dev);
- read_lock(&bond->ptrlock);
- if (bond->current_slave != NULL) { /* one usable interface */
- skb->dev = bond->current_slave->dev;
- read_unlock(&bond->ptrlock);
- skb->priority = 1;
- ret = dev_queue_xmit(skb);
- read_unlock(&bond->lock);
- return 0;
- }
- else {
- read_unlock(&bond->ptrlock);
+ if ((bond->params.mode == BOND_MODE_TLB) ||
+ (bond->params.mode == BOND_MODE_ALB)) {
+ /* Must be called only after all
+ * slaves have been released
+ */
+ bond_alb_deinitialize(bond);
}
- /* no suitable interface, frame not sent */
-#ifdef BONDING_DEBUG
- printk(KERN_INFO "There was no suitable interface, so we don't transmit\n");
-#endif
- dev_kfree_skb(skb);
- read_unlock(&bond->lock);
return 0;
}
-static struct net_device_stats *bond_get_stats(struct net_device *dev)
+static struct net_device_stats *bond_get_stats(struct net_device *bond_dev)
{
- bonding_t *bond = dev->priv;
+ struct bonding *bond = bond_dev->priv;
struct net_device_stats *stats = &(bond->stats), *sstats;
- slave_t *slave;
+ struct slave *slave;
+ int i;
memset(stats, 0, sizeof(struct net_device_stats));
read_lock_bh(&bond->lock);
- for (slave = bond->prev; slave != (slave_t *)bond; slave = slave->prev) {
+ bond_for_each_slave(bond, slave, i) {
sstats = slave->dev->get_stats(slave->dev);
-
+
stats->rx_packets += sstats->rx_packets;
stats->rx_bytes += sstats->rx_bytes;
stats->rx_errors += sstats->rx_errors;
@@ -3347,290 +3650,290 @@
stats->rx_over_errors += sstats->rx_over_errors;
stats->rx_crc_errors += sstats->rx_crc_errors;
stats->rx_frame_errors += sstats->rx_frame_errors;
- stats->rx_fifo_errors += sstats->rx_fifo_errors;
+ stats->rx_fifo_errors += sstats->rx_fifo_errors;
stats->rx_missed_errors += sstats->rx_missed_errors;
-
+
stats->tx_aborted_errors += sstats->tx_aborted_errors;
stats->tx_carrier_errors += sstats->tx_carrier_errors;
stats->tx_fifo_errors += sstats->tx_fifo_errors;
stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
stats->tx_window_errors += sstats->tx_window_errors;
-
}
read_unlock_bh(&bond->lock);
+
return stats;
}
-#ifdef CONFIG_PROC_FS
-
-#define SEQ_START_TOKEN ((void *)1)
-
-static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
+static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
{
- struct bonding *bond = seq->private;
- loff_t off = 0;
- struct slave *slave;
-
- /* make sure the bond won't be taken away */
- read_lock(&dev_base_lock);
- read_lock_bh(&bond->lock);
-
- if (*pos == 0) {
- return SEQ_START_TOKEN;
- }
+ struct net_device *slave_dev = NULL;
+ struct ifbond *u_binfo = NULL, k_binfo;
+ struct ifslave *u_sinfo = NULL, k_sinfo;
+ struct mii_ioctl_data *mii = NULL;
+ int prev_abi_ver = orig_app_abi_ver;
+ int res = 0;
- for (slave = bond->prev; slave != (slave_t *)bond;
- slave = slave->prev) {
+ dprintk("bond_ioctl: master=%s, cmd=%d\n",
+ bond_dev->name, cmd);
- if (++off == *pos) {
- return slave;
+ switch (cmd) {
+ case SIOCETHTOOL:
+ return bond_ethtool_ioctl(bond_dev, ifr);
+ case SIOCGMIIPHY:
+ mii = (struct mii_ioctl_data *)&ifr->ifr_data;
+ if (!mii) {
+ return -EINVAL;
+ }
+ mii->phy_id = 0;
+ /* Fall Through */
+ case SIOCGMIIREG:
+ /*
+ * We do this again just in case we were called by SIOCGMIIREG
+ * instead of SIOCGMIIPHY.
+ */
+ mii = (struct mii_ioctl_data *)&ifr->ifr_data;
+ if (!mii) {
+ return -EINVAL;
}
- }
-
- return NULL;
-}
-
-static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
-{
- struct bonding *bond = seq->private;
- struct slave *slave = v;
-
- ++*pos;
- if (v == SEQ_START_TOKEN) {
- slave = bond->prev;
- } else {
- slave = slave->prev;
- }
-
- return (slave == (struct slave *) bond) ? NULL : slave;
-}
-static void bond_info_seq_stop(struct seq_file *seq, void *v)
-{
- struct bonding *bond = seq->private;
+ if (mii->reg_num == 1) {
+ struct bonding *bond = bond_dev->priv;
+ mii->val_out = 0;
+ read_lock_bh(&bond->lock);
+ read_lock(&bond->curr_slave_lock);
+ if (bond->curr_active_slave) {
+ mii->val_out = BMSR_LSTATUS;
+ }
+ read_unlock(&bond->curr_slave_lock);
+ read_unlock_bh(&bond->lock);
+ }
- read_unlock_bh(&bond->lock);
- read_unlock(&dev_base_lock);
-}
+ return 0;
+ case BOND_INFO_QUERY_OLD:
+ case SIOCBONDINFOQUERY:
+ u_binfo = (struct ifbond *)ifr->ifr_data;
-static void bond_info_show_master(struct seq_file *seq, struct bonding *bond)
-{
- struct slave *curr;
+ if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) {
+ return -EFAULT;
+ }
- read_lock(&bond->ptrlock);
- curr = bond->current_slave;
- read_unlock(&bond->ptrlock);
-
- seq_printf(seq, "Bonding Mode: %s\n", bond_mode_name());
-
- if (USES_PRIMARY(bond_mode)) {
- if (curr) {
- seq_printf(seq,
- "Currently Active Slave: %s\n",
- curr->dev->name);
+ res = bond_info_query(bond_dev, &k_binfo);
+ if (res == 0) {
+ if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) {
+ return -EFAULT;
+ }
}
- }
- seq_printf(seq, "MII Status: %s\n", (curr) ? "up" : "down");
- seq_printf(seq, "MII Polling Interval (ms): %d\n", miimon);
- seq_printf(seq, "Up Delay (ms): %d\n", updelay * miimon);
- seq_printf(seq, "Down Delay (ms): %d\n", downdelay * miimon);
- seq_printf(seq, "Multicast Mode: %s\n", multicast_mode_name());
+ return res;
+ case BOND_SLAVE_INFO_QUERY_OLD:
+ case SIOCBONDSLAVEINFOQUERY:
+ u_sinfo = (struct ifslave *)ifr->ifr_data;
- if (bond_mode == BOND_MODE_8023AD) {
- struct ad_info ad_info;
+ if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) {
+ return -EFAULT;
+ }
- seq_puts(seq, "\n802.3ad info\n");
+ res = bond_slave_info_query(bond_dev, &k_sinfo);
+ if (res == 0) {
+ if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) {
+ return -EFAULT;
+ }
+ }
- if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
- seq_printf(seq, "bond %s has no active aggregator\n",
- bond->device->name);
- } else {
- seq_printf(seq, "Active Aggregator Info:\n");
+ return res;
+ default:
+ /* Go on */
+ break;
+ }
- seq_printf(seq, "\tAggregator ID: %d\n",
- ad_info.aggregator_id);
- seq_printf(seq, "\tNumber of ports: %d\n",
- ad_info.ports);
- seq_printf(seq, "\tActor Key: %d\n",
- ad_info.actor_key);
- seq_printf(seq, "\tPartner Key: %d\n",
- ad_info.partner_key);
- seq_printf(seq, "\tPartner Mac Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
- ad_info.partner_system[0],
- ad_info.partner_system[1],
- ad_info.partner_system[2],
- ad_info.partner_system[3],
- ad_info.partner_system[4],
- ad_info.partner_system[5]);
- }
+ if (!capable(CAP_NET_ADMIN)) {
+ return -EPERM;
}
-}
-static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave)
-{
- seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
- seq_printf(seq, "MII Status: %s\n",
- (slave->link == BOND_LINK_UP) ? "up" : "down");
- seq_printf(seq, "Link Failure Count: %d\n",
- slave->link_failure_count);
+ if (orig_app_abi_ver == -1) {
+ /* no orig_app_abi_ver was provided yet, so we'll use the
+ * current one from now on, even if it's 0
+ */
+ orig_app_abi_ver = app_abi_ver;
- if (app_abi_ver >= 1) {
- seq_printf(seq,
- "Permanent HW addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
- slave->perm_hwaddr[0],
- slave->perm_hwaddr[1],
- slave->perm_hwaddr[2],
- slave->perm_hwaddr[3],
- slave->perm_hwaddr[4],
- slave->perm_hwaddr[5]);
+ } else if (orig_app_abi_ver != app_abi_ver) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: already using ifenslave ABI version %d; to "
+ "upgrade ifenslave to version %d, you must first "
+ "reload bonding.\n",
+ orig_app_abi_ver, app_abi_ver);
+ return -EINVAL;
}
- if (bond_mode == BOND_MODE_8023AD) {
- const struct aggregator *agg
- = SLAVE_AD_INFO(slave).port.aggregator;
+ slave_dev = dev_get_by_name(ifr->ifr_slave);
- if (agg) {
- seq_printf(seq, "Aggregator ID: %d\n",
- agg->aggregator_identifier);
- } else {
- seq_puts(seq, "Aggregator ID: N/A\n");
+ dprintk("slave_dev=%p: \n", slave_dev);
+
+ if (!slave_dev) {
+ res = -ENODEV;
+ } else {
+ dprintk("slave_dev->name=%s: \n", slave_dev->name);
+ switch (cmd) {
+ case BOND_ENSLAVE_OLD:
+ case SIOCBONDENSLAVE:
+ res = bond_enslave(bond_dev, slave_dev);
+ break;
+ case BOND_RELEASE_OLD:
+ case SIOCBONDRELEASE:
+ res = bond_release(bond_dev, slave_dev);
+ break;
+ case BOND_SETHWADDR_OLD:
+ case SIOCBONDSETHWADDR:
+ res = bond_sethwaddr(bond_dev, slave_dev);
+ break;
+ case BOND_CHANGE_ACTIVE_OLD:
+ case SIOCBONDCHANGEACTIVE:
+ res = bond_ioctl_change_active(bond_dev, slave_dev);
+ break;
+ default:
+ res = -EOPNOTSUPP;
}
+
+ dev_put(slave_dev);
}
-}
-static int bond_info_seq_show(struct seq_file *seq, void *v)
-{
- if (v == SEQ_START_TOKEN) {
- seq_printf(seq, "%s\n", version);
- bond_info_show_master(seq, seq->private);
- } else {
- bond_info_show_slave(seq, v);
+ if (res < 0) {
+ /* The ioctl failed, so there's no point in changing the
+ * orig_app_abi_ver. We'll restore it's value just in case
+ * we've changed it earlier in this function.
+ */
+ orig_app_abi_ver = prev_abi_ver;
}
- return 0;
+ return res;
}
-static struct seq_operations bond_info_seq_ops = {
- .start = bond_info_seq_start,
- .next = bond_info_seq_next,
- .stop = bond_info_seq_stop,
- .show = bond_info_seq_show,
-};
-
-static int bond_info_open(struct inode *inode, struct file *file)
+static void bond_set_multicast_list(struct net_device *bond_dev)
{
- struct seq_file *seq;
- struct proc_dir_entry *proc;
- int rc;
-
- rc = seq_open(file, &bond_info_seq_ops);
- if (!rc) {
- /* recover the pointer buried in proc_dir_entry data */
- seq = file->private_data;
- proc = PDE(inode);
- seq->private = proc->data;
- }
- return rc;
-}
+ struct bonding *bond = bond_dev->priv;
+ struct dev_mc_list *dmi;
-static struct file_operations bond_info_fops = {
- .owner = THIS_MODULE,
- .open = bond_info_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = seq_release,
-};
+ write_lock_bh(&bond->lock);
-static int bond_create_proc_info(struct bonding *bond)
-{
- struct net_device *dev = bond->device;
+ /*
+ * Do promisc before checking multicast_mode
+ */
+ if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC)) {
+ bond_set_promiscuity(bond, 1);
+ }
- if (bond_proc_dir) {
- bond->bond_proc_file = create_proc_entry(dev->name,
- S_IRUGO,
- bond_proc_dir);
- if (bond->bond_proc_file == NULL) {
- printk(KERN_WARNING
- "%s: Cannot create /proc/net/bonding/%s\n",
- dev->name, dev->name);
- } else {
- bond->bond_proc_file->data = bond;
- bond->bond_proc_file->proc_fops = &bond_info_fops;
- bond->bond_proc_file->owner = THIS_MODULE;
- memcpy(bond->procdir_name, dev->name, IFNAMSIZ);
- }
+ if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC)) {
+ bond_set_promiscuity(bond, -1);
}
- return 0;
-}
+ /* set allmulti flag to slaves */
+ if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI)) {
+ bond_set_allmulti(bond, 1);
+ }
-static void bond_destroy_proc_info(struct bonding *bond)
-{
- if (bond_proc_dir && bond->bond_proc_file) {
- remove_proc_entry(bond->procdir_name, bond_proc_dir);
- memset(bond->procdir_name, 0, IFNAMSIZ);
- bond->bond_proc_file = NULL;
+ if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI)) {
+ bond_set_allmulti(bond, -1);
}
-}
-/* Create the bonding directory under /proc/net, if doesn't exist yet.
- * Caller must hold rtnl_lock.
- */
-static void bond_create_proc_dir(void)
-{
- int len = strlen(DRV_NAME);
+ bond->flags = bond_dev->flags;
- for (bond_proc_dir = proc_net->subdir; bond_proc_dir;
- bond_proc_dir = bond_proc_dir->next) {
- if ((bond_proc_dir->namelen == len) &&
- !memcmp(bond_proc_dir->name, DRV_NAME, len)) {
- break;
+ /* looking for addresses to add to slaves' mc list */
+ for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
+ if (!bond_mc_list_find_dmi(dmi, bond->mc_list)) {
+ bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
}
}
- if (!bond_proc_dir) {
- bond_proc_dir = proc_mkdir(DRV_NAME, proc_net);
- if (bond_proc_dir) {
- bond_proc_dir->owner = THIS_MODULE;
- } else {
- printk(KERN_WARNING DRV_NAME
- ": Warning: cannot create /proc/net/%s\n",
- DRV_NAME);
+ /* looking for addresses to delete from slaves' list */
+ for (dmi = bond->mc_list; dmi; dmi = dmi->next) {
+ if (!bond_mc_list_find_dmi(dmi, bond_dev->mc_list)) {
+ bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
}
}
+
+ /* save master's multicast list */
+ bond_mc_list_destroy(bond);
+ bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC);
+
+ write_unlock_bh(&bond->lock);
}
-/* Destroy the bonding directory under /proc/net, if empty.
- * Caller must hold rtnl_lock.
+/*
+ * Change the MTU of all of a master's slaves to match the master
*/
-static void bond_destroy_proc_dir(void)
+static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
{
- struct proc_dir_entry *de;
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *stop_at;
+ int res = 0;
+ int i;
- if (!bond_proc_dir) {
- return;
- }
+ dprintk("bond=%p, name=%s, new_mtu=%d\n", bond,
+ (bond_dev ? bond_dev->name : "None"), new_mtu);
- /* verify that the /proc dir is empty */
- for (de = bond_proc_dir->subdir; de; de = de->next) {
- /* ignore . and .. */
- if (*(de->name) != '.') {
- break;
+ /* Can't hold bond->lock with bh disabled here since
+ * some base drivers panic. On the other hand we can't
+ * hold bond->lock without bh disabled because we'll
+ * deadlock. The only solution is to rely on the fact
+ * that we're under rtnl_lock here, and the slaves
+ * list won't change. This doesn't solve the problem
+ * of setting the slave's MTU while it is
+ * transmitting, but the assumption is that the base
+ * driver can handle that.
+ *
+ * TODO: figure out a way to safely iterate the slaves
+ * list, but without holding a lock around the actual
+ * call to the base driver.
+ */
+
+ bond_for_each_slave(bond, slave, i) {
+ dprintk("s %p s->p %p c_m %p\n", slave,
+ slave->prev, slave->dev->change_mtu);
+ if (slave->dev->change_mtu) {
+ res = slave->dev->change_mtu(slave->dev, new_mtu);
+ } else {
+ slave->dev->mtu = new_mtu;
+ res = 0;
+ }
+
+ if (res) {
+ /* If we failed to set the slave's mtu to the new value
+ * we must abort the operation even in ACTIVE_BACKUP
+ * mode, because if we allow the backup slaves to have
+ * different mtu values than the active slave we'll
+ * need to change their mtu when doing a failover. That
+ * means changing their mtu from timer context, which
+ * is probably not a good idea.
+ */
+ dprintk("err %d %s\n", res, slave->dev->name);
+ goto unwind;
}
}
- if (de) {
- if (bond_proc_dir->owner == THIS_MODULE) {
- bond_proc_dir->owner = NULL;
+ bond_dev->mtu = new_mtu;
+
+ return 0;
+
+unwind:
+ /* unwind from head to the slave that failed */
+ stop_at = slave;
+ bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
+ int tmp_res;
+
+ if (slave->dev->change_mtu) {
+ tmp_res = slave->dev->change_mtu(slave->dev, bond_dev->mtu);
+ if (tmp_res) {
+ dprintk("unwind err %d dev %s\n", tmp_res,
+ slave->dev->name);
+ }
+ } else {
+ slave->dev->mtu = bond_dev->mtu;
}
- } else {
- remove_proc_entry(DRV_NAME, proc_net);
- bond_proc_dir = NULL;
}
+
+ return res;
}
-#endif /* CONFIG_PROC_FS */
/*
* Change HW address
@@ -3639,263 +3942,404 @@
* downing the master releases all slaves. We can make bonds full of
* bonding devices to test this, however.
*/
-static inline int
-bond_set_mac_address(struct net_device *dev, void *addr)
+static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
{
- struct bonding *bond = dev->priv;
+ struct bonding *bond = bond_dev->priv;
struct sockaddr *sa = addr, tmp_sa;
- struct slave *slave;
- int error;
+ struct slave *slave, *stop_at;
+ int res = 0;
+ int i;
- dprintk(KERN_INFO "bond_set_mac_address %p %s\n", dev,
- dev->name);
+ dprintk("bond=%p, name=%s\n", bond, (bond_dev ? bond_dev->name : "None"));
if (!is_valid_ether_addr(sa->sa_data)) {
return -EADDRNOTAVAIL;
}
- for (slave = bond->prev; slave != (struct slave *)bond;
- slave = slave->prev) {
- dprintk(KERN_INFO "bond_set_mac: slave %p %s\n", slave,
- slave->dev->name);
+ /* Can't hold bond->lock with bh disabled here since
+ * some base drivers panic. On the other hand we can't
+ * hold bond->lock without bh disabled because we'll
+ * deadlock. The only solution is to rely on the fact
+ * that we're under rtnl_lock here, and the slaves
+ * list won't change. This doesn't solve the problem
+ * of setting the slave's hw address while it is
+ * transmitting, but the assumption is that the base
+ * driver can handle that.
+ *
+ * TODO: figure out a way to safely iterate the slaves
+ * list, but without holding a lock around the actual
+ * call to the base driver.
+ */
+
+ bond_for_each_slave(bond, slave, i) {
+ dprintk("slave %p %s\n", slave, slave->dev->name);
+
if (slave->dev->set_mac_address == NULL) {
- error = -EOPNOTSUPP;
- dprintk(KERN_INFO "bond_set_mac EOPNOTSUPP %s\n",
- slave->dev->name);
+ res = -EOPNOTSUPP;
+ dprintk("EOPNOTSUPP %s\n", slave->dev->name);
goto unwind;
}
- error = slave->dev->set_mac_address(slave->dev, addr);
- if (error) {
- /* TODO: consider downing the slave
+ res = slave->dev->set_mac_address(slave->dev, addr);
+ if (res) {
+ /* TODO: consider downing the slave
* and retry ?
* User should expect communications
* breakage anyway until ARP finish
* updating, so...
*/
- dprintk(KERN_INFO "bond_set_mac err %d %s\n",
- error, slave->dev->name);
+ dprintk("err %d %s\n", res, slave->dev->name);
goto unwind;
}
}
/* success */
- memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
+ memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
return 0;
unwind:
- memcpy(tmp_sa.sa_data, dev->dev_addr, dev->addr_len);
- tmp_sa.sa_family = dev->type;
+ memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
+ tmp_sa.sa_family = bond_dev->type;
+
+ /* unwind from head to the slave that failed */
+ stop_at = slave;
+ bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
+ int tmp_res;
+
+ tmp_res = slave->dev->set_mac_address(slave->dev, &tmp_sa);
+ if (tmp_res) {
+ dprintk("unwind err %d dev %s\n", tmp_res,
+ slave->dev->name);
+ }
+ }
+
+ return res;
+}
+
+static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *start_at;
+ int i;
+ int res = 1;
+
+ read_lock(&bond->lock);
+
+ if (!BOND_IS_OK(bond)) {
+ goto out;
+ }
+
+ read_lock(&bond->curr_slave_lock);
+ slave = start_at = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
+
+ if (!slave) {
+ goto out;
+ }
- for (slave = slave->next; slave != bond->next;
- slave = slave->next) {
- int tmp_error;
+ bond_for_each_slave_from(bond, slave, i, start_at) {
+ if (IS_UP(slave->dev) &&
+ (slave->link == BOND_LINK_UP) &&
+ (slave->state == BOND_STATE_ACTIVE)) {
+ res = bond_dev_queue_xmit(bond, skb, slave->dev);
+
+ write_lock(&bond->curr_slave_lock);
+ bond->curr_active_slave = slave->next;
+ write_unlock(&bond->curr_slave_lock);
- tmp_error = slave->dev->set_mac_address(slave->dev, &tmp_sa);
- if (tmp_error) {
- dprintk(KERN_INFO "bond_set_mac_address: "
- "unwind err %d dev %s\n",
- tmp_error, slave->dev->name);
+ break;
}
}
- return error;
+
+out:
+ if (res) {
+ /* no suitable interface, frame not sent */
+ dev_kfree_skb(skb);
+ }
+ read_unlock(&bond->lock);
+ return 0;
}
/*
- * Change the MTU of all of a master's slaves to match the master
+ * in active-backup mode, we know that bond->curr_active_slave is always valid if
+ * the bond has a usable interface.
*/
-static inline int
-bond_change_mtu(struct net_device *dev, int newmtu)
+static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
{
- bonding_t *bond = dev->priv;
- slave_t *slave;
- int error;
-
- dprintk(KERN_INFO "CM: b %p nm %d\n", bond, newmtu);
- for (slave = bond->prev; slave != (slave_t *)bond;
- slave = slave->prev) {
- dprintk(KERN_INFO "CM: s %p s->p %p c_m %p\n", slave,
- slave->prev, slave->dev->change_mtu);
- if (slave->dev->change_mtu) {
- error = slave->dev->change_mtu(slave->dev, newmtu);
- } else {
- slave->dev->mtu = newmtu;
- error = 0;
- }
+ struct bonding *bond = bond_dev->priv;
+ int res = 1;
- if (error) {
- /* If we failed to set the slave's mtu to the new value
- * we must abort the operation even in ACTIVE_BACKUP
- * mode, because if we allow the backup slaves to have
- * different mtu values than the active slave we'll
- * need to change their mtu when doing a failover. That
- * means changing their mtu from timer context, which
- * is probably not a good idea.
- */
- dprintk(KERN_INFO "bond_change_mtu err %d %s\n",
- error, slave->dev->name);
- goto unwind;
- }
+ /* if we are sending arp packets, try to at least
+ identify our own ip address */
+ if (bond->params.arp_interval && !my_ip &&
+ (skb->protocol == __constant_htons(ETH_P_ARP))) {
+ char *the_ip = (char *)skb->data +
+ sizeof(struct ethhdr) +
+ sizeof(struct arphdr) +
+ ETH_ALEN;
+ memcpy(&my_ip, the_ip, 4);
}
- dev->mtu = newmtu;
+ read_lock(&bond->lock);
+ read_lock(&bond->curr_slave_lock);
+
+ if (!BOND_IS_OK(bond)) {
+ goto out;
+ }
+
+ if (bond->curr_active_slave) { /* one usable interface */
+ res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
+ }
+
+out:
+ if (res) {
+ /* no suitable interface, frame not sent */
+ dev_kfree_skb(skb);
+ }
+ read_unlock(&bond->curr_slave_lock);
+ read_unlock(&bond->lock);
return 0;
+}
+/*
+ * in XOR mode, we determine the output device by performing xor on
+ * the source and destination hw adresses. If this device is not
+ * enabled, find the next slave following this xor slave.
+ */
+static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
+{
+ struct bonding *bond = bond_dev->priv;
+ struct ethhdr *data = (struct ethhdr *)skb->data;
+ struct slave *slave, *start_at;
+ int slave_no;
+ int i;
+ int res = 1;
-unwind:
- for (slave = slave->next; slave != bond->next;
- slave = slave->next) {
+ read_lock(&bond->lock);
- if (slave->dev->change_mtu) {
- slave->dev->change_mtu(slave->dev, dev->mtu);
- } else {
- slave->dev->mtu = dev->mtu;
+ if (!BOND_IS_OK(bond)) {
+ goto out;
+ }
+
+ slave_no = (data->h_dest[5]^bond_dev->dev_addr[5]) % bond->slave_cnt;
+
+ bond_for_each_slave(bond, slave, i) {
+ slave_no--;
+ if (slave_no < 0) {
+ break;
+ }
+ }
+
+ start_at = slave;
+
+ bond_for_each_slave_from(bond, slave, i, start_at) {
+ if (IS_UP(slave->dev) &&
+ (slave->link == BOND_LINK_UP) &&
+ (slave->state == BOND_STATE_ACTIVE)) {
+ res = bond_dev_queue_xmit(bond, skb, slave->dev);
+ break;
}
}
- return error;
+out:
+ if (res) {
+ /* no suitable interface, frame not sent */
+ dev_kfree_skb(skb);
+ }
+ read_unlock(&bond->lock);
+ return 0;
}
/*
- * Change device name
+ * in broadcast mode, we send everything to all usable interfaces.
*/
-static inline int bond_event_changename(struct bonding *bond)
+static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
{
-#ifdef CONFIG_PROC_FS
- bond_destroy_proc_info(bond);
- bond_create_proc_info(bond);
-#endif
+ struct bonding *bond = bond_dev->priv;
+ struct slave *slave, *start_at;
+ struct net_device *tx_dev = NULL;
+ int i;
+ int res = 1;
- return NOTIFY_DONE;
-}
+ read_lock(&bond->lock);
-static int bond_master_netdev_event(unsigned long event, struct net_device *event_dev)
-{
- struct bonding *bond, *event_bond = NULL;
+ if (!BOND_IS_OK(bond)) {
+ goto out;
+ }
- list_for_each_entry(bond, &bond_dev_list, bond_list) {
- if (bond == event_dev->priv) {
- event_bond = bond;
- break;
- }
+ read_lock(&bond->curr_slave_lock);
+ start_at = bond->curr_active_slave;
+ read_unlock(&bond->curr_slave_lock);
+
+ if (!start_at) {
+ goto out;
}
- if (event_bond == NULL) {
- return NOTIFY_DONE;
+ bond_for_each_slave_from(bond, slave, i, start_at) {
+ if (IS_UP(slave->dev) &&
+ (slave->link == BOND_LINK_UP) &&
+ (slave->state == BOND_STATE_ACTIVE)) {
+ if (tx_dev) {
+ struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
+ if (!skb2) {
+ printk(KERN_ERR DRV_NAME
+ ": Error: bond_xmit_broadcast(): "
+ "skb_clone() failed\n");
+ continue;
+ }
+
+ res = bond_dev_queue_xmit(bond, skb2, tx_dev);
+ if (res) {
+ dev_kfree_skb(skb2);
+ continue;
+ }
+ }
+ tx_dev = slave->dev;
+ }
}
- switch (event) {
- case NETDEV_CHANGENAME:
- return bond_event_changename(event_bond);
- case NETDEV_UNREGISTER:
- /*
- * TODO: remove a bond from the list?
- */
- break;
- default:
- break;
+ if (tx_dev) {
+ res = bond_dev_queue_xmit(bond, skb, tx_dev);
}
- return NOTIFY_DONE;
+out:
+ if (res) {
+ /* no suitable interface, frame not sent */
+ dev_kfree_skb(skb);
+ }
+ /* frame sent to all suitable interfaces */
+ read_unlock(&bond->lock);
+ return 0;
}
-static int bond_slave_netdev_event(unsigned long event, struct net_device *event_dev)
+#ifdef CONFIG_NET_FASTROUTE
+static int bond_accept_fastpath(struct net_device *bond_dev, struct dst_entry *dst)
{
- struct net_device *master = event_dev->master;
+ return -1;
+}
+#endif
- switch (event) {
- case NETDEV_UNREGISTER:
- if (master != NULL) {
- bond_release(master, event_dev);
- }
+/*------------------------- Device initialization ---------------------------*/
+
+/*
+ * set bond mode specific net device operations
+ */
+static inline void bond_set_mode_ops(struct net_device *bond_dev, int mode)
+{
+ switch (mode) {
+ case BOND_MODE_ROUNDROBIN:
+ bond_dev->hard_start_xmit = bond_xmit_roundrobin;
break;
- case NETDEV_CHANGE:
- /*
- * TODO: is this what we get if somebody
- * sets up a hierarchical bond, then rmmod's
- * one of the slave bonding devices?
- */
+ case BOND_MODE_ACTIVEBACKUP:
+ bond_dev->hard_start_xmit = bond_xmit_activebackup;
break;
- case NETDEV_DOWN:
- /*
- * ... Or is it this?
- */
+ case BOND_MODE_XOR:
+ bond_dev->hard_start_xmit = bond_xmit_xor;
break;
- case NETDEV_CHANGEMTU:
- /*
- * TODO: Should slaves be allowed to
- * independently alter their MTU? For
- * an active-backup bond, slaves need
- * not be the same type of device, so
- * MTUs may vary. For other modes,
- * slaves arguably should have the
- * same MTUs. To do this, we'd need to
- * take over the slave's change_mtu
- * function for the duration of their
- * servitude.
- */
+ case BOND_MODE_BROADCAST:
+ bond_dev->hard_start_xmit = bond_xmit_broadcast;
break;
- case NETDEV_CHANGENAME:
- /*
- * TODO: handle changing the primary's name
- */
+ case BOND_MODE_8023AD:
+ bond_dev->hard_start_xmit = bond_3ad_xmit_xor;
+ break;
+ case BOND_MODE_TLB:
+ case BOND_MODE_ALB:
+ bond_dev->hard_start_xmit = bond_alb_xmit;
+ bond_dev->set_mac_address = bond_alb_set_mac_address;
break;
default:
+ /* Should never happen, mode already checked */
+ printk(KERN_ERR DRV_NAME
+ ": Error: Unknown bonding mode %d\n",
+ mode);
break;
}
-
- return NOTIFY_DONE;
}
/*
- * bond_netdev_event: handle netdev notifier chain events.
- *
- * This function receives events for the netdev chain. The caller (an
- * ioctl handler calling notifier_call_chain) holds the necessary
- * locks for us to safely manipulate the slave devices (RTNL lock,
- * dev_probe_lock).
+ * Does not allocate but creates a /proc entry.
+ * Allowed to fail.
*/
-static int bond_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
+static int __init bond_init(struct net_device *bond_dev, struct bond_params *params)
{
- struct net_device *event_dev = (struct net_device *)ptr;
- unsigned short flags;
- int res = NOTIFY_DONE;
+ struct bonding *bond = bond_dev->priv;
- dprintk(KERN_INFO "bond_netdev_event n_b %p ev %lx ptr %p\n",
- this, event, ptr);
+ dprintk("Begin bond_init for %s\n", bond_dev->name);
- flags = event_dev->flags & (IFF_MASTER | IFF_SLAVE);
- switch (flags) {
- case IFF_MASTER:
- res = bond_master_netdev_event(event, event_dev);
- break;
- case IFF_SLAVE:
- res = bond_slave_netdev_event(event, event_dev);
- break;
- default:
- /* A master that is also a slave ? */
- break;
- }
+ /* initialize rwlocks */
+ rwlock_init(&bond->lock);
+ rwlock_init(&bond->curr_slave_lock);
- return res;
-}
+ bond->params = *params; /* copy params struct */
-static struct notifier_block bond_netdev_notifier = {
- .notifier_call = bond_netdev_event,
-};
+ /* Initialize pointers */
+ bond->first_slave = NULL;
+ bond->curr_active_slave = NULL;
+ bond->current_arp_slave = NULL;
+ bond->primary_slave = NULL;
+ bond->dev = bond_dev;
+ INIT_LIST_HEAD(&bond->vlan_list);
+
+ /* Initialize the device entry points */
+ bond_dev->open = bond_open;
+ bond_dev->stop = bond_close;
+ bond_dev->get_stats = bond_get_stats;
+ bond_dev->do_ioctl = bond_do_ioctl;
+ bond_dev->set_multicast_list = bond_set_multicast_list;
+ bond_dev->change_mtu = bond_change_mtu;
+ bond_dev->set_mac_address = bond_set_mac_address;
+
+ bond_set_mode_ops(bond_dev, bond->params.mode);
+
+#ifdef CONFIG_NET_FASTROUTE
+ bond_dev->accept_fastpath = bond_accept_fastpath;
+#endif
+
+ /* Initialize the device options */
+ bond_dev->tx_queue_len = 0;
+ bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
+
+ /* At first, we block adding VLANs. That's the only way to
+ * prevent problems that occur when adding VLANs over an
+ * empty bond. The block will be removed once non-challenged
+ * slaves are enslaved.
+ */
+ bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
+
+ /* By default, we declare the bond to be fully
+ * VLAN hardware accelerated capable. Special
+ * care is taken in the various xmit functions
+ * when there are slaves that are not hw accel
+ * capable
+ */
+ bond_dev->vlan_rx_register = bond_vlan_rx_register;
+ bond_dev->vlan_rx_add_vid = bond_vlan_rx_add_vid;
+ bond_dev->vlan_rx_kill_vid = bond_vlan_rx_kill_vid;
+ bond_dev->features |= (NETIF_F_HW_VLAN_TX |
+ NETIF_F_HW_VLAN_RX |
+ NETIF_F_HW_VLAN_FILTER);
+
+#ifdef CONFIG_PROC_FS
+ bond_create_proc_entry(bond);
+#endif
+
+ list_add_tail(&bond->bond_list, &bond_dev_list);
+
+ return 0;
+}
/* De-initialize device specific data.
* Caller must hold rtnl_lock.
*/
-static inline void bond_deinit(struct net_device *dev)
+static inline void bond_deinit(struct net_device *bond_dev)
{
- struct bonding *bond = dev->priv;
+ struct bonding *bond = bond_dev->priv;
list_del(&bond->bond_list);
#ifdef CONFIG_PROC_FS
- bond_destroy_proc_info(bond);
+ bond_remove_proc_entry(bond);
#endif
}
@@ -3907,11 +4351,11 @@
struct bonding *bond, *nxt;
list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) {
- struct net_device *dev = bond->device;
+ struct net_device *bond_dev = bond->dev;
- unregister_netdevice(dev);
- bond_deinit(dev);
- free_netdev(dev);
+ unregister_netdevice(bond_dev);
+ bond_deinit(bond_dev);
+ free_netdev(bond_dev);
}
#ifdef CONFIG_PROC_FS
@@ -3919,123 +4363,21 @@
#endif
}
-/*
- * Does not allocate but creates a /proc entry.
- * Allowed to fail.
- */
-static int __init bond_init(struct net_device *dev)
-{
- struct bonding *bond;
- int count;
-
-#ifdef BONDING_DEBUG
- printk (KERN_INFO "Begin bond_init for %s\n", dev->name);
-#endif
- bond = dev->priv;
-
- /* initialize rwlocks */
- rwlock_init(&bond->lock);
- rwlock_init(&bond->ptrlock);
-
- /* Initialize pointers */
- bond->next = bond->prev = (slave_t *)bond;
- bond->current_slave = NULL;
- bond->current_arp_slave = NULL;
- bond->device = dev;
-
- /* Initialize the device structure. */
- dev->set_mac_address = bond_set_mac_address;
-
- switch (bond_mode) {
- case BOND_MODE_ACTIVEBACKUP:
- dev->hard_start_xmit = bond_xmit_activebackup;
- break;
- case BOND_MODE_ROUNDROBIN:
- dev->hard_start_xmit = bond_xmit_roundrobin;
- break;
- case BOND_MODE_XOR:
- dev->hard_start_xmit = bond_xmit_xor;
- break;
- case BOND_MODE_BROADCAST:
- dev->hard_start_xmit = bond_xmit_broadcast;
- break;
- case BOND_MODE_8023AD:
- dev->hard_start_xmit = bond_3ad_xmit_xor;
- break;
- case BOND_MODE_TLB:
- case BOND_MODE_ALB:
- dev->hard_start_xmit = bond_alb_xmit;
- dev->set_mac_address = bond_alb_set_mac_address;
- break;
- default:
- printk(KERN_ERR "Unknown bonding mode %d\n", bond_mode);
- return -EINVAL;
- }
-
- dev->get_stats = bond_get_stats;
- dev->open = bond_open;
- dev->stop = bond_close;
- dev->set_multicast_list = set_multicast_list;
- dev->do_ioctl = bond_ioctl;
- dev->change_mtu = bond_change_mtu;
- dev->tx_queue_len = 0;
- dev->flags |= IFF_MASTER|IFF_MULTICAST;
-#ifdef CONFIG_NET_FASTROUTE
- dev->accept_fastpath = bond_accept_fastpath;
-#endif
-
- printk(KERN_INFO "%s registered with", dev->name);
- if (miimon > 0) {
- printk(" MII link monitoring set to %d ms", miimon);
- updelay /= miimon;
- downdelay /= miimon;
- } else {
- printk("out MII link monitoring");
- }
- printk(", in %s mode.\n", bond_mode_name());
-
- printk(KERN_INFO "%s registered with", dev->name);
- if (arp_interval > 0) {
- printk(" ARP monitoring set to %d ms with %d target(s):",
- arp_interval, arp_ip_count);
- for (count=0 ; count<arp_ip_count ; count++)
- printk (" %s", arp_ip_target[count]);
- printk("\n");
- } else {
- printk("out ARP monitoring\n");
- }
-
-#ifdef CONFIG_PROC_FS
- bond_create_proc_info(bond);
-#endif
-
- list_add_tail(&bond->bond_list, &bond_dev_list);
-
- return 0;
-}
-
-/*
-static int __init bond_probe(struct net_device *dev)
-{
- bond_init(dev);
- return 0;
-}
- */
+/*------------------------- Module initialization ---------------------------*/
/*
* Convert string input module parms. Accept either the
* number of the mode or its string name.
*/
-static inline int
-bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl)
+static inline int bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl)
{
int i;
- for (i = 0; tbl[i].modename != NULL; i++) {
+ for (i = 0; tbl[i].modename; i++) {
if ((isdigit(*mode_arg) &&
- tbl[i].mode == simple_strtol(mode_arg, NULL, 0)) ||
- (0 == strncmp(mode_arg, tbl[i].modename,
- strlen(tbl[i].modename)))) {
+ tbl[i].mode == simple_strtol(mode_arg, NULL, 0)) ||
+ (strncmp(mode_arg, tbl[i].modename,
+ strlen(tbl[i].modename)) == 0)) {
return tbl[i].mode;
}
}
@@ -4043,275 +4385,281 @@
return -1;
}
-
-static int __init bonding_init(void)
+static int bond_check_params(struct bond_params *params)
{
- int no;
- int err;
-
- printk(KERN_INFO "%s", version);
-
/*
* Convert string parameters.
*/
if (mode) {
bond_mode = bond_parse_parm(mode, bond_mode_tbl);
if (bond_mode == -1) {
- printk(KERN_WARNING
- "bonding_init(): Invalid bonding mode \"%s\"\n",
+ printk(KERN_ERR DRV_NAME
+ ": Error: Invalid bonding mode \"%s\"\n",
mode == NULL ? "NULL" : mode);
return -EINVAL;
}
}
- if (USES_PRIMARY(bond_mode)) {
- multicast_mode = BOND_MULTICAST_ACTIVE;
- } else {
- multicast_mode = BOND_MULTICAST_ALL;
- }
-
- if (multicast) {
- multicast_mode = bond_parse_parm(multicast, bond_mc_tbl);
- if (multicast_mode == -1) {
- printk(KERN_WARNING
- "bonding_init(): Invalid multicast mode \"%s\"\n",
- multicast == NULL ? "NULL" : multicast);
- return -EINVAL;
- }
- }
-
if (lacp_rate) {
if (bond_mode != BOND_MODE_8023AD) {
- printk(KERN_WARNING
- "lacp_rate param is irrelevant in mode %s\n",
- bond_mode_name());
+ printk(KERN_INFO DRV_NAME
+ ": lacp_rate param is irrelevant in mode %s\n",
+ bond_mode_name(bond_mode));
} else {
lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
if (lacp_fast == -1) {
- printk(KERN_WARNING
- "bonding_init(): Invalid lacp rate "
- "\"%s\"\n",
+ printk(KERN_ERR DRV_NAME
+ ": Error: Invalid lacp rate \"%s\"\n",
lacp_rate == NULL ? "NULL" : lacp_rate);
-
return -EINVAL;
}
}
}
if (max_bonds < 1 || max_bonds > INT_MAX) {
- printk(KERN_WARNING
- "bonding_init(): max_bonds (%d) not in range %d-%d, "
- "so it was reset to BOND_DEFAULT_MAX_BONDS (%d)",
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: max_bonds (%d) not in range %d-%d, so it "
+ "was reset to BOND_DEFAULT_MAX_BONDS (%d)",
max_bonds, 1, INT_MAX, BOND_DEFAULT_MAX_BONDS);
max_bonds = BOND_DEFAULT_MAX_BONDS;
}
if (miimon < 0) {
- printk(KERN_WARNING
- "bonding_init(): miimon module parameter (%d), "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: miimon module parameter (%d), "
"not in range 0-%d, so it was reset to %d\n",
miimon, INT_MAX, BOND_LINK_MON_INTERV);
miimon = BOND_LINK_MON_INTERV;
}
if (updelay < 0) {
- printk(KERN_WARNING
- "bonding_init(): updelay module parameter (%d), "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: updelay module parameter (%d), "
"not in range 0-%d, so it was reset to 0\n",
updelay, INT_MAX);
updelay = 0;
}
if (downdelay < 0) {
- printk(KERN_WARNING
- "bonding_init(): downdelay module parameter (%d), "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: downdelay module parameter (%d), "
"not in range 0-%d, so it was reset to 0\n",
downdelay, INT_MAX);
downdelay = 0;
}
+ if ((use_carrier != 0) && (use_carrier != 1)) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: use_carrier module parameter (%d), "
+ "not of valid value (0/1), so it was set to 1\n",
+ use_carrier);
+ use_carrier = 1;
+ }
+
/* reset values for 802.3ad */
if (bond_mode == BOND_MODE_8023AD) {
- if (arp_interval != 0) {
- printk(KERN_WARNING "bonding_init(): ARP monitoring"
- "can't be used simultaneously with 802.3ad, "
- "disabling ARP monitoring\n");
- arp_interval = 0;
- }
-
- if (miimon == 0) {
- printk(KERN_ERR
- "bonding_init(): miimon must be specified, "
- "otherwise bonding will not detect link failure, "
- "speed and duplex which are essential "
- "for 802.3ad operation\n");
- printk(KERN_ERR "Forcing miimon to 100msec\n");
+ if (!miimon) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: miimon must be specified, "
+ "otherwise bonding will not detect link "
+ "failure, speed and duplex which are "
+ "essential for 802.3ad operation\n");
+ printk(KERN_WARNING "Forcing miimon to 100msec\n");
miimon = 100;
}
-
- if (multicast_mode != BOND_MULTICAST_ALL) {
- printk(KERN_ERR
- "bonding_init(): Multicast mode must "
- "be set to ALL for 802.3ad\n");
- printk(KERN_ERR "Forcing Multicast mode to ALL\n");
- multicast_mode = BOND_MULTICAST_ALL;
- }
}
/* reset values for TLB/ALB */
if ((bond_mode == BOND_MODE_TLB) ||
(bond_mode == BOND_MODE_ALB)) {
- if (miimon == 0) {
- printk(KERN_ERR
- "bonding_init(): miimon must be specified, "
- "otherwise bonding will not detect link failure "
- "and link speed which are essential "
+ if (!miimon) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: miimon must be specified, "
+ "otherwise bonding will not detect link "
+ "failure and link speed which are essential "
"for TLB/ALB load balancing\n");
- printk(KERN_ERR "Forcing miimon to 100msec\n");
+ printk(KERN_WARNING "Forcing miimon to 100msec\n");
miimon = 100;
}
-
- if (multicast_mode != BOND_MULTICAST_ACTIVE) {
- printk(KERN_ERR
- "bonding_init(): Multicast mode must "
- "be set to ACTIVE for TLB/ALB\n");
- printk(KERN_ERR "Forcing Multicast mode to ACTIVE\n");
- multicast_mode = BOND_MULTICAST_ACTIVE;
- }
}
if (bond_mode == BOND_MODE_ALB) {
- printk(KERN_INFO
- "In ALB mode you might experience client disconnections"
- " upon reconnection of a link if the bonding module"
- " updelay parameter (%d msec) is incompatible with the"
- " forwarding delay time of the switch\n", updelay);
+ printk(KERN_NOTICE DRV_NAME
+ ": In ALB mode you might experience client "
+ "disconnections upon reconnection of a link if the "
+ "bonding module updelay parameter (%d msec) is "
+ "incompatible with the forwarding delay time of the "
+ "switch\n",
+ updelay);
}
- if (miimon == 0) {
- if ((updelay != 0) || (downdelay != 0)) {
+ if (!miimon) {
+ if (updelay || downdelay) {
/* just warn the user the up/down delay will have
* no effect since miimon is zero...
*/
- printk(KERN_WARNING
- "bonding_init(): miimon module parameter not "
- "set and updelay (%d) or downdelay (%d) module "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: miimon module parameter not set "
+ "and updelay (%d) or downdelay (%d) module "
"parameter is set; updelay and downdelay have "
"no effect unless miimon is set\n",
- updelay, downdelay);
+ updelay, downdelay);
}
} else {
/* don't allow arp monitoring */
- if (arp_interval != 0) {
- printk(KERN_WARNING
- "bonding_init(): miimon (%d) and arp_interval "
- "(%d) can't be used simultaneously, "
- "disabling ARP monitoring\n",
- miimon, arp_interval);
+ if (arp_interval) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: miimon (%d) and arp_interval (%d) "
+ "can't be used simultaneously, disabling ARP "
+ "monitoring\n",
+ miimon, arp_interval);
arp_interval = 0;
}
if ((updelay % miimon) != 0) {
- /* updelay will be rounded in bond_init() when it
- * is divided by miimon, we just inform user here
- */
- printk(KERN_WARNING
- "bonding_init(): updelay (%d) is not a multiple "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: updelay (%d) is not a multiple "
"of miimon (%d), updelay rounded to %d ms\n",
- updelay, miimon, (updelay / miimon) * miimon);
+ updelay, miimon, (updelay / miimon) * miimon);
}
+ updelay /= miimon;
+
if ((downdelay % miimon) != 0) {
- /* downdelay will be rounded in bond_init() when it
- * is divided by miimon, we just inform user here
- */
- printk(KERN_WARNING
- "bonding_init(): downdelay (%d) is not a "
- "multiple of miimon (%d), downdelay rounded "
- "to %d ms\n",
- downdelay, miimon,
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: downdelay (%d) is not a multiple "
+ "of miimon (%d), downdelay rounded to %d ms\n",
+ downdelay, miimon,
(downdelay / miimon) * miimon);
}
+
+ downdelay /= miimon;
}
if (arp_interval < 0) {
- printk(KERN_WARNING
- "bonding_init(): arp_interval module parameter (%d), "
- "not in range 0-%d, so it was reset to %d\n",
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: arp_interval module parameter (%d) "
+ ", not in range 0-%d, so it was reset to %d\n",
arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
arp_interval = BOND_LINK_ARP_INTERV;
}
- for (arp_ip_count=0 ;
- (arp_ip_count < MAX_ARP_IP_TARGETS) && arp_ip_target[arp_ip_count];
- arp_ip_count++ ) {
+ for (arp_ip_count = 0;
+ (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[arp_ip_count];
+ arp_ip_count++) {
/* not complete check, but should be good enough to
catch mistakes */
- if (!isdigit(arp_ip_target[arp_ip_count][0])) {
- printk(KERN_WARNING
- "bonding_init(): bad arp_ip_target module "
- "parameter (%s), ARP monitoring will not be "
- "performed\n",
- arp_ip_target[arp_ip_count]);
- arp_interval = 0;
- } else {
- u32 ip = in_aton(arp_ip_target[arp_ip_count]);
+ if (!isdigit(arp_ip_target[arp_ip_count][0])) {
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: bad arp_ip_target module parameter "
+ "(%s), ARP monitoring will not be performed\n",
+ arp_ip_target[arp_ip_count]);
+ arp_interval = 0;
+ } else {
+ u32 ip = in_aton(arp_ip_target[arp_ip_count]);
arp_target[arp_ip_count] = ip;
}
- }
-
+ }
- if ( (arp_interval > 0) && (arp_ip_count==0)) {
+ if (arp_interval && !arp_ip_count) {
/* don't allow arping if no arp_ip_target given... */
- printk(KERN_WARNING
- "bonding_init(): arp_interval module parameter "
- "(%d) specified without providing an arp_ip_target "
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: arp_interval module parameter (%d) "
+ "specified without providing an arp_ip_target "
"parameter, arp_interval was reset to 0\n",
arp_interval);
arp_interval = 0;
}
- if ((miimon == 0) && (arp_interval == 0)) {
+ if (miimon) {
+ printk(KERN_INFO DRV_NAME
+ ": MII link monitoring set to %d ms\n",
+ miimon);
+ } else if (arp_interval) {
+ int i;
+
+ printk(KERN_INFO DRV_NAME
+ ": ARP monitoring set to %d ms with %d target(s):",
+ arp_interval, arp_ip_count);
+
+ for (i = 0; i < arp_ip_count; i++)
+ printk (" %s", arp_ip_target[i]);
+
+ printk("\n");
+
+ } else {
/* miimon and arp_interval not set, we need one so things
* work as expected, see bonding.txt for details
*/
- printk(KERN_ERR
- "bonding_init(): either miimon or "
- "arp_interval and arp_ip_target module parameters "
- "must be specified, otherwise bonding will not detect "
- "link failures! see bonding.txt for details.\n");
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: either miimon or arp_interval and "
+ "arp_ip_target module parameters must be specified, "
+ "otherwise bonding will not detect link failures! see "
+ "bonding.txt for details.\n");
}
- if ((primary != NULL) && !USES_PRIMARY(bond_mode)) {
+ if (primary && !USES_PRIMARY(bond_mode)) {
/* currently, using a primary only makes sense
* in active backup, TLB or ALB modes
*/
- printk(KERN_WARNING
- "bonding_init(): %s primary device specified but has "
- "no effect in %s mode\n",
- primary, bond_mode_name());
+ printk(KERN_WARNING DRV_NAME
+ ": Warning: %s primary device specified but has no "
+ "effect in %s mode\n",
+ primary, bond_mode_name(bond_mode));
primary = NULL;
}
+ /* fill params struct with the proper values */
+ params->mode = bond_mode;
+ params->miimon = miimon;
+ params->arp_interval = arp_interval;
+ params->updelay = updelay;
+ params->downdelay = downdelay;
+ params->use_carrier = use_carrier;
+ params->lacp_fast = lacp_fast;
+ params->primary[0] = 0;
+
+ if (primary) {
+ strncpy(params->primary, primary, IFNAMSIZ);
+ params->primary[IFNAMSIZ - 1] = 0;
+ }
+
+ memcpy(params->arp_targets, arp_target, sizeof(arp_target));
+
+ return 0;
+}
+
+static int __init bonding_init(void)
+{
+ struct bond_params params;
+ int i;
+ int res;
+
+ printk(KERN_INFO "%s", version);
+
+ res = bond_check_params(¶ms);
+ if (res) {
+ return res;
+ }
+
rtnl_lock();
#ifdef CONFIG_PROC_FS
bond_create_proc_dir();
#endif
- err = 0;
- for (no = 0; no < max_bonds; no++) {
- struct net_device *dev;
-
- dev = alloc_netdev(sizeof(struct bonding), "", ether_setup);
- if (!dev) {
- err = -ENOMEM;
+ for (i = 0; i < max_bonds; i++) {
+ struct net_device *bond_dev;
+
+ bond_dev = alloc_netdev(sizeof(struct bonding), "", ether_setup);
+ if (!bond_dev) {
+ res = -ENOMEM;
goto out_err;
}
- err = dev_alloc_name(dev, "bond%d");
- if (err < 0) {
- free_netdev(dev);
+ res = dev_alloc_name(bond_dev, "bond%d");
+ if (res < 0) {
+ free_netdev(bond_dev);
goto out_err;
}
@@ -4319,18 +4667,18 @@
* /proc files), but before register_netdevice(), because we
* need to set function pointers.
*/
- err = bond_init(dev);
- if (err < 0) {
- free_netdev(dev);
+ res = bond_init(bond_dev, ¶ms);
+ if (res < 0) {
+ free_netdev(bond_dev);
goto out_err;
}
- SET_MODULE_OWNER(dev);
+ SET_MODULE_OWNER(bond_dev);
- err = register_netdevice(dev);
- if (err < 0) {
- bond_deinit(dev);
- free_netdev(dev);
+ res = register_netdevice(bond_dev);
+ if (res < 0) {
+ bond_deinit(bond_dev);
+ free_netdev(bond_dev);
goto out_err;
}
}
@@ -4346,7 +4694,7 @@
rtnl_unlock();
- return err;
+ return res;
}
static void __exit bonding_exit(void)
@@ -4362,6 +4710,8 @@
module_exit(bonding_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
+MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
+MODULE_SUPPORTED_DEVICE("most ethernet devices");
/*
* Local variables:
@@ -4370,3 +4720,4 @@
* tab-width: 8
* End:
*/
+
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)