| /* |
| * Copyright (C) 2003-2009 Chelsio Communications. All rights reserved. |
| * |
| * Written by Divy Le Ray (divy@chelsio.com) |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file included in this |
| * release for licensing terms and conditions. |
| */ |
| |
| #include <linux/netdevice.h> |
| #include <net/sock.h> |
| #include <linux/toedev.h> |
| #include <linux/if_vlan.h> |
| #include <linux/version.h> |
| #include <net/ip.h> |
| |
| #include <drivers/net/bonding/bonding.h> |
| #include <drivers/net/bonding/bond_3ad.h> |
| |
| #include "toe_bonding.h" |
| |
| #include "toe_compat.h" |
| |
| /* |
| * Bonding for TOE. |
| * Limitation(s): |
| * The slaves of a bonding device share the same TOEDEV: |
| * They are either ports of the same adapter, |
| * or bonding devices themselves. |
| */ |
| |
| /* Adapted from drivers/net/bonding/bond_main.c:bond_xmit_activebackup() */ |
| static struct net_device * toe_bond_acb_select(struct net_device *dev, |
| int context) |
| { |
| struct bonding *bond = (struct bonding *)netdev_priv(dev); |
| struct net_device *slave_dev = NULL; |
| |
| if (context == TOE_OPEN) { |
| read_lock(&bond->lock); |
| read_lock(&bond->curr_slave_lock); |
| } |
| |
| if (!BOND_IS_OK(bond)) |
| goto out; |
| |
| if (!bond->curr_active_slave) |
| goto out; |
| |
| slave_dev = bond->curr_active_slave->dev; |
| |
| out: |
| if (context == TOE_OPEN) { |
| read_unlock(&bond->curr_slave_lock); |
| read_unlock(&bond->lock); |
| } |
| return (slave_dev); |
| } |
| |
| /* XXX */ |
| static struct net_device * toe_bond_xor_select(struct net_device *dev, int context) |
| { |
| struct bonding *bond = (struct bonding *)netdev_priv(dev); |
| struct net_device *slave_dev = NULL; |
| struct slave *slave, *start_at; |
| int slave_no, i; |
| static int xor_select_cntr = 0; |
| |
| if (context == TOE_OPEN) |
| read_lock(&bond->lock); |
| |
| if (!BOND_IS_OK(bond)) { |
| goto out; |
| } |
| |
| slave_no = xor_select_cntr++ % 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)) { |
| slave_dev = slave->dev; |
| break; |
| } |
| } |
| |
| out: |
| if (context == TOE_OPEN) |
| read_unlock(&bond->lock); |
| return slave_dev; |
| } |
| |
| /* Adapted from drivers/net/bonding/bond_3ad.c:__get_bond_by_port() */ |
| static inline struct bonding *toe_bond_get_bond_by_port(struct port *port) |
| { |
| if (port->slave == NULL) { |
| return NULL; |
| } |
| |
| return bond_get_bond_by_slave(port->slave); |
| } |
| |
| /* Adapted from drivers/net/bonding/bond_3ad.c:__get_first_port() */ |
| static inline struct port *toe_bond_get_first_port(struct bonding *bond) |
| { |
| if (bond->slave_cnt == 0) |
| return NULL; |
| |
| return &(SLAVE_AD_INFO(bond->first_slave).port); |
| } |
| |
| /* Adapted from drivers/net/bonding/bond_3ad.c:__get_next_port() */ |
| static inline struct port *toe_bond_get_next_port(struct port *port) |
| { |
| struct bonding *bond = toe_bond_get_bond_by_port(port); |
| struct slave *slave = port->slave; |
| |
| // If there's no bond for this port, or this is the last slave |
| if ((bond == NULL) || (slave->next == bond->first_slave)) |
| return NULL; |
| |
| return &(SLAVE_AD_INFO(slave->next).port); |
| } |
| |
| /* Adapted from |
| * drivers/net/bonding/bond_3ad.c:bond_3ad_get_active_agg_info() */ |
| static int toe_bond_3ad_get_active_agg_info(struct bonding *bond, |
| struct ad_info *ad_info) |
| { |
| struct aggregator *aggregator = NULL; |
| struct port *port; |
| |
| for (port = toe_bond_get_first_port(bond); port; |
| port = toe_bond_get_next_port(port)) |
| { |
| if (port->aggregator && port->aggregator->is_active) { |
| aggregator = port->aggregator; |
| break; |
| } |
| } |
| |
| if (aggregator) { |
| ad_info->aggregator_id = aggregator->aggregator_identifier; |
| ad_info->ports = aggregator->num_of_ports; |
| ad_info->actor_key = aggregator->actor_oper_aggregator_key; |
| ad_info->partner_key = aggregator->partner_oper_aggregator_key; |
| memcpy(ad_info->partner_system, |
| aggregator->partner_system.mac_addr_value, ETH_ALEN); |
| return 0; |
| } |
| |
| return -1; |
| } |
| |
| /* Adapted from drivers/net/bonding/bond_3ad.c:bond_3ad_xmit_xor() */ |
| static struct net_device * toe_bond_8023AD_select(struct net_device *dev, |
| int context) |
| { |
| struct bonding *bond = (struct bonding *)netdev_priv(dev); |
| struct net_device *slave_dev = NULL; |
| struct slave *slave, *start_at; |
| static int slave_counter = 0; |
| int slave_agg_no; |
| int slaves_in_agg; |
| int agg_id; |
| struct ad_info ad_info; |
| int i, found = 0; |
| |
| if (context == TOE_OPEN) |
| read_lock(&bond->lock); |
| |
| if (!BOND_IS_OK(bond)) { |
| goto out; |
| } |
| |
| if (toe_bond_3ad_get_active_agg_info(bond, &ad_info)) { |
| printk("%s: %s: Error: bond_3ad_get_active_agg_info failed\n", |
| __func__, dev->name); |
| goto out; |
| } |
| |
| slaves_in_agg = ad_info.ports; |
| agg_id = ad_info.aggregator_id; |
| |
| if (slaves_in_agg == 0) { |
| /*the aggregator is empty*/ |
| printk("%s: %s: Error: active aggregator is empty\n", |
| __func__, dev->name); |
| goto out; |
| } |
| |
| slave_counter++; |
| slave_agg_no = (slave_counter %= slaves_in_agg); |
| |
| bond_for_each_slave(bond, slave, i) { |
| struct aggregator *agg = SLAVE_AD_INFO(slave).port.aggregator; |
| |
| if (agg && (agg->aggregator_identifier == agg_id)) { |
| slave_agg_no--; |
| if (slave_agg_no < 0) { |
| break; |
| } |
| } |
| } |
| |
| if (slave_agg_no >= 0) { |
| printk(KERN_ERR DRV_NAME ": %s: Error: Couldn't find a slave " |
| "to tx on for aggregator ID %d\n", dev->name, agg_id); |
| goto out; |
| } |
| |
| start_at = slave; |
| |
| bond_for_each_slave_from(bond, slave, i, start_at) { |
| int slave_agg_id = 0; |
| struct aggregator *agg = SLAVE_AD_INFO(slave).port.aggregator; |
| |
| if (agg) { |
| slave_agg_id = agg->aggregator_identifier; |
| } |
| |
| found = (SLAVE_IS_OK(slave) && agg && |
| (slave_agg_id == agg_id)); |
| if (found) { |
| slave_dev = slave->dev; |
| break; |
| } |
| } |
| |
| out: |
| if (context == TOE_OPEN) |
| read_unlock(&bond->lock); |
| |
| return slave_dev; |
| } |
| |
| /* XXX */ |
| static struct net_device * toe_bond_tlb_select(struct net_device *dev, |
| int context) |
| { |
| return NULL; |
| } |
| |
| /* XXX */ |
| static struct net_device * toe_bond_alb_select(struct net_device *dev, |
| int context) |
| { |
| return NULL; |
| } |
| |
| struct net_device * toe_bond_get_slave(struct net_device *dev, |
| struct sock *sk, int context) |
| { |
| struct bonding *bond = (struct bonding *)netdev_priv(dev); |
| |
| switch (bond->params.mode) { |
| case BOND_MODE_ROUNDROBIN: |
| dev = NULL; |
| break; |
| case BOND_MODE_ACTIVEBACKUP: |
| dev = toe_bond_acb_select(dev, context); |
| break; |
| case BOND_MODE_XOR: |
| dev = toe_bond_xor_select(dev, context); |
| break; |
| case BOND_MODE_8023AD: |
| dev = toe_bond_8023AD_select(dev, context); |
| break; |
| case BOND_MODE_TLB: |
| dev = toe_bond_tlb_select(dev, context); |
| break; |
| case BOND_MODE_ALB: |
| dev = toe_bond_alb_select(dev, context); |
| break; |
| } |
| |
| return dev; |
| } |
| |
| |
| void toe_bond_neigh_propagate(struct net_device *dev, struct neighbour *neigh) |
| { |
| struct bonding *bond = (struct bonding *)netdev_priv(dev); |
| struct slave *slave, *start_at; |
| int i; |
| |
| slave = start_at = bond->first_slave; |
| bond_for_each_slave_from(bond, slave, i, start_at) { |
| struct toedev *tdev = TOEDEV(slave->dev); |
| |
| /* Slave is a bonding device */ |
| if (slave->dev->flags & IFF_MASTER) |
| toe_bond_neigh_propagate(slave->dev, neigh); |
| |
| /* Slave is a physical device. */ |
| else if (netdev_is_offload(dev) && tdev) |
| tdev->neigh_update(tdev, neigh); |
| } |
| } |
