Lines Matching refs:bond
186 static void bond_send_gratuitous_arp(struct bonding *bond);
215 * bond_add_vlan - add a new vlan id on bond
216 * @bond: bond that got the notification
221 static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
225 dprintk("bond: %s, vlan id %d\n",
226 (bond ? bond->dev->name: "None"), vlan_id);
237 write_lock_bh(&bond->lock);
239 list_add_tail(&vlan->vlan_list, &bond->vlan_list);
241 write_unlock_bh(&bond->lock);
243 dprintk("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
249 * bond_del_vlan - delete a vlan id from bond
250 * @bond: bond that got the notification
253 * returns -ENODEV if @vlan_id was not found in @bond.
255 static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
260 dprintk("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
262 write_lock_bh(&bond->lock);
264 list_for_each_entry_safe(vlan, next, &bond->vlan_list, vlan_list) {
268 if ((bond->params.mode == BOND_MODE_TLB) ||
269 (bond->params.mode == BOND_MODE_ALB)) {
270 bond_alb_clear_vlan(bond, vlan_id);
273 dprintk("removed VLAN ID %d from bond %s\n", vlan_id,
274 bond->dev->name);
278 if (list_empty(&bond->vlan_list) &&
279 (bond->slave_cnt == 0)) {
285 bond->dev->features |= NETIF_F_VLAN_CHALLENGED;
293 dprintk("couldn't find VLAN ID %d in bond %s\n", vlan_id,
294 bond->dev->name);
297 write_unlock_bh(&bond->lock);
303 * @bond: the bond we're working on
308 * Assumes bond->lock is held.
310 static int bond_has_challenged_slaves(struct bonding *bond)
315 bond_for_each_slave(bond, slave, i) {
329 * @bond: the bond we're working on
332 * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
335 * Caller must hold bond->lock
337 struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
341 if (list_empty(&bond->vlan_list)) {
346 next = list_entry(bond->vlan_list.next,
349 last = list_entry(bond->vlan_list.prev,
352 next = list_entry(bond->vlan_list.next,
366 * @bond: bond device that got this skb for tx.
370 * When the bond gets an skb to transmit that is
377 int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev)
381 if (!list_empty(&bond->vlan_list) &&
428 struct bonding *bond = bond_dev->priv;
432 bond->vlgrp = grp;
434 bond_for_each_slave(bond, slave, i) {
451 struct bonding *bond = bond_dev->priv;
455 bond_for_each_slave(bond, slave, i) {
464 res = bond_add_vlan(bond, vid);
479 struct bonding *bond = bond_dev->priv;
484 bond_for_each_slave(bond, slave, i) {
492 vlan_dev = vlan_group_get_device(bond->vlgrp, vid);
494 vlan_group_set_device(bond->vlgrp, vid, vlan_dev);
498 res = bond_del_vlan(bond, vid);
506 static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
510 write_lock_bh(&bond->lock);
512 if (list_empty(&bond->vlan_list)) {
518 slave_dev->vlan_rx_register(slave_dev, bond->vlgrp);
526 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
531 write_unlock_bh(&bond->lock);
534 static void bond_del_vlans_from_slave(struct bonding *bond, struct net_device *slave_dev)
539 write_lock_bh(&bond->lock);
541 if (list_empty(&bond->vlan_list)) {
550 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
554 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
556 vlan_group_set_device(bond->vlgrp, vlan->vlan_id, vlan_dev);
566 write_unlock_bh(&bond->lock);
578 static int bond_set_carrier(struct bonding *bond)
583 if (bond->slave_cnt == 0)
586 if (bond->params.mode == BOND_MODE_8023AD)
587 return bond_3ad_set_carrier(bond);
589 bond_for_each_slave(bond, slave, i) {
591 if (!netif_carrier_ok(bond->dev)) {
592 netif_carrier_on(bond->dev);
600 if (netif_carrier_ok(bond->dev)) {
601 netif_carrier_off(bond->dev);
688 static int bond_check_dev_link(struct bonding *bond, struct net_device *slave_dev, int reporting)
695 if (bond->params.use_carrier) {
790 static void bond_set_promiscuity(struct bonding *bond, int inc)
792 if (USES_PRIMARY(bond->params.mode)) {
794 if (bond->curr_active_slave) {
795 dev_set_promiscuity(bond->curr_active_slave->dev, inc);
800 bond_for_each_slave(bond, slave, i) {
809 static void bond_set_allmulti(struct bonding *bond, int inc)
811 if (USES_PRIMARY(bond->params.mode)) {
813 if (bond->curr_active_slave) {
814 dev_set_allmulti(bond->curr_active_slave->dev, inc);
819 bond_for_each_slave(bond, slave, i) {
829 static void bond_mc_add(struct bonding *bond, void *addr, int alen)
831 if (USES_PRIMARY(bond->params.mode)) {
833 if (bond->curr_active_slave) {
834 dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0);
839 bond_for_each_slave(bond, slave, i) {
849 static void bond_mc_delete(struct bonding *bond, void *addr, int alen)
851 if (USES_PRIMARY(bond->params.mode)) {
853 if (bond->curr_active_slave) {
854 dev_mc_delete(bond->curr_active_slave->dev, addr, alen, 0);
859 bond_for_each_slave(bond, slave, i) {
871 static void bond_resend_igmp_join_requests(struct bonding *bond)
877 in_dev = __in_dev_get_rcu(bond->dev);
888 * Totally destroys the mc_list in bond
890 static void bond_mc_list_destroy(struct bonding *bond)
894 dmi = bond->mc_list;
896 bond->mc_list = dmi->next;
898 dmi = bond->mc_list;
900 bond->mc_list = NULL;
906 static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond,
918 new_dmi->next = bond->mc_list;
919 bond->mc_list = new_dmi;
934 struct bonding *bond = bond_dev->priv;
941 if (bond->params.mode == BOND_MODE_8023AD) {
956 static void bond_mc_swap(struct bonding *bond, struct slave *new_active, struct slave *old_active)
960 if (!USES_PRIMARY(bond->params.mode)) {
968 if (bond->dev->flags & IFF_PROMISC) {
972 if (bond->dev->flags & IFF_ALLMULTI) {
976 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
982 if (bond->dev->flags & IFF_PROMISC) {
986 if (bond->dev->flags & IFF_ALLMULTI) {
990 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
993 bond_resend_igmp_join_requests(bond);
999 * @bond: our bonding struct
1003 static struct slave *bond_find_best_slave(struct bonding *bond)
1007 int mintime = bond->params.updelay;
1010 new_active = old_active = bond->curr_active_slave;
1013 if (bond->slave_cnt > 0) { /* found one slave */
1014 new_active = bond->first_slave;
1025 if ((bond->primary_slave) &&
1026 (!bond->params.arp_interval) &&
1027 (IS_UP(bond->primary_slave->dev))) {
1028 new_active = bond->primary_slave;
1034 bond_for_each_slave_from(bond, new_active, i, old_active) {
1053 * @bond: our bonding struct
1056 * Set the new slave to the bond's settings and unset them on the old
1066 void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
1068 struct slave *old_active = bond->curr_active_slave;
1076 if (USES_PRIMARY(bond->params.mode)) {
1080 bond->dev->name, new_active->dev->name,
1081 (bond->params.updelay - new_active->delay) * bond->params.miimon);
1088 if (bond->params.mode == BOND_MODE_8023AD) {
1092 if ((bond->params.mode == BOND_MODE_TLB) ||
1093 (bond->params.mode == BOND_MODE_ALB)) {
1094 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
1097 if (USES_PRIMARY(bond->params.mode)) {
1101 bond->dev->name, new_active->dev->name);
1106 if (USES_PRIMARY(bond->params.mode)) {
1107 bond_mc_swap(bond, new_active, old_active);
1110 if ((bond->params.mode == BOND_MODE_TLB) ||
1111 (bond->params.mode == BOND_MODE_ALB)) {
1112 bond_alb_handle_active_change(bond, new_active);
1118 bond->curr_active_slave = new_active;
1121 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
1129 bond_send_gratuitous_arp(bond);
1135 * @bond: our bonding struct
1144 void bond_select_active_slave(struct bonding *bond)
1149 best_slave = bond_find_best_slave(bond);
1150 if (best_slave != bond->curr_active_slave) {
1151 bond_change_active_slave(bond, best_slave);
1152 rv = bond_set_carrier(bond);
1156 if (netif_carrier_ok(bond->dev)) {
1159 bond->dev->name);
1163 bond->dev->name);
1173 * bond->lock held for writing by caller.
1175 static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
1177 if (bond->first_slave == NULL) { /* attaching the first slave */
1180 bond->first_slave = new_slave;
1182 new_slave->next = bond->first_slave;
1183 new_slave->prev = bond->first_slave->prev;
1188 bond->slave_cnt++;
1194 * belongs to <bond>.
1196 * If any slave pointer in bond was pointing to <slave>,
1199 * bond->lock held for writing by caller.
1201 static void bond_detach_slave(struct bonding *bond, struct slave *slave)
1211 if (bond->first_slave == slave) { /* slave is the first slave */
1212 if (bond->slave_cnt > 1) { /* there are more slave */
1213 bond->first_slave = slave->next;
1215 bond->first_slave = NULL; /* slave was the last one */
1221 bond->slave_cnt--;
1243 static int bond_compute_features(struct bonding *bond)
1247 struct net_device *bond_dev = bond->dev;
1251 bond_for_each_slave(bond, slave, i) {
1278 /* enslave device <slave> to bond device <master> */
1281 struct bonding *bond = bond_dev->priv;
1289 if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL &&
1296 /* bond must be initialized by bond_open() before enslaving */
1312 if (!list_empty(&bond->vlan_list)) {
1316 "bond %s\n", bond_dev->name, slave_dev->name,
1323 "long as %s is part of bond %s\n",
1330 if (bond->slave_cnt == 0) {
1332 * so remove the block of adding VLANs over the bond.
1408 if ((bond->params.mode == BOND_MODE_TLB) ||
1409 (bond->params.mode == BOND_MODE_ALB)) {
1413 res = bond_alb_init_slave(bond, new_slave);
1424 if (!USES_PRIMARY(bond->params.mode)) {
1441 if (bond->params.mode == BOND_MODE_8023AD) {
1448 bond_add_vlans_on_slave(bond, slave_dev);
1450 write_lock_bh(&bond->lock);
1452 bond_attach_slave(bond, new_slave);
1457 bond_compute_features(bond);
1461 if (bond->params.miimon && !bond->params.use_carrier) {
1462 link_reporting = bond_check_dev_link(bond, slave_dev, 1);
1464 if ((link_reporting == -1) && !bond->params.arp_interval) {
1494 if (!bond->params.miimon ||
1495 (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) {
1496 if (bond->params.updelay) {
1500 new_slave->delay = bond->params.updelay;
1520 if (bond->params.mode == BOND_MODE_8023AD) {
1528 if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
1530 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
1531 bond->primary_slave = new_slave;
1535 switch (bond->params.mode) {
1538 bond_select_active_slave(bond);
1547 if (bond->slave_cnt == 1) {
1550 * can be called only after the mac address of the bond is set
1552 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL,
1553 bond->params.lacp_fast);
1564 if ((!bond->curr_active_slave) &&
1569 bond_change_active_slave(bond, new_slave);
1581 * anyway (it holds no special properties of the bond device),
1584 if (!bond->curr_active_slave) {
1585 bond->curr_active_slave = new_slave;
1590 bond_set_carrier(bond);
1592 write_unlock_bh(&bond->lock);
1629 * Try to release the slave device <slave> from the bond device <master>
1641 struct bonding *bond = bond_dev->priv;
1655 write_lock_bh(&bond->lock);
1657 slave = bond_get_slave_by_dev(bond, slave_dev);
1659 /* not a slave of this bond */
1663 write_unlock_bh(&bond->lock);
1670 if (!mac_addr_differ && (bond->slave_cnt > 1)) {
1690 if (bond->params.mode == BOND_MODE_8023AD) {
1704 oldcurrent = bond->curr_active_slave;
1706 bond->current_arp_slave = NULL;
1708 /* release the slave from its bond */
1709 bond_detach_slave(bond, slave);
1711 bond_compute_features(bond);
1713 if (bond->primary_slave == slave) {
1714 bond->primary_slave = NULL;
1718 bond_change_active_slave(bond, NULL);
1721 if ((bond->params.mode == BOND_MODE_TLB) ||
1722 (bond->params.mode == BOND_MODE_ALB)) {
1728 bond_alb_deinit_slave(bond, slave);
1732 bond_select_active_slave(bond);
1734 if (bond->slave_cnt == 0) {
1735 bond_set_carrier(bond);
1743 if (list_empty(&bond->vlan_list)) {
1751 ": %s: When re-adding slaves, make sure the bond's "
1756 !bond_has_challenged_slaves(bond)) {
1759 "left bond %s. VLAN blocking is removed\n",
1764 write_unlock_bh(&bond->lock);
1769 bond_del_vlans_from_slave(bond, slave_dev);
1775 if (!USES_PRIMARY(bond->params.mode)) {
1814 struct bonding *bond = bond_dev->priv;
1819 write_lock_bh(&bond->lock);
1823 if (bond->slave_cnt == 0) {
1827 bond->current_arp_slave = NULL;
1828 bond->primary_slave = NULL;
1829 bond_change_active_slave(bond, NULL);
1831 while ((slave = bond->first_slave) != NULL) {
1835 if (bond->params.mode == BOND_MODE_8023AD) {
1840 bond_detach_slave(bond, slave);
1842 if ((bond->params.mode == BOND_MODE_TLB) ||
1843 (bond->params.mode == BOND_MODE_ALB)) {
1847 bond_alb_deinit_slave(bond, slave);
1850 bond_compute_features(bond);
1856 write_unlock_bh(&bond->lock);
1859 bond_del_vlans_from_slave(bond, slave_dev);
1865 if (!USES_PRIMARY(bond->params.mode)) {
1896 write_lock_bh(&bond->lock);
1905 if (list_empty(&bond->vlan_list)) {
1913 ": %s: When re-adding slaves, make sure the bond's "
1923 write_unlock_bh(&bond->lock);
1941 struct bonding *bond = bond_dev->priv;
1946 if (!USES_PRIMARY(bond->params.mode)) {
1956 write_lock_bh(&bond->lock);
1958 old_active = bond->curr_active_slave;
1959 new_active = bond_get_slave_by_dev(bond, slave_dev);
1965 write_unlock_bh(&bond->lock);
1973 bond_change_active_slave(bond, new_active);
1978 write_unlock_bh(&bond->lock);
1985 struct bonding *bond = bond_dev->priv;
1987 info->bond_mode = bond->params.mode;
1988 info->miimon = bond->params.miimon;
1990 read_lock_bh(&bond->lock);
1991 info->num_slaves = bond->slave_cnt;
1992 read_unlock_bh(&bond->lock);
1999 struct bonding *bond = bond_dev->priv;
2007 read_lock_bh(&bond->lock);
2009 bond_for_each_slave(bond, slave, i) {
2016 read_unlock_bh(&bond->lock);
2035 struct bonding *bond = bond_dev->priv;
2041 read_lock(&bond->lock);
2043 delta_in_ticks = (bond->params.miimon * HZ) / 1000;
2045 if (bond->kill_timers) {
2049 if (bond->slave_cnt == 0) {
2059 read_lock(&bond->curr_slave_lock);
2060 oldcurrent = bond->curr_active_slave;
2061 read_unlock(&bond->curr_slave_lock);
2063 bond_for_each_slave(bond, slave, i) {
2069 link_state = bond_check_dev_link(bond, slave_dev, 0);
2078 slave->delay = bond->params.downdelay;
2084 if (bond->params.downdelay) {
2091 ? ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
2097 bond->params.downdelay * bond->params.miimon);
2113 if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP) ||
2114 (bond->params.mode == BOND_MODE_8023AD)) {
2126 if (bond->params.mode == BOND_MODE_8023AD) {
2130 if ((bond->params.mode == BOND_MODE_TLB) ||
2131 (bond->params.mode == BOND_MODE_ALB)) {
2132 bond_alb_handle_link_change(bond, slave, BOND_LINK_DOWN);
2149 (bond->params.downdelay - slave->delay) * bond->params.miimon,
2159 slave->delay = bond->params.updelay;
2161 if (bond->params.updelay) {
2170 bond->params.updelay * bond->params.miimon);
2185 (bond->params.updelay - slave->delay) * bond->params.miimon,
2194 if (bond->params.mode == BOND_MODE_8023AD) {
2197 } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
2200 } else if (slave != bond->primary_slave) {
2212 if (bond->params.mode == BOND_MODE_8023AD) {
2216 if ((bond->params.mode == BOND_MODE_TLB) ||
2217 (bond->params.mode == BOND_MODE_ALB)) {
2218 bond_alb_handle_link_change(bond, slave, BOND_LINK_UP);
2222 (slave == bond->primary_slave)) {
2242 if (bond->params.mode == BOND_MODE_8023AD) {
2255 write_lock(&bond->curr_slave_lock);
2257 bond_select_active_slave(bond);
2259 write_unlock(&bond->curr_slave_lock);
2261 bond_set_carrier(bond);
2264 if (bond->params.miimon) {
2265 mod_timer(&bond->mii_timer, jiffies + delta_in_ticks);
2268 read_unlock(&bond->lock);
2296 static int bond_has_ip(struct bonding *bond)
2300 if (bond->master_ip)
2303 if (list_empty(&bond->vlan_list))
2306 list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
2315 static int bond_has_this_ip(struct bonding *bond, u32 ip)
2319 if (ip == bond->master_ip)
2322 if (list_empty(&bond->vlan_list))
2325 list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
2364 static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
2367 u32 *targets = bond->params.arp_targets;
2377 if (list_empty(&bond->vlan_list)) {
2380 bond->master_ip, 0);
2398 bond->dev->name, NIPQUAD(fl.fl4_dst));
2406 if (rt->u.dst.dev == bond->dev) {
2408 dprintk("basa: rtdev == bond->dev: arp_send\n");
2410 bond->master_ip, 0);
2415 list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
2417 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
2436 bond->dev->name, NIPQUAD(fl.fl4_dst),
2447 static void bond_send_gratuitous_arp(struct bonding *bond)
2449 struct slave *slave = bond->curr_active_slave;
2453 dprintk("bond_send_grat_arp: bond %s slave %s\n", bond->dev->name,
2458 if (bond->master_ip) {
2459 bond_arp_send(slave->dev, ARPOP_REPLY, bond->master_ip,
2460 bond->master_ip, 0);
2463 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
2464 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
2472 static void bond_validate_arp(struct bonding *bond, struct slave *slave, u32 sip, u32 tip)
2475 u32 *targets = bond->params.arp_targets;
2477 targets = bond->params.arp_targets;
2482 bond_has_this_ip(bond, tip));
2484 if (bond_has_this_ip(bond, tip))
2495 struct bonding *bond;
2502 bond = dev->priv;
2503 read_lock(&bond->lock);
2505 dprintk("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",
2506 bond->dev->name, skb->dev ? skb->dev->name : "NULL",
2509 slave = bond_get_slave_by_dev(bond, orig_dev);
2510 if (!slave || !slave_do_arp_validate(bond, slave))
2535 " tip %u.%u.%u.%u\n", bond->dev->name, slave->dev->name,
2536 slave->state, bond->params.arp_validate,
2537 slave_do_arp_validate(bond, slave), NIPQUAD(sip), NIPQUAD(tip));
2548 bond_validate_arp(bond, slave, sip, tip);
2550 bond_validate_arp(bond, slave, tip, sip);
2553 read_unlock(&bond->lock);
2568 struct bonding *bond = bond_dev->priv;
2574 read_lock(&bond->lock);
2576 delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
2578 if (bond->kill_timers) {
2582 if (bond->slave_cnt == 0) {
2586 read_lock(&bond->curr_slave_lock);
2587 oldcurrent = bond->curr_active_slave;
2588 read_unlock(&bond->curr_slave_lock);
2598 bond_for_each_slave(bond, slave, i) {
2634 bond_has_ip(bond))) {
2662 bond_arp_send_all(bond, slave);
2667 write_lock(&bond->curr_slave_lock);
2669 bond_select_active_slave(bond);
2671 write_unlock(&bond->curr_slave_lock);
2675 if (bond->params.arp_interval) {
2676 mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
2679 read_unlock(&bond->lock);
2699 struct bonding *bond = bond_dev->priv;
2704 read_lock(&bond->lock);
2706 delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
2708 if (bond->kill_timers) {
2712 if (bond->slave_cnt == 0) {
2721 bond_for_each_slave(bond, slave, i) {
2723 if ((jiffies - slave_last_rx(bond, slave)) <=
2728 write_lock(&bond->curr_slave_lock);
2730 if ((!bond->curr_active_slave) &&
2732 bond_change_active_slave(bond, slave);
2733 bond->current_arp_slave = NULL;
2734 } else if (bond->curr_active_slave != slave) {
2742 bond->current_arp_slave = NULL;
2745 bond_set_carrier(bond);
2747 if (slave == bond->curr_active_slave) {
2753 netif_carrier_on(bond->dev);
2762 write_unlock(&bond->curr_slave_lock);
2765 read_lock(&bond->curr_slave_lock);
2767 if ((slave != bond->curr_active_slave) &&
2768 (!bond->current_arp_slave) &&
2769 (((jiffies - slave_last_rx(bond, slave)) >= 3*delta_in_ticks) &&
2770 bond_has_ip(bond))) {
2782 read_unlock(&bond->curr_slave_lock);
2797 read_unlock(&bond->curr_slave_lock);
2802 read_lock(&bond->curr_slave_lock);
2803 slave = bond->curr_active_slave;
2804 read_unlock(&bond->curr_slave_lock);
2816 (((jiffies - slave_last_rx(bond, slave)) >= (2*delta_in_ticks)) &&
2817 bond_has_ip(bond))) &&
2832 write_lock(&bond->curr_slave_lock);
2834 bond_select_active_slave(bond);
2835 slave = bond->curr_active_slave;
2837 write_unlock(&bond->curr_slave_lock);
2839 bond->current_arp_slave = slave;
2844 } else if ((bond->primary_slave) &&
2845 (bond->primary_slave != slave) &&
2846 (bond->primary_slave->link == BOND_LINK_UP)) {
2853 bond->primary_slave->dev->name);
2856 write_lock(&bond->curr_slave_lock);
2857 bond_change_active_slave(bond, bond->primary_slave);
2858 write_unlock(&bond->curr_slave_lock);
2860 slave = bond->primary_slave;
2863 bond->current_arp_slave = NULL;
2869 if (slave && bond_has_ip(bond)) {
2870 bond_arp_send_all(bond, slave);
2879 if (!bond->current_arp_slave) {
2880 bond->current_arp_slave = bond->first_slave;
2883 if (bond->current_arp_slave) {
2884 bond_set_slave_inactive_flags(bond->current_arp_slave);
2887 bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) {
2891 bond_arp_send_all(bond, slave);
2893 bond->current_arp_slave = slave;
2923 if (bond->params.arp_interval) {
2924 mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
2927 read_unlock(&bond->lock);
2938 struct bonding *bond = seq->private;
2943 /* make sure the bond won't be taken away */
2945 read_lock_bh(&bond->lock);
2951 bond_for_each_slave(bond, slave, i) {
2962 struct bonding *bond = seq->private;
2967 return bond->first_slave;
2972 return (slave == bond->first_slave) ? NULL : slave;
2977 struct bonding *bond = seq->private;
2979 read_unlock_bh(&bond->lock);
2985 struct bonding *bond = seq->private;
2990 read_lock(&bond->curr_slave_lock);
2991 curr = bond->curr_active_slave;
2992 read_unlock(&bond->curr_slave_lock);
2995 bond_mode_name(bond->params.mode));
2997 if (bond->params.mode == BOND_MODE_XOR ||
2998 bond->params.mode == BOND_MODE_8023AD) {
3000 xmit_hashtype_tbl[bond->params.xmit_policy].modename,
3001 bond->params.xmit_policy);
3004 if (USES_PRIMARY(bond->params.mode)) {
3006 (bond->primary_slave) ?
3007 bond->primary_slave->dev->name : "None");
3013 seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
3015 seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
3017 bond->params.updelay * bond->params.miimon);
3019 bond->params.downdelay * bond->params.miimon);
3023 if(bond->params.arp_interval > 0) {
3026 bond->params.arp_interval);
3031 if (!bond->params.arp_targets[i])
3035 target = ntohl(bond->params.arp_targets[i]);
3042 if (bond->params.mode == BOND_MODE_8023AD) {
3047 (bond->params.lacp_fast) ? "fast" : "slow");
3049 if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
3050 seq_printf(seq, "bond %s has no active aggregator\n",
3051 bond->dev->name);
3076 struct bonding *bond = seq->private;
3090 if (bond->params.mode == BOND_MODE_8023AD) {
3147 static int bond_create_proc_entry(struct bonding *bond)
3149 struct net_device *bond_dev = bond->dev;
3152 bond->proc_entry = create_proc_entry(bond_dev->name,
3155 if (bond->proc_entry == NULL) {
3160 bond->proc_entry->data = bond;
3161 bond->proc_entry->proc_fops = &bond_info_fops;
3162 bond->proc_entry->owner = THIS_MODULE;
3163 memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
3170 static void bond_remove_proc_entry(struct bonding *bond)
3172 if (bond_proc_dir && bond->proc_entry) {
3173 remove_proc_entry(bond->proc_file_name, bond_proc_dir);
3174 memset(bond->proc_file_name, 0, IFNAMSIZ);
3175 bond->proc_entry = NULL;
3241 static int bond_event_changename(struct bonding *bond)
3244 bond_remove_proc_entry(bond);
3245 bond_create_proc_entry(bond);
3248 bond_destroy_sysfs_entry(bond);
3249 bond_create_sysfs_entry(bond);
3263 * TODO: remove a bond from the list?
3276 struct bonding *bond = bond_dev->priv;
3287 * sets up a hierarchical bond, then rmmod's
3300 * an active-backup bond, slaves need
3316 bond_compute_features(bond);
3369 struct bonding *bond, *bond_next;
3372 list_for_each_entry_safe(bond, bond_next, &bond_dev_list, bond_list) {
3373 if (bond->dev == event_dev) {
3376 bond->master_ip = ifa->ifa_local;
3379 bond->master_ip = bond_glean_dev_ip(bond->dev);
3386 if (list_empty(&bond->vlan_list))
3389 list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
3391 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
3420 /* register to receive lacpdus on a bond */
3421 static void bond_register_lacpdu(struct bonding *bond)
3423 struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);
3427 pk_type->dev = bond->dev;
3433 /* unregister to receive lacpdus on a bond */
3434 static void bond_unregister_lacpdu(struct bonding *bond)
3436 dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
3439 void bond_register_arp(struct bonding *bond)
3441 struct packet_type *pt = &bond->arp_mon_pt;
3447 pt->dev = bond->dev;
3452 void bond_unregister_arp(struct bonding *bond)
3454 struct packet_type *pt = &bond->arp_mon_pt;
3504 struct bonding *bond = bond_dev->priv;
3505 struct timer_list *mii_timer = &bond->mii_timer;
3506 struct timer_list *arp_timer = &bond->arp_timer;
3508 bond->kill_timers = 0;
3510 if ((bond->params.mode == BOND_MODE_TLB) ||
3511 (bond->params.mode == BOND_MODE_ALB)) {
3512 struct timer_list *alb_timer = &(BOND_ALB_INFO(bond).alb_timer);
3517 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
3524 alb_timer->data = (unsigned long)bond;
3529 if (bond->params.miimon) { /* link check interval, in milliseconds. */
3537 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
3541 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
3546 if (bond->params.arp_validate)
3547 bond_register_arp(bond);
3552 if (bond->params.mode == BOND_MODE_8023AD) {
3553 struct timer_list *ad_timer = &(BOND_AD_INFO(bond).ad_timer);
3556 ad_timer->data = (unsigned long)bond;
3561 bond_register_lacpdu(bond);
3569 struct bonding *bond = bond_dev->priv;
3571 if (bond->params.mode == BOND_MODE_8023AD) {
3573 bond_unregister_lacpdu(bond);
3576 if (bond->params.arp_validate)
3577 bond_unregister_arp(bond);
3579 write_lock_bh(&bond->lock);
3583 bond->kill_timers = 1;
3585 write_unlock_bh(&bond->lock);
3587 /* del_timer_sync must run without holding the bond->lock
3591 if (bond->params.miimon) { /* link check interval, in milliseconds. */
3592 del_timer_sync(&bond->mii_timer);
3595 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
3596 del_timer_sync(&bond->arp_timer);
3599 switch (bond->params.mode) {
3601 del_timer_sync(&(BOND_AD_INFO(bond).ad_timer));
3605 del_timer_sync(&(BOND_ALB_INFO(bond).alb_timer));
3612 if ((bond->params.mode == BOND_MODE_TLB) ||
3613 (bond->params.mode == BOND_MODE_ALB)) {
3617 bond_alb_deinitialize(bond);
3625 struct bonding *bond = bond_dev->priv;
3626 struct net_device_stats *stats = &(bond->stats), *sstats;
3632 read_lock_bh(&bond->lock);
3634 bond_for_each_slave(bond, slave, i) {
3663 read_unlock_bh(&bond->lock);
3700 struct bonding *bond = bond_dev->priv;
3702 read_lock_bh(&bond->lock);
3703 read_lock(&bond->curr_slave_lock);
3704 if (netif_carrier_ok(bond->dev)) {
3707 read_unlock(&bond->curr_slave_lock);
3708 read_unlock_bh(&bond->lock);
3792 struct bonding *bond = bond_dev->priv;
3795 write_lock_bh(&bond->lock);
3800 if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC)) {
3801 bond_set_promiscuity(bond, 1);
3804 if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC)) {
3805 bond_set_promiscuity(bond, -1);
3809 if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI)) {
3810 bond_set_allmulti(bond, 1);
3813 if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI)) {
3814 bond_set_allmulti(bond, -1);
3817 bond->flags = bond_dev->flags;
3821 if (!bond_mc_list_find_dmi(dmi, bond->mc_list)) {
3822 bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
3827 for (dmi = bond->mc_list; dmi; dmi = dmi->next) {
3829 bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
3834 bond_mc_list_destroy(bond);
3835 bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC);
3837 write_unlock_bh(&bond->lock);
3845 struct bonding *bond = bond_dev->priv;
3850 dprintk("bond=%p, name=%s, new_mtu=%d\n", bond,
3853 /* Can't hold bond->lock with bh disabled here since
3855 * hold bond->lock without bh disabled because we'll
3868 bond_for_each_slave(bond, slave, i) {
3895 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
3917 struct bonding *bond = bond_dev->priv;
3923 dprintk("bond=%p, name=%s\n", bond, (bond_dev ? bond_dev->name : "None"));
3929 /* Can't hold bond->lock with bh disabled here since
3931 * hold bond->lock without bh disabled because we'll
3944 bond_for_each_slave(bond, slave, i) {
3976 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
3991 struct bonding *bond = bond_dev->priv;
3996 read_lock(&bond->lock);
3998 if (!BOND_IS_OK(bond)) {
4002 read_lock(&bond->curr_slave_lock);
4003 slave = start_at = bond->curr_active_slave;
4004 read_unlock(&bond->curr_slave_lock);
4010 bond_for_each_slave_from(bond, slave, i, start_at) {
4014 res = bond_dev_queue_xmit(bond, skb, slave->dev);
4016 write_lock(&bond->curr_slave_lock);
4017 bond->curr_active_slave = slave->next;
4018 write_unlock(&bond->curr_slave_lock);
4030 read_unlock(&bond->lock);
4036 * in active-backup mode, we know that bond->curr_active_slave is always valid if
4037 * the bond has a usable interface.
4041 struct bonding *bond = bond_dev->priv;
4044 read_lock(&bond->lock);
4045 read_lock(&bond->curr_slave_lock);
4047 if (!BOND_IS_OK(bond)) {
4051 if (!bond->curr_active_slave)
4054 res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
4061 read_unlock(&bond->curr_slave_lock);
4062 read_unlock(&bond->lock);
4073 struct bonding *bond = bond_dev->priv;
4079 read_lock(&bond->lock);
4081 if (!BOND_IS_OK(bond)) {
4085 slave_no = bond->xmit_hash_policy(skb, bond_dev, bond->slave_cnt);
4087 bond_for_each_slave(bond, slave, i) {
4096 bond_for_each_slave_from(bond, slave, i, start_at) {
4100 res = bond_dev_queue_xmit(bond, skb, slave->dev);
4110 read_unlock(&bond->lock);
4119 struct bonding *bond = bond_dev->priv;
4125 read_lock(&bond->lock);
4127 if (!BOND_IS_OK(bond)) {
4131 read_lock(&bond->curr_slave_lock);
4132 start_at = bond->curr_active_slave;
4133 read_unlock(&bond->curr_slave_lock);
4139 bond_for_each_slave_from(bond, slave, i, start_at) {
4153 res = bond_dev_queue_xmit(bond, skb2, tx_dev);
4164 res = bond_dev_queue_xmit(bond, skb, tx_dev);
4173 read_unlock(&bond->lock);
4180 * set bond mode specific net device operations
4182 void bond_set_mode_ops(struct bonding *bond, int mode)
4184 struct net_device *bond_dev = bond->dev;
4195 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34)
4196 bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
4198 bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
4204 bond_set_master_3ad_flags(bond);
4206 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34)
4207 bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
4209 bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
4212 bond_set_master_alb_flags(bond);
4250 struct bonding *bond = bond_dev->priv;
4255 rwlock_init(&bond->lock);
4256 rwlock_init(&bond->curr_slave_lock);
4258 bond->params = *params; /* copy params struct */
4261 bond->first_slave = NULL;
4262 bond->curr_active_slave = NULL;
4263 bond->current_arp_slave = NULL;
4264 bond->primary_slave = NULL;
4265 bond->dev = bond_dev;
4266 INIT_LIST_HEAD(&bond->vlan_list);
4278 bond_set_mode_ops(bond, bond->params.mode);
4289 * empty bond. The block will be removed once non-challenged
4294 /* don't acquire bond device's netif_tx_lock when
4298 /* By default, we declare the bond to be fully
4312 bond_create_proc_entry(bond);
4315 list_add_tail(&bond->bond_list, &bond_dev_list);
4325 struct bonding *bond = bond_dev->priv;
4327 list_del(&bond->bond_list);
4330 bond_remove_proc_entry(bond);
4334 /* Unregister and free all bond devices.
4339 struct bonding *bond, *nxt;
4341 list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) {
4342 struct net_device *bond_dev = bond->dev;
4344 bond_mc_list_destroy(bond);
4672 /* Create a new bond based on the specified name and bonding parameters.
4673 * If name is NULL, obtain a suitable "bond%d" name for us.
4694 res = dev_alloc_name(bond_dev, "bond%d");