Commit 709db03a authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 's390-qeth' 



Karsten Graul says:

====================
s390/qeth: Add bridge to switchdev LEARNING_SYNC

The netlink bridgeport attribute LEARNING_SYNC can be used to enable
qeth interfaces to report MAC addresses that are reachable via this
qeth interface to the attached software bridge via switchdev
notifiers SWITCHDEV_FDB_ADD_TO_BRIDGE and SWITCHDEV_FDB_DEL_TO_BRIDGE.

Extend this support of LEARNING_SYNC to the bridge to switchdev notifiers
SWITCHDEV_FDB_ADD_TO_DEVICE and SWITCHDEV_FDB_DEL_TO_DEVICE.

Add the capability to sync MAC addresses that are learned by a
north-facing, non-isolated bridgeport of a software bridge to
south-facing, isolated bridgeports. This enables the software bridge to
influence south to north traffic steering in hardware.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 17bd3a1e f7936b7b

drivers/s390/net/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ config QETH_L2 
	def_tristate y

	prompt "qeth layer 2 device support"

	depends on QETH

	depends on BRIDGE || BRIDGE=n

	help

	  Select this option to be able to run qeth devices in layer 2 mode.

	  To compile as a module, choose M. The module name is qeth_l2.

drivers/s390/net/qeth_l2_main.c

+236 −3
Original line number Diff line number Diff line
@@ -717,6 +717,227 @@ static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable) 
	return rc;

}



struct qeth_l2_br2dev_event_work {

	struct work_struct work;

	struct net_device *br_dev;

	struct net_device *lsync_dev;

	struct net_device *dst_dev;

	unsigned long event;

	unsigned char addr[ETH_ALEN];

};



static const struct net_device_ops qeth_l2_netdev_ops;



static bool qeth_l2_must_learn(struct net_device *netdev,

			       struct net_device *dstdev)

{

	struct qeth_priv *priv;



	priv = netdev_priv(netdev);

	return (netdev != dstdev &&

		(priv->brport_features & BR_LEARNING_SYNC) &&

		!(br_port_flag_is_set(netdev, BR_ISOLATED) &&

		  br_port_flag_is_set(dstdev, BR_ISOLATED)) &&

		netdev->netdev_ops == &qeth_l2_netdev_ops);

}



/**

 *	qeth_l2_br2dev_worker() - update local MACs

 *	@work: bridge to device FDB update

 *

 *	Update local MACs of a learning_sync bridgeport so it can receive

 *	messages for a destination port.

 *	In case of an isolated learning_sync port, also update its isolated

 *	siblings.

 */

static void qeth_l2_br2dev_worker(struct work_struct *work)

{

	struct qeth_l2_br2dev_event_work *br2dev_event_work =

		container_of(work, struct qeth_l2_br2dev_event_work, work);

	struct net_device *lsyncdev = br2dev_event_work->lsync_dev;

	struct net_device *dstdev = br2dev_event_work->dst_dev;

	struct net_device *brdev = br2dev_event_work->br_dev;

	unsigned long event = br2dev_event_work->event;

	unsigned char *addr = br2dev_event_work->addr;

	struct qeth_card *card = lsyncdev->ml_priv;

	struct net_device *lowerdev;

	struct list_head *iter;

	int err = 0;



	kfree(br2dev_event_work);

	QETH_CARD_TEXT_(card, 4, "b2dw%04x", event);

	QETH_CARD_TEXT_(card, 4, "ma%012lx", ether_addr_to_u64(addr));



	rcu_read_lock();

	/* Verify preconditions are still valid: */

	if (!netif_is_bridge_port(lsyncdev) ||

	    brdev != netdev_master_upper_dev_get_rcu(lsyncdev))

		goto unlock;

	if (!qeth_l2_must_learn(lsyncdev, dstdev))

		goto unlock;



	if (br_port_flag_is_set(lsyncdev, BR_ISOLATED)) {

		/* Update lsyncdev and its isolated sibling(s): */

		iter = &brdev->adj_list.lower;

		lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

		while (lowerdev) {

			if (br_port_flag_is_set(lowerdev, BR_ISOLATED)) {

				switch (event) {

				case SWITCHDEV_FDB_ADD_TO_DEVICE:

					err = dev_uc_add(lowerdev, addr);

					break;

				case SWITCHDEV_FDB_DEL_TO_DEVICE:

					err = dev_uc_del(lowerdev, addr);

					break;

				default:

					break;

				}

				if (err) {

					QETH_CARD_TEXT(card, 2, "b2derris");

					QETH_CARD_TEXT_(card, 2,

							"err%02x%03d", event,

							lowerdev->ifindex);

				}

			}

			lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

		}

	} else {

		switch (event) {

		case SWITCHDEV_FDB_ADD_TO_DEVICE:

			err = dev_uc_add(lsyncdev, addr);

			break;

		case SWITCHDEV_FDB_DEL_TO_DEVICE:

			err = dev_uc_del(lsyncdev, addr);

			break;

		default:

			break;

		}

		if (err)

			QETH_CARD_TEXT_(card, 2, "b2derr%02x", event);

	}



unlock:

	rcu_read_unlock();

	dev_put(brdev);

	dev_put(lsyncdev);

	dev_put(dstdev);

}



static int qeth_l2_br2dev_queue_work(struct net_device *brdev,

				     struct net_device *lsyncdev,

				     struct net_device *dstdev,

				     unsigned long event,

				     const unsigned char *addr)

{

	struct qeth_l2_br2dev_event_work *worker_data;

	struct qeth_card *card;



	worker_data = kzalloc(sizeof(*worker_data), GFP_ATOMIC);

	if (!worker_data)

		return -ENOMEM;

	INIT_WORK(&worker_data->work, qeth_l2_br2dev_worker);

	worker_data->br_dev = brdev;

	worker_data->lsync_dev = lsyncdev;

	worker_data->dst_dev = dstdev;

	worker_data->event = event;

	ether_addr_copy(worker_data->addr, addr);



	card = lsyncdev->ml_priv;

	/* Take a reference on the sw port devices and the bridge */

	dev_hold(brdev);

	dev_hold(lsyncdev);

	dev_hold(dstdev);

	queue_work(card->event_wq, &worker_data->work);

	return 0;

}



/* Called under rtnl_lock */

static int qeth_l2_switchdev_event(struct notifier_block *unused,

				   unsigned long event, void *ptr)

{

	struct net_device *dstdev, *brdev, *lowerdev;

	struct switchdev_notifier_fdb_info *fdb_info;

	struct switchdev_notifier_info *info = ptr;

	struct list_head *iter;

	struct qeth_card *card;

	int rc;



	if (!(event == SWITCHDEV_FDB_ADD_TO_DEVICE ||

	      event == SWITCHDEV_FDB_DEL_TO_DEVICE))

		return NOTIFY_DONE;



	dstdev = switchdev_notifier_info_to_dev(info);

	brdev = netdev_master_upper_dev_get_rcu(dstdev);

	if (!brdev || !netif_is_bridge_master(brdev))

		return NOTIFY_DONE;

	fdb_info = container_of(info,

				struct switchdev_notifier_fdb_info,

				info);

	iter = &brdev->adj_list.lower;

	lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

	while (lowerdev) {

		if (qeth_l2_must_learn(lowerdev, dstdev)) {

			card = lowerdev->ml_priv;

			QETH_CARD_TEXT_(card, 4, "b2dqw%03x", event);

			rc = qeth_l2_br2dev_queue_work(brdev, lowerdev,

						       dstdev, event,

						       fdb_info->addr);

			if (rc) {

				QETH_CARD_TEXT(card, 2, "b2dqwerr");

				return NOTIFY_BAD;

			}

		}

		lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

	}

	return NOTIFY_DONE;

}



static struct notifier_block qeth_l2_sw_notifier = {

		.notifier_call = qeth_l2_switchdev_event,

};



static refcount_t qeth_l2_switchdev_notify_refcnt;



/* Called under rtnl_lock */

static void qeth_l2_br2dev_get(void)

{

	int rc;



	if (!refcount_inc_not_zero(&qeth_l2_switchdev_notify_refcnt)) {

		rc = register_switchdev_notifier(&qeth_l2_sw_notifier);

		if (rc) {

			QETH_DBF_MESSAGE(2,

					 "failed to register qeth_l2_sw_notifier: %d\n",

					 rc);

		} else {

			refcount_set(&qeth_l2_switchdev_notify_refcnt, 1);

			QETH_DBF_MESSAGE(2, "qeth_l2_sw_notifier registered\n");

		}

	}

	QETH_DBF_TEXT_(SETUP, 2, "b2d+%04d",

		       qeth_l2_switchdev_notify_refcnt.refs.counter);

}



/* Called under rtnl_lock */

static void qeth_l2_br2dev_put(void)

{

	int rc;



	if (refcount_dec_and_test(&qeth_l2_switchdev_notify_refcnt)) {

		rc = unregister_switchdev_notifier(&qeth_l2_sw_notifier);

		if (rc) {

			QETH_DBF_MESSAGE(2,

					 "failed to unregister qeth_l2_sw_notifier: %d\n",

					 rc);

		} else {

			QETH_DBF_MESSAGE(2,

					 "qeth_l2_sw_notifier unregistered\n");

		}

	}

	QETH_DBF_TEXT_(SETUP, 2, "b2d-%04d",

		       qeth_l2_switchdev_notify_refcnt.refs.counter);

}



static int qeth_l2_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,

				  struct net_device *dev, u32 filter_mask,

				  int nlflags)
@@ -810,16 +1031,19 @@ static int qeth_l2_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 
	} else if (enable) {

		qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);

		rc = qeth_l2_dev2br_an_set(card, true);

		if (rc)

		if (rc) {

			qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);

		else

		} else {

			priv->brport_features |= BR_LEARNING_SYNC;

			qeth_l2_br2dev_get();

		}

	} else {

		rc = qeth_l2_dev2br_an_set(card, false);

		if (!rc) {

			qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);

			priv->brport_features ^= BR_LEARNING_SYNC;

			qeth_l2_dev2br_fdb_flush(card);

			qeth_l2_br2dev_put();

		}

	}

	mutex_unlock(&card->sbp_lock);
@@ -2072,6 +2296,7 @@ static int qeth_l2_probe_device(struct ccwgroup_device *gdev) 
static void qeth_l2_remove_device(struct ccwgroup_device *gdev)

{

	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	struct qeth_priv *priv;



	if (gdev->dev.type != &qeth_l2_devtype)

		device_remove_groups(&gdev->dev, qeth_l2_attr_groups);
@@ -2083,9 +2308,16 @@ static void qeth_l2_remove_device(struct ccwgroup_device *gdev) 
		qeth_set_offline(card, card->discipline, false);



	cancel_work_sync(&card->close_dev_work);

	if (card->dev->reg_state == NETREG_REGISTERED)

	if (card->dev->reg_state == NETREG_REGISTERED) {

		priv = netdev_priv(card->dev);

		if (priv->brport_features & BR_LEARNING_SYNC) {

			rtnl_lock();

			qeth_l2_br2dev_put();

			rtnl_unlock();

		}

		unregister_netdev(card->dev);

	}

}



static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok)

{
@@ -2207,6 +2439,7 @@ EXPORT_SYMBOL_GPL(qeth_l2_discipline); 
static int __init qeth_l2_init(void)

{

	pr_info("register layer 2 discipline\n");

	refcount_set(&qeth_l2_switchdev_notify_refcnt, 0);

	return 0;

}