Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 06d21290 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'switchdev-blocking-notifiers'



Petr Machata says:

====================
switchdev: Convert switchdev_port_obj_{add,del}() to notifiers

An offloading driver may need to have access to switchdev events on
ports that aren't directly under its control. An example is a VXLAN port
attached to a bridge offloaded by a driver. The driver needs to know
about VLANs configured on the VXLAN device. However the VXLAN device
isn't stashed between the bridge and a front-panel-port device (such as
is the case e.g. for LAG devices), so the usual switchdev ops don't
reach the driver.

VXLAN is likely not the only device type like this: in theory any L2
tunnel device that needs offloading will prompt requirement of this
sort.

A way to fix this is to give up the notion of port object addition /
deletion as a switchdev operation, which assumes somewhat tight coupling
between the message producer and consumer. And instead send the message
over a notifier chain.

The series starts with a clean-up patch #1, where
SWITCHDEV_OBJ_PORT_{VLAN, MDB}() are fixed up to lift the constraint
that the passed-in argument be a simple variable named "obj".

switchdev_port_obj_add and _del are invoked in a context that permits
blocking. Not only that, at least for the VLAN notification, being able
to signal failure is actually important. Therefore introduce a new
blocking notifier chain that the new events will be sent on. That's done
in patch #2. Retain the current (atomic) notifier chain for the
preexisting notifications.

In patch #3, introduce two new switchdev notifier types,
SWITCHDEV_PORT_OBJ_ADD and SWITCHDEV_PORT_OBJ_DEL. These notifier types
communicate the same event as the corresponding switchdev op, except in
a form of a notification. struct switchdev_notifier_port_obj_info was
added to carry the fields that correspond to the switchdev op arguments.
An additional field, handled, will be used to communicate back to
switchdev that the event has reached an interested party, which will be
important for the two-phase commit.

In patches #4, #5, and #7, rocker, DSA resp. ethsw are updated to
subscribe to the switchdev blocking notifier chain, and handle the new
notifier types. #6 introduces a helper to determine whether a
netdevice corresponds to a front panel port.

What these three drivers have in common is that their ports don't
support any uppers besides bridge. That makes it possible to ignore any
notifiers that don't reference a front-panel port device, because they
are certainly out of scope.

Unlike the previous three, mlxsw and ocelot drivers admit stacked
devices as uppers. While the current switchdev code recursively descends
through layers of lower devices, eventually calling the op on a
front-panel port device, the notifier would reference a stacking device
that's one of front-panel ports uppers. The filtering is thus more
complex.

For ocelot, such iteration is currently pretty much required, because
there's no bookkeeping of LAG devices. mlxsw does keep the list of LAGs,
however it iterates the lower devices anyway when deciding whether an
event on a tunnel device pertains to the driver or not.

Therefore this patch set instead introduces, in patch #8, a helper to
iterate through lowers, much like the current switchdev code does,
looking for devices that match a given predicate.

Then in patches #9 and #10, first mlxsw and then ocelot are updated to
dispatch the newly-added notifier types to the preexisting
port_obj_add/_del handlers. The dispatch is done via the new helper, to
recursively descend through lower devices.

Finally in patch #11, the actual switch is made, retiring the current
SDO-based code in favor of a notifier.

Now that the event is distributed through a notifier, the explicit
netdevice check in rocker, DSA and ethsw doesn't let through any events
except those done on a front-panel port itself. It is therefore
unnecessary to check in VLAN-handling code whether a VLAN was added to
the bridge itself: such events will simply be ignored much sooner.
Therefore remove it in patch #12.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 2eb487c1 ab4a1686
Loading
Loading
Loading
Loading
+44 −3
Original line number Original line Diff line number Diff line
@@ -1968,8 +1968,6 @@ static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
static const struct switchdev_ops mlxsw_sp_port_switchdev_ops = {
static const struct switchdev_ops mlxsw_sp_port_switchdev_ops = {
	.switchdev_port_attr_get	= mlxsw_sp_port_attr_get,
	.switchdev_port_attr_get	= mlxsw_sp_port_attr_get,
	.switchdev_port_attr_set	= mlxsw_sp_port_attr_set,
	.switchdev_port_attr_set	= mlxsw_sp_port_attr_set,
	.switchdev_port_obj_add		= mlxsw_sp_port_obj_add,
	.switchdev_port_obj_del		= mlxsw_sp_port_obj_del,
};
};


static int
static int
@@ -3118,6 +3116,32 @@ static struct notifier_block mlxsw_sp_switchdev_notifier = {
	.notifier_call = mlxsw_sp_switchdev_event,
	.notifier_call = mlxsw_sp_switchdev_event,
};
};


static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused,
					     unsigned long event, void *ptr)
{
	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
	int err;

	switch (event) {
	case SWITCHDEV_PORT_OBJ_ADD:
		err = switchdev_handle_port_obj_add(dev, ptr,
						    mlxsw_sp_port_dev_check,
						    mlxsw_sp_port_obj_add);
		return notifier_from_errno(err);
	case SWITCHDEV_PORT_OBJ_DEL:
		err = switchdev_handle_port_obj_del(dev, ptr,
						    mlxsw_sp_port_dev_check,
						    mlxsw_sp_port_obj_del);
		return notifier_from_errno(err);
	}

	return NOTIFY_DONE;
}

static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = {
	.notifier_call = mlxsw_sp_switchdev_blocking_event,
};

u8
u8
mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
{
{
@@ -3127,6 +3151,7 @@ mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
{
{
	struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
	struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
	struct notifier_block *nb;
	int err;
	int err;


	err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
	err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
@@ -3141,17 +3166,33 @@ static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
		return err;
		return err;
	}
	}


	nb = &mlxsw_sp_switchdev_blocking_notifier;
	err = register_switchdev_blocking_notifier(nb);
	if (err) {
		dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n");
		goto err_register_switchdev_blocking_notifier;
	}

	INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
	INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
	bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
	bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
	return 0;
	return 0;

err_register_switchdev_blocking_notifier:
	unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
	return err;
}
}


static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
{
{
	struct notifier_block *nb;

	cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
	cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
	unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);


	nb = &mlxsw_sp_switchdev_blocking_notifier;
	unregister_switchdev_blocking_notifier(nb);

	unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
}
}


int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
+28 −2
Original line number Original line Diff line number Diff line
@@ -1337,8 +1337,6 @@ static int ocelot_port_obj_del(struct net_device *dev,
static const struct switchdev_ops ocelot_port_switchdev_ops = {
static const struct switchdev_ops ocelot_port_switchdev_ops = {
	.switchdev_port_attr_get	= ocelot_port_attr_get,
	.switchdev_port_attr_get	= ocelot_port_attr_get,
	.switchdev_port_attr_set	= ocelot_port_attr_set,
	.switchdev_port_attr_set	= ocelot_port_attr_set,
	.switchdev_port_obj_add		= ocelot_port_obj_add,
	.switchdev_port_obj_del		= ocelot_port_obj_del,
};
};


static int ocelot_port_bridge_join(struct ocelot_port *ocelot_port,
static int ocelot_port_bridge_join(struct ocelot_port *ocelot_port,
@@ -1595,6 +1593,34 @@ struct notifier_block ocelot_netdevice_nb __read_mostly = {
};
};
EXPORT_SYMBOL(ocelot_netdevice_nb);
EXPORT_SYMBOL(ocelot_netdevice_nb);


static int ocelot_switchdev_blocking_event(struct notifier_block *unused,
					   unsigned long event, void *ptr)
{
	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
	int err;

	switch (event) {
		/* Blocking events. */
	case SWITCHDEV_PORT_OBJ_ADD:
		err = switchdev_handle_port_obj_add(dev, ptr,
						    ocelot_netdevice_dev_check,
						    ocelot_port_obj_add);
		return notifier_from_errno(err);
	case SWITCHDEV_PORT_OBJ_DEL:
		err = switchdev_handle_port_obj_del(dev, ptr,
						    ocelot_netdevice_dev_check,
						    ocelot_port_obj_del);
		return notifier_from_errno(err);
	}

	return NOTIFY_DONE;
}

struct notifier_block ocelot_switchdev_blocking_nb __read_mostly = {
	.notifier_call = ocelot_switchdev_blocking_event,
};
EXPORT_SYMBOL(ocelot_switchdev_blocking_nb);

int ocelot_probe_port(struct ocelot *ocelot, u8 port,
int ocelot_probe_port(struct ocelot *ocelot, u8 port,
		      void __iomem *regs,
		      void __iomem *regs,
		      struct phy_device *phy)
		      struct phy_device *phy)
+1 −0
Original line number Original line Diff line number Diff line
@@ -499,5 +499,6 @@ int ocelot_probe_port(struct ocelot *ocelot, u8 port,
		      struct phy_device *phy);
		      struct phy_device *phy);


extern struct notifier_block ocelot_netdevice_nb;
extern struct notifier_block ocelot_netdevice_nb;
extern struct notifier_block ocelot_switchdev_blocking_nb;


#endif
#endif
+3 −0
Original line number Original line Diff line number Diff line
@@ -12,6 +12,7 @@
#include <linux/of_platform.h>
#include <linux/of_platform.h>
#include <linux/mfd/syscon.h>
#include <linux/mfd/syscon.h>
#include <linux/skbuff.h>
#include <linux/skbuff.h>
#include <net/switchdev.h>


#include "ocelot.h"
#include "ocelot.h"


@@ -328,6 +329,7 @@ static int mscc_ocelot_probe(struct platform_device *pdev)
	}
	}


	register_netdevice_notifier(&ocelot_netdevice_nb);
	register_netdevice_notifier(&ocelot_netdevice_nb);
	register_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);


	dev_info(&pdev->dev, "Ocelot switch probed\n");
	dev_info(&pdev->dev, "Ocelot switch probed\n");


@@ -342,6 +344,7 @@ static int mscc_ocelot_remove(struct platform_device *pdev)
	struct ocelot *ocelot = platform_get_drvdata(pdev);
	struct ocelot *ocelot = platform_get_drvdata(pdev);


	ocelot_deinit(ocelot);
	ocelot_deinit(ocelot);
	unregister_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
	unregister_netdevice_notifier(&ocelot_netdevice_nb);
	unregister_netdevice_notifier(&ocelot_netdevice_nb);


	return 0;
	return 0;
+55 −5
Original line number Original line Diff line number Diff line
@@ -1632,9 +1632,6 @@ rocker_world_port_obj_vlan_add(struct rocker_port *rocker_port,
{
{
	struct rocker_world_ops *wops = rocker_port->rocker->wops;
	struct rocker_world_ops *wops = rocker_port->rocker->wops;


	if (netif_is_bridge_master(vlan->obj.orig_dev))
		return -EOPNOTSUPP;

	if (!wops->port_obj_vlan_add)
	if (!wops->port_obj_vlan_add)
		return -EOPNOTSUPP;
		return -EOPNOTSUPP;


@@ -2145,8 +2142,6 @@ static int rocker_port_obj_del(struct net_device *dev,
static const struct switchdev_ops rocker_port_switchdev_ops = {
static const struct switchdev_ops rocker_port_switchdev_ops = {
	.switchdev_port_attr_get	= rocker_port_attr_get,
	.switchdev_port_attr_get	= rocker_port_attr_get,
	.switchdev_port_attr_set	= rocker_port_attr_set,
	.switchdev_port_attr_set	= rocker_port_attr_set,
	.switchdev_port_obj_add		= rocker_port_obj_add,
	.switchdev_port_obj_del		= rocker_port_obj_del,
};
};


struct rocker_fib_event_work {
struct rocker_fib_event_work {
@@ -2812,12 +2807,54 @@ static int rocker_switchdev_event(struct notifier_block *unused,
	return NOTIFY_DONE;
	return NOTIFY_DONE;
}
}


static int
rocker_switchdev_port_obj_event(unsigned long event, struct net_device *netdev,
			struct switchdev_notifier_port_obj_info *port_obj_info)
{
	int err = -EOPNOTSUPP;

	switch (event) {
	case SWITCHDEV_PORT_OBJ_ADD:
		err = rocker_port_obj_add(netdev, port_obj_info->obj,
					  port_obj_info->trans);
		break;
	case SWITCHDEV_PORT_OBJ_DEL:
		err = rocker_port_obj_del(netdev, port_obj_info->obj);
		break;
	}

	port_obj_info->handled = true;
	return notifier_from_errno(err);
}

static int rocker_switchdev_blocking_event(struct notifier_block *unused,
					   unsigned long event, void *ptr)
{
	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);

	if (!rocker_port_dev_check(dev))
		return NOTIFY_DONE;

	switch (event) {
	case SWITCHDEV_PORT_OBJ_ADD:
	case SWITCHDEV_PORT_OBJ_DEL:
		return rocker_switchdev_port_obj_event(event, dev, ptr);
	}

	return NOTIFY_DONE;
}

static struct notifier_block rocker_switchdev_notifier = {
static struct notifier_block rocker_switchdev_notifier = {
	.notifier_call = rocker_switchdev_event,
	.notifier_call = rocker_switchdev_event,
};
};


static struct notifier_block rocker_switchdev_blocking_notifier = {
	.notifier_call = rocker_switchdev_blocking_event,
};

static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
{
	struct notifier_block *nb;
	struct rocker *rocker;
	struct rocker *rocker;
	int err;
	int err;


@@ -2933,6 +2970,13 @@ static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
		goto err_register_switchdev_notifier;
		goto err_register_switchdev_notifier;
	}
	}


	nb = &rocker_switchdev_blocking_notifier;
	err = register_switchdev_blocking_notifier(nb);
	if (err) {
		dev_err(&pdev->dev, "Failed to register switchdev blocking notifier\n");
		goto err_register_switchdev_blocking_notifier;
	}

	rocker->hw.id = rocker_read64(rocker, SWITCH_ID);
	rocker->hw.id = rocker_read64(rocker, SWITCH_ID);


	dev_info(&pdev->dev, "Rocker switch with id %*phN\n",
	dev_info(&pdev->dev, "Rocker switch with id %*phN\n",
@@ -2940,6 +2984,8 @@ static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)


	return 0;
	return 0;


err_register_switchdev_blocking_notifier:
	unregister_switchdev_notifier(&rocker_switchdev_notifier);
err_register_switchdev_notifier:
err_register_switchdev_notifier:
	unregister_fib_notifier(&rocker->fib_nb);
	unregister_fib_notifier(&rocker->fib_nb);
err_register_fib_notifier:
err_register_fib_notifier:
@@ -2971,6 +3017,10 @@ static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
static void rocker_remove(struct pci_dev *pdev)
static void rocker_remove(struct pci_dev *pdev)
{
{
	struct rocker *rocker = pci_get_drvdata(pdev);
	struct rocker *rocker = pci_get_drvdata(pdev);
	struct notifier_block *nb;

	nb = &rocker_switchdev_blocking_notifier;
	unregister_switchdev_blocking_notifier(nb);


	unregister_switchdev_notifier(&rocker_switchdev_notifier);
	unregister_switchdev_notifier(&rocker_switchdev_notifier);
	unregister_fib_notifier(&rocker->fib_nb);
	unregister_fib_notifier(&rocker->fib_nb);
Loading