linux-imx
Public
Source
committed 91cf8eceffcx
#include <linux/notifier.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/if_bridge.h>#include <linux/list.h>#include <linux/workqueue.h>#include <linux/if_vlan.h>#include <linux/rtnetlink.h>#include <net/switchdev.h>/** * switchdev_trans_item_enqueue - Enqueue data item to transaction queue * * @trans: transaction * @data: pointer to data being queued * @destructor: data destructor * @tritem: transaction item being queued * * Enqeueue data item to transaction queue. tritem is typically placed in * cointainter pointed at by data pointer. Destructor is called on * transaction abort and after successful commit phase in case * the caller did not dequeue the item before. */void switchdev_trans_item_enqueue(struct switchdev_trans *trans, void *data, void (*destructor)(void const *), struct switchdev_trans_item *tritem){ tritem->data = data; tritem->destructor = destructor; list_add_tail(&tritem->list, &trans->item_list);}EXPORT_SYMBOL_GPL(switchdev_trans_item_enqueue);static struct switchdev_trans_item *__switchdev_trans_item_dequeue(struct switchdev_trans *trans){ struct switchdev_trans_item *tritem; if (list_empty(&trans->item_list)) return NULL; tritem = list_first_entry(&trans->item_list, struct switchdev_trans_item, list); list_del(&tritem->list); return tritem;}/** * switchdev_trans_item_dequeue - Dequeue data item from transaction queue * * @trans: transaction */void *switchdev_trans_item_dequeue(struct switchdev_trans *trans){ struct switchdev_trans_item *tritem; tritem = __switchdev_trans_item_dequeue(trans); BUG_ON(!tritem); return tritem->data;}EXPORT_SYMBOL_GPL(switchdev_trans_item_dequeue);static void switchdev_trans_init(struct switchdev_trans *trans){ INIT_LIST_HEAD(&trans->item_list);}static void switchdev_trans_items_destroy(struct switchdev_trans *trans){ struct switchdev_trans_item *tritem; while ((tritem = __switchdev_trans_item_dequeue(trans))) tritem->destructor(tritem->data);}static void switchdev_trans_items_warn_destroy(struct net_device *dev, struct switchdev_trans *trans){ WARN(!list_empty(&trans->item_list), "%s: transaction item queue is not empty.\n", dev->name); switchdev_trans_items_destroy(trans);}static LIST_HEAD(deferred);static DEFINE_SPINLOCK(deferred_lock);typedef void switchdev_deferred_func_t(struct net_device *dev, const void *data);struct switchdev_deferred_item { struct list_head list; struct net_device *dev; switchdev_deferred_func_t *func; return 0;}static int switchdev_port_attr_set_now(struct net_device *dev, const struct switchdev_attr *attr){ struct switchdev_trans trans; int err; switchdev_trans_init(&trans); /* Phase I: prepare for attr set. Driver/device should fail * here if there are going to be issues in the commit phase, * such as lack of resources or support. The driver/device * should reserve resources needed for the commit phase here, * but should not commit the attr. */ trans.ph_prepare = true; err = switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr, &trans); if (err) { /* Prepare phase failed: abort the transaction. Any * resources reserved in the prepare phase are * released. */ if (err != -EOPNOTSUPP) switchdev_trans_items_destroy(&trans); if (err) return err; } /* Phase II: commit attr set. This cannot fail as a fault * of driver/device. If it does, it's a bug in the driver/device * because the driver said everythings was OK in phase I. */ trans.ph_prepare = false; err = switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr, &trans); WARN(err, "%s: Commit of attribute (id=%d) failed.\n", dev->name, attr->id); switchdev_trans_items_warn_destroy(dev, &trans); return err;}static void switchdev_port_attr_set_deferred(struct net_device *dev, const void *data){ const struct switchdev_attr *attr = data; int err;static int switchdev_port_obj_add_now(struct net_device *dev, const struct switchdev_obj *obj, struct netlink_ext_ack *extack){ struct switchdev_trans trans; int err; ASSERT_RTNL(); switchdev_trans_init(&trans); /* Phase I: prepare for obj add. Driver/device should fail * here if there are going to be issues in the commit phase, * such as lack of resources or support. The driver/device * should reserve resources needed for the commit phase here, * but should not commit the obj. */ trans.ph_prepare = true; err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, dev, obj, &trans, extack); if (err) { /* Prepare phase failed: abort the transaction. Any * resources reserved in the prepare phase are * released. */ if (err != -EOPNOTSUPP) switchdev_trans_items_destroy(&trans); if (err) return err; } /* Phase II: commit obj add. This cannot fail as a fault * of driver/device. If it does, it's a bug in the driver/device * because the driver said everythings was OK in phase I. */ trans.ph_prepare = false; err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, dev, obj, &trans, extack); WARN(err, "%s: Commit of object (id=%d) failed.\n", dev->name, obj->id); switchdev_trans_items_warn_destroy(dev, &trans); return err;}static void switchdev_port_obj_add_deferred(struct net_device *dev, const void *data){ const struct switchdev_obj *obj = data; int err;