drivers: net: use flow block API

This patch updates flow_block_cb_setup_simple() to use the flow block API.
Several drivers are also adjusted to use it.

This patch introduces the per-driver list of flow blocks to account for
blocks that are already in use.

Remove tc_block_offload alias.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index 06819590f6d06e51369dca4f60655aa08a435de2..3f632028eff035b66aa1c3206b98a144374b351f 100644 (file)
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -9907,6 +9907,8 @@ static int bnxt_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        }
 }
 
+static LIST_HEAD(bnxt_block_cb_list);
+
 static int bnxt_setup_tc(struct net_device *dev, enum tc_setup_type type,
                         void *type_data)
 {
@@ -9914,7 +9916,8 @@ static int bnxt_setup_tc(struct net_device *dev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &bnxt_block_cb_list,
                                                  bnxt_setup_tc_block_cb,
                                                  bp, bp, true);
        case TC_SETUP_QDISC_MQPRIO: {

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
index 89398ff011d4bc74d2692cb823deb3d46f1ef58b..f9bf7d7250abca8565684a2afa3bd9a29f347bbe 100644 (file)
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
@@ -161,6 +161,8 @@ static int bnxt_vf_rep_setup_tc_block_cb(enum tc_setup_type type,
        }
 }
 
+static LIST_HEAD(bnxt_vf_block_cb_list);
+
 static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
                                void *type_data)
 {
@@ -168,7 +170,8 @@ static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &bnxt_vf_block_cb_list,
                                                  bnxt_vf_rep_setup_tc_block_cb,
                                                  vf_rep, vf_rep, true);
        default:

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 9a486282a32e2984ac04ad072f847b1071c599cf..fdc8ca4f8891e854486f2c852830735a8003a6dc 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -3190,6 +3190,8 @@ static int cxgb_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        }
 }
 
+static LIST_HEAD(cxgb_block_cb_list);
+
 static int cxgb_setup_tc(struct net_device *dev, enum tc_setup_type type,
                         void *type_data)
 {
@@ -3197,7 +3199,8 @@ static int cxgb_setup_tc(struct net_device *dev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &cxgb_block_cb_list,
                                                  cxgb_setup_tc_block_cb,
                                                  pi, dev, true);
        default:

diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 52f0f14d42071a87411710afaf6e77607083ed10..7be1080680f5dbd065ec894b8b2947e6f1768bd1 100644 (file)
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -8177,6 +8177,8 @@ static int i40e_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        }
 }
 
+static LIST_HEAD(i40e_block_cb_list);
+
 static int __i40e_setup_tc(struct net_device *netdev, enum tc_setup_type type,
                           void *type_data)
 {
@@ -8186,7 +8188,8 @@ static int __i40e_setup_tc(struct net_device *netdev, enum tc_setup_type type,
        case TC_SETUP_QDISC_MQPRIO:
                return i40e_setup_tc(netdev, type_data);
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &i40e_block_cb_list,
                                                  i40e_setup_tc_block_cb,
                                                  np, np, true);
        default:

diff --git a/drivers/net/ethernet/intel/iavf/iavf_main.c b/drivers/net/ethernet/intel/iavf/iavf_main.c
index fd0e2bcc75e5b8d0a4c745e844bad3069ead0dc9..05eca6f2e890ff7759cbd6296ab4bb77ad7a05a9 100644 (file)
--- a/drivers/net/ethernet/intel/iavf/iavf_main.c
+++ b/drivers/net/ethernet/intel/iavf/iavf_main.c
@@ -3113,6 +3113,8 @@ static int iavf_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        }
 }
 
+static LIST_HEAD(iavf_block_cb_list);
+
 /**
  * iavf_setup_tc - configure multiple traffic classes
  * @netdev: network interface device structure
@@ -3133,7 +3135,8 @@ static int iavf_setup_tc(struct net_device *netdev, enum tc_setup_type type,
        case TC_SETUP_QDISC_MQPRIO:
                return __iavf_setup_tc(netdev, type_data);
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &iavf_block_cb_list,
                                                  iavf_setup_tc_block_cb,
                                                  adapter, adapter, true);
        default:

diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 836f9e1a136c8dc7a03b9c19ae3dc588a601e17a..00e8186e2c59347af106b1da6022aa742f3ed549 100644 (file)
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -2806,6 +2806,8 @@ static int igb_offload_txtime(struct igb_adapter *adapter,
        return 0;
 }
 
+static LIST_HEAD(igb_block_cb_list);
+
 static int igb_setup_tc(struct net_device *dev, enum tc_setup_type type,
                        void *type_data)
 {
@@ -2815,7 +2817,8 @@ static int igb_setup_tc(struct net_device *dev, enum tc_setup_type type,
        case TC_SETUP_QDISC_CBS:
                return igb_offload_cbs(adapter, type_data);
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &igb_block_cb_list,
                                                  igb_setup_tc_block_cb,
                                                  adapter, adapter, true);
 

diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index b098f5be9c0d8a96c5afe2684706ad3909e6a69f..cbaf712d6529bf0e1d20289c8d0d4a0466b79623 100644 (file)
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -9614,6 +9614,8 @@ static int ixgbe_setup_tc_mqprio(struct net_device *dev,
        return ixgbe_setup_tc(dev, mqprio->num_tc);
 }
 
+static LIST_HEAD(ixgbe_block_cb_list);
+
 static int __ixgbe_setup_tc(struct net_device *dev, enum tc_setup_type type,
                            void *type_data)
 {
@@ -9621,7 +9623,8 @@ static int __ixgbe_setup_tc(struct net_device *dev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &ixgbe_block_cb_list,
                                                  ixgbe_setup_tc_block_cb,
                                                  adapter, adapter, true);
        case TC_SETUP_QDISC_MQPRIO:

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
index 8e5ebdb7c459ad0ba359b3969cce8ca4658e690e..4c138789c547aa5d490f76061fc0bb60952b2176 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
@@ -3459,6 +3459,8 @@ static int mlx5e_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
 }
 #endif
 
+static LIST_HEAD(mlx5e_block_cb_list);
+
 static int mlx5e_setup_tc(struct net_device *dev, enum tc_setup_type type,
                          void *type_data)
 {
@@ -3467,7 +3469,8 @@ static int mlx5e_setup_tc(struct net_device *dev, enum tc_setup_type type,
        switch (type) {
 #ifdef CONFIG_MLX5_ESWITCH
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &mlx5e_block_cb_list,
                                                  mlx5e_setup_tc_block_cb,
                                                  priv, priv, true);
 #endif

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
index f2ad1ca7ed2a8bc9fd621d592178ad743ff1fe1b..7ca6b64720176674099bbbd3fc1b25ddaa267d95 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
@@ -693,17 +693,29 @@ static int mlx5e_rep_indr_setup_block_cb(enum tc_setup_type type,
        }
 }
 
+static void mlx5e_rep_indr_tc_block_unbind(void *cb_priv)
+{
+       struct mlx5e_rep_indr_block_priv *indr_priv = cb_priv;
+
+       list_del(&indr_priv->list);
+       kfree(indr_priv);
+}
+
+static LIST_HEAD(mlx5e_block_cb_list);
+
 static int
 mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,
                              struct mlx5e_rep_priv *rpriv,
-                             struct tc_block_offload *f)
+                             struct flow_block_offload *f)
 {
        struct mlx5e_rep_indr_block_priv *indr_priv;
-       int err = 0;
+       struct flow_block_cb *block_cb;
 
        if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
                return -EOPNOTSUPP;
 
+       f->driver_block_list = &mlx5e_block_cb_list;
+
        switch (f->command) {
        case FLOW_BLOCK_BIND:
                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev);
@@ -719,26 +731,32 @@ mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,
                list_add(&indr_priv->list,
                         &rpriv->uplink_priv.tc_indr_block_priv_list);
 
-               err = tcf_block_cb_register(f->block,
-                                           mlx5e_rep_indr_setup_block_cb,
-                                           indr_priv, indr_priv, f->extack);
-               if (err) {
+               block_cb = flow_block_cb_alloc(f->net,
+                                              mlx5e_rep_indr_setup_block_cb,
+                                              indr_priv, indr_priv,
+                                              mlx5e_rep_indr_tc_block_unbind);
+               if (IS_ERR(block_cb)) {
                        list_del(&indr_priv->list);
                        kfree(indr_priv);
+                       return PTR_ERR(block_cb);
                }
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &mlx5e_block_cb_list);
 
-               return err;
+               return 0;
        case FLOW_BLOCK_UNBIND:
                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev);
                if (!indr_priv)
                        return -ENOENT;
 
-               tcf_block_cb_unregister(f->block,
-                                       mlx5e_rep_indr_setup_block_cb,
-                                       indr_priv);
-               list_del(&indr_priv->list);
-               kfree(indr_priv);
+               block_cb = flow_block_cb_lookup(f,
+                                               mlx5e_rep_indr_setup_block_cb,
+                                               indr_priv);
+               if (!block_cb)
+                       return -ENOENT;
 
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index a178d082f061fb04a9ebbc029417e5f5a5003b7d..65bea6be84d68bfed074edb95176ddb0580928f4 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -1585,33 +1585,45 @@ static int mlxsw_sp_setup_tc_block_cb_flower(enum tc_setup_type type,
        }
 }
 
+static void mlxsw_sp_tc_block_flower_release(void *cb_priv)
+{
+       struct mlxsw_sp_acl_block *acl_block = cb_priv;
+
+       mlxsw_sp_acl_block_destroy(acl_block);
+}
+
+static LIST_HEAD(mlxsw_sp_block_cb_list);
+
 static int
 mlxsw_sp_setup_tc_block_flower_bind(struct mlxsw_sp_port *mlxsw_sp_port,
-                                   struct tcf_block *block, bool ingress,
-                                   struct netlink_ext_ack *extack)
+                                   struct flow_block_offload *f, bool ingress)
 {
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_acl_block *acl_block;
-       struct tcf_block_cb *block_cb;
+       struct flow_block_cb *block_cb;
+       bool register_block = false;
        int err;
 
-       block_cb = tcf_block_cb_lookup(block, mlxsw_sp_setup_tc_block_cb_flower,
-                                      mlxsw_sp);
+       block_cb = flow_block_cb_lookup(f, mlxsw_sp_setup_tc_block_cb_flower,
+                                       mlxsw_sp);
        if (!block_cb) {
-               acl_block = mlxsw_sp_acl_block_create(mlxsw_sp, block->net);
+               acl_block = mlxsw_sp_acl_block_create(mlxsw_sp, f->net);
                if (!acl_block)
                        return -ENOMEM;
-               block_cb = __tcf_block_cb_register(block,
-                                                  mlxsw_sp_setup_tc_block_cb_flower,
-                                                  mlxsw_sp, acl_block, extack);
+               block_cb = flow_block_cb_alloc(f->net,
+                                              mlxsw_sp_setup_tc_block_cb_flower,
+                                              mlxsw_sp, acl_block,
+                                              mlxsw_sp_tc_block_flower_release);
                if (IS_ERR(block_cb)) {
+                       mlxsw_sp_acl_block_destroy(acl_block);
                        err = PTR_ERR(block_cb);
                        goto err_cb_register;
                }
+               register_block = true;
        } else {
-               acl_block = tcf_block_cb_priv(block_cb);
+               acl_block = flow_block_cb_priv(block_cb);
        }
-       tcf_block_cb_incref(block_cb);
+       flow_block_cb_incref(block_cb);
        err = mlxsw_sp_acl_block_bind(mlxsw_sp, acl_block,
                                      mlxsw_sp_port, ingress);
        if (err)
@@ -1622,28 +1634,31 @@ mlxsw_sp_setup_tc_block_flower_bind(struct mlxsw_sp_port *mlxsw_sp_port,
        else
                mlxsw_sp_port->eg_acl_block = acl_block;
 
+       if (register_block) {
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &mlxsw_sp_block_cb_list);
+       }
+
        return 0;
 
 err_block_bind:
-       if (!tcf_block_cb_decref(block_cb)) {
-               __tcf_block_cb_unregister(block, block_cb);
+       if (!flow_block_cb_decref(block_cb))
+               flow_block_cb_free(block_cb);
 err_cb_register:
-               mlxsw_sp_acl_block_destroy(acl_block);
-       }
        return err;
 }
 
 static void
 mlxsw_sp_setup_tc_block_flower_unbind(struct mlxsw_sp_port *mlxsw_sp_port,
-                                     struct tcf_block *block, bool ingress)
+                                     struct flow_block_offload *f, bool ingress)
 {
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_acl_block *acl_block;
-       struct tcf_block_cb *block_cb;
+       struct flow_block_cb *block_cb;
        int err;
 
-       block_cb = tcf_block_cb_lookup(block, mlxsw_sp_setup_tc_block_cb_flower,
-                                      mlxsw_sp);
+       block_cb = flow_block_cb_lookup(f, mlxsw_sp_setup_tc_block_cb_flower,
+                                       mlxsw_sp);
        if (!block_cb)
                return;
 
@@ -1652,18 +1667,19 @@ mlxsw_sp_setup_tc_block_flower_unbind(struct mlxsw_sp_port *mlxsw_sp_port,
        else
                mlxsw_sp_port->eg_acl_block = NULL;
 
-       acl_block = tcf_block_cb_priv(block_cb);
+       acl_block = flow_block_cb_priv(block_cb);
        err = mlxsw_sp_acl_block_unbind(mlxsw_sp, acl_block,
                                        mlxsw_sp_port, ingress);
-       if (!err && !tcf_block_cb_decref(block_cb)) {
-               __tcf_block_cb_unregister(block, block_cb);
-               mlxsw_sp_acl_block_destroy(acl_block);
+       if (!err && !flow_block_cb_decref(block_cb)) {
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
        }
 }
 
 static int mlxsw_sp_setup_tc_block(struct mlxsw_sp_port *mlxsw_sp_port,
-                                  struct tc_block_offload *f)
+                                  struct flow_block_offload *f)
 {
+       struct flow_block_cb *block_cb;
        tc_setup_cb_t *cb;
        bool ingress;
        int err;
@@ -1678,24 +1694,32 @@ static int mlxsw_sp_setup_tc_block(struct mlxsw_sp_port *mlxsw_sp_port,
                return -EOPNOTSUPP;
        }
 
+       f->driver_block_list = &mlxsw_sp_block_cb_list;
+
        switch (f->command) {
        case FLOW_BLOCK_BIND:
-               err = tcf_block_cb_register(f->block, cb, mlxsw_sp_port,
-                                           mlxsw_sp_port, f->extack);
-               if (err)
-                       return err;
-               err = mlxsw_sp_setup_tc_block_flower_bind(mlxsw_sp_port,
-                                                         f->block, ingress,
-                                                         f->extack);
+               block_cb = flow_block_cb_alloc(f->net, cb, mlxsw_sp_port,
+                                              mlxsw_sp_port, NULL);
+               if (IS_ERR(block_cb))
+                       return PTR_ERR(block_cb);
+               err = mlxsw_sp_setup_tc_block_flower_bind(mlxsw_sp_port, f,
+                                                         ingress);
                if (err) {
-                       tcf_block_cb_unregister(f->block, cb, mlxsw_sp_port);
+                       flow_block_cb_free(block_cb);
                        return err;
                }
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &mlxsw_sp_block_cb_list);
                return 0;
        case FLOW_BLOCK_UNBIND:
                mlxsw_sp_setup_tc_block_flower_unbind(mlxsw_sp_port,
-                                                     f->block, ingress);
-               tcf_block_cb_unregister(f->block, cb, mlxsw_sp_port);
+                                                     f, ingress);
+               block_cb = flow_block_cb_lookup(f, cb, mlxsw_sp_port);
+               if (!block_cb)
+                       return -ENOENT;
+
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/drivers/net/ethernet/mscc/ocelot_ace.h b/drivers/net/ethernet/mscc/ocelot_ace.h
index d621683643e1792fbad6aa1589d715787cea88ee..e98944c87259172966922d2b2816638cd5e9fa52 100644 (file)
--- a/drivers/net/ethernet/mscc/ocelot_ace.h
+++ b/drivers/net/ethernet/mscc/ocelot_ace.h
@@ -225,8 +225,8 @@ int ocelot_ace_init(struct ocelot *ocelot);
 void ocelot_ace_deinit(void);
 
 int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
-                                     struct tc_block_offload *f);
+                                     struct flow_block_offload *f);
 void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
-                                        struct tc_block_offload *f);
+                                        struct flow_block_offload *f);
 
 #endif /* _MSCC_OCELOT_ACE_H_ */

diff --git a/drivers/net/ethernet/mscc/ocelot_flower.c b/drivers/net/ethernet/mscc/ocelot_flower.c
index b682f08a93b42873dd646ab81d0da197e2304d57..5b92c2a03f3d13ab4ba583359f581d6681bcd496 100644 (file)
--- a/drivers/net/ethernet/mscc/ocelot_flower.c
+++ b/drivers/net/ethernet/mscc/ocelot_flower.c
@@ -299,36 +299,45 @@ static void ocelot_port_block_destroy(struct ocelot_port_block *block)
        kfree(block);
 }
 
+static void ocelot_tc_block_unbind(void *cb_priv)
+{
+       struct ocelot_port_block *port_block = cb_priv;
+
+       ocelot_port_block_destroy(port_block);
+}
+
 int ocelot_setup_tc_block_flower_bind(struct ocelot_port *port,
-                                     struct tc_block_offload *f)
+                                     struct flow_block_offload *f)
 {
        struct ocelot_port_block *port_block;
-       struct tcf_block_cb *block_cb;
+       struct flow_block_cb *block_cb;
        int ret;
 
        if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
                return -EOPNOTSUPP;
 
-       block_cb = tcf_block_cb_lookup(f->block,
-                                      ocelot_setup_tc_block_cb_flower, port);
+       block_cb = flow_block_cb_lookup(f, ocelot_setup_tc_block_cb_flower,
+                                       port);
        if (!block_cb) {
                port_block = ocelot_port_block_create(port);
                if (!port_block)
                        return -ENOMEM;
 
-               block_cb =
-                       __tcf_block_cb_register(f->block,
-                                               ocelot_setup_tc_block_cb_flower,
-                                               port, port_block, f->extack);
+               block_cb = flow_block_cb_alloc(f->net,
+                                              ocelot_setup_tc_block_cb_flower,
+                                              port, port_block,
+                                              ocelot_tc_block_unbind);
                if (IS_ERR(block_cb)) {
                        ret = PTR_ERR(block_cb);
                        goto err_cb_register;
                }
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, f->driver_block_list);
        } else {
-               port_block = tcf_block_cb_priv(block_cb);
+               port_block = flow_block_cb_priv(block_cb);
        }
 
-       tcf_block_cb_incref(block_cb);
+       flow_block_cb_incref(block_cb);
        return 0;
 
 err_cb_register:
@@ -338,20 +347,17 @@ err_cb_register:
 }
 
 void ocelot_setup_tc_block_flower_unbind(struct ocelot_port *port,
-                                        struct tc_block_offload *f)
+                                        struct flow_block_offload *f)
 {
-       struct ocelot_port_block *port_block;
-       struct tcf_block_cb *block_cb;
+       struct flow_block_cb *block_cb;
 
-       block_cb = tcf_block_cb_lookup(f->block,
-                                      ocelot_setup_tc_block_cb_flower, port);
+       block_cb = flow_block_cb_lookup(f, ocelot_setup_tc_block_cb_flower,
+                                       port);
        if (!block_cb)
                return;
 
-       port_block = tcf_block_cb_priv(block_cb);
-       if (!tcf_block_cb_decref(block_cb)) {
-               tcf_block_cb_unregister(f->block,
-                                       ocelot_setup_tc_block_cb_flower, port);
-               ocelot_port_block_destroy(port_block);
+       if (!flow_block_cb_decref(block_cb)) {
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
        }
 }

diff --git a/drivers/net/ethernet/mscc/ocelot_tc.c b/drivers/net/ethernet/mscc/ocelot_tc.c
index 58a0b5f8850cba02521fa6ec1d596ea3a40c553d..935a774cb291bdf936e077a656a36e88ce9f4165 100644 (file)
--- a/drivers/net/ethernet/mscc/ocelot_tc.c
+++ b/drivers/net/ethernet/mscc/ocelot_tc.c
@@ -128,35 +128,51 @@ static int ocelot_setup_tc_block_cb_eg(enum tc_setup_type type,
                                        cb_priv, false);
 }
 
+static LIST_HEAD(ocelot_block_cb_list);
+
 static int ocelot_setup_tc_block(struct ocelot_port *port,
-                                struct tc_block_offload *f)
+                                struct flow_block_offload *f)
 {
+       struct flow_block_cb *block_cb;
        tc_setup_cb_t *cb;
-       int ret;
+       int err;
 
        netdev_dbg(port->dev, "tc_block command %d, binder_type %d\n",
                   f->command, f->binder_type);
 
        if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) {
                cb = ocelot_setup_tc_block_cb_ig;
-               port->tc.block_shared = tcf_block_shared(f->block);
+               port->tc.block_shared = f->block_shared;
        } else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) {
                cb = ocelot_setup_tc_block_cb_eg;
        } else {
                return -EOPNOTSUPP;
        }
 
+       f->driver_block_list = &ocelot_block_cb_list;
+
        switch (f->command) {
        case FLOW_BLOCK_BIND:
-               ret = tcf_block_cb_register(f->block, cb, port,
-                                           port, f->extack);
-               if (ret)
-                       return ret;
+               block_cb = flow_block_cb_alloc(f->net, cb, port, port, NULL);
+               if (IS_ERR(block_cb))
+                       return PTR_ERR(block_cb);
 
-               return ocelot_setup_tc_block_flower_bind(port, f);
+               err = ocelot_setup_tc_block_flower_bind(port, f);
+               if (err < 0) {
+                       flow_block_cb_free(block_cb);
+                       return err;
+               }
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, f->driver_block_list);
+               return 0;
        case FLOW_BLOCK_UNBIND:
+               block_cb = flow_block_cb_lookup(f, cb, port);
+               if (!block_cb)
+                       return -ENOENT;
+
                ocelot_setup_tc_block_flower_unbind(port, f);
-               tcf_block_cb_unregister(f->block, cb, port);
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/drivers/net/ethernet/netronome/nfp/abm/cls.c b/drivers/net/ethernet/netronome/nfp/abm/cls.c
index 29fb45734962f6b375cf07368f2dbfe5053f1fcd..23ebddfb953255802065799421f1c9ef80ea09b5 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/abm/cls.c
+++ b/drivers/net/ethernet/netronome/nfp/abm/cls.c
@@ -262,9 +262,12 @@ static int nfp_abm_setup_tc_block_cb(enum tc_setup_type type,
        }
 }
 
+static LIST_HEAD(nfp_abm_block_cb_list);
+
 int nfp_abm_setup_cls_block(struct net_device *netdev, struct nfp_repr *repr,
-                           struct tc_block_offload *f)
+                           struct flow_block_offload *f)
 {
-       return flow_block_cb_setup_simple(f, NULL, nfp_abm_setup_tc_block_cb,
+       return flow_block_cb_setup_simple(f, &nfp_abm_block_cb_list,
+                                         nfp_abm_setup_tc_block_cb,
                                          repr, repr, true);
 }

diff --git a/drivers/net/ethernet/netronome/nfp/abm/main.h b/drivers/net/ethernet/netronome/nfp/abm/main.h
index 49749c60885e128dc6da947cceff00bf03f8e490..48746c9c6224cced6898fa0a2842d76ee1b151b0 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/abm/main.h
+++ b/drivers/net/ethernet/netronome/nfp/abm/main.h
@@ -247,7 +247,7 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink,
 int nfp_abm_setup_tc_gred(struct net_device *netdev, struct nfp_abm_link *alink,
                          struct tc_gred_qopt_offload *opt);
 int nfp_abm_setup_cls_block(struct net_device *netdev, struct nfp_repr *repr,
-                           struct tc_block_offload *opt);
+                           struct flow_block_offload *opt);
 
 int nfp_abm_ctrl_read_params(struct nfp_abm_link *alink);
 int nfp_abm_ctrl_find_addrs(struct nfp_abm *abm);

diff --git a/drivers/net/ethernet/netronome/nfp/bpf/main.c b/drivers/net/ethernet/netronome/nfp/bpf/main.c
index 0c93c84a188a5eafe7f25e358d098525692d2782..1c9fb11470df7b3d4af3f8ee749c6cc2a10c2d94 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/bpf/main.c
+++ b/drivers/net/ethernet/netronome/nfp/bpf/main.c
@@ -160,6 +160,8 @@ static int nfp_bpf_setup_tc_block_cb(enum tc_setup_type type,
        return 0;
 }
 
+static LIST_HEAD(nfp_bpf_block_cb_list);
+
 static int nfp_bpf_setup_tc(struct nfp_app *app, struct net_device *netdev,
                            enum tc_setup_type type, void *type_data)
 {
@@ -167,7 +169,8 @@ static int nfp_bpf_setup_tc(struct nfp_app *app, struct net_device *netdev,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &nfp_bpf_block_cb_list,
                                                  nfp_bpf_setup_tc_block_cb,
                                                  nn, nn, true);
        default:

diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c
index 46041e5091508611d54098c9dba832e687ed02bd..ddd6b509f27e663d62c933f2ccfb7fc3031f3f4e 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/offload.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c
@@ -1302,27 +1302,41 @@ static int nfp_flower_setup_tc_block_cb(enum tc_setup_type type,
        }
 }
 
+static LIST_HEAD(nfp_block_cb_list);
+
 static int nfp_flower_setup_tc_block(struct net_device *netdev,
-                                    struct tc_block_offload *f)
+                                    struct flow_block_offload *f)
 {
        struct nfp_repr *repr = netdev_priv(netdev);
        struct nfp_flower_repr_priv *repr_priv;
+       struct flow_block_cb *block_cb;
 
        if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
                return -EOPNOTSUPP;
 
        repr_priv = repr->app_priv;
-       repr_priv->block_shared = tcf_block_shared(f->block);
+       repr_priv->block_shared = f->block_shared;
+       f->driver_block_list = &nfp_block_cb_list;
 
        switch (f->command) {
        case FLOW_BLOCK_BIND:
-               return tcf_block_cb_register(f->block,
-                                            nfp_flower_setup_tc_block_cb,
-                                            repr, repr, f->extack);
+               block_cb = flow_block_cb_alloc(f->net,
+                                              nfp_flower_setup_tc_block_cb,
+                                              repr, repr, NULL);
+               if (IS_ERR(block_cb))
+                       return PTR_ERR(block_cb);
+
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &nfp_block_cb_list);
+               return 0;
        case FLOW_BLOCK_UNBIND:
-               tcf_block_cb_unregister(f->block,
-                                       nfp_flower_setup_tc_block_cb,
-                                       repr);
+               block_cb = flow_block_cb_lookup(f, nfp_flower_setup_tc_block_cb,
+                                               repr);
+               if (!block_cb)
+                       return -ENOENT;
+
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;
@@ -1381,13 +1395,21 @@ static int nfp_flower_setup_indr_block_cb(enum tc_setup_type type,
        }
 }
 
+static void nfp_flower_setup_indr_tc_release(void *cb_priv)
+{
+       struct nfp_flower_indr_block_cb_priv *priv = cb_priv;
+
+       list_del(&priv->list);
+       kfree(priv);
+}
+
 static int
 nfp_flower_setup_indr_tc_block(struct net_device *netdev, struct nfp_app *app,
-                              struct tc_block_offload *f)
+                              struct flow_block_offload *f)
 {
        struct nfp_flower_indr_block_cb_priv *cb_priv;
        struct nfp_flower_priv *priv = app->priv;
-       int err;
+       struct flow_block_cb *block_cb;
 
        if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS &&
            !(f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS &&
@@ -1404,26 +1426,32 @@ nfp_flower_setup_indr_tc_block(struct net_device *netdev, struct nfp_app *app,
                cb_priv->app = app;
                list_add(&cb_priv->list, &priv->indr_block_cb_priv);
 
-               err = tcf_block_cb_register(f->block,
-                                           nfp_flower_setup_indr_block_cb,
-                                           cb_priv, cb_priv, f->extack);
-               if (err) {
+               block_cb = flow_block_cb_alloc(f->net,
+                                              nfp_flower_setup_indr_block_cb,
+                                              cb_priv, cb_priv,
+                                              nfp_flower_setup_indr_tc_release);
+               if (IS_ERR(block_cb)) {
                        list_del(&cb_priv->list);
                        kfree(cb_priv);
+                       return PTR_ERR(block_cb);
                }
 
-               return err;
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &nfp_block_cb_list);
+               return 0;
        case FLOW_BLOCK_UNBIND:
                cb_priv = nfp_flower_indr_block_cb_priv_lookup(app, netdev);
                if (!cb_priv)
                        return -ENOENT;
 
-               tcf_block_cb_unregister(f->block,
-                                       nfp_flower_setup_indr_block_cb,
-                                       cb_priv);
-               list_del(&cb_priv->list);
-               kfree(cb_priv);
+               block_cb = flow_block_cb_lookup(f,
+                                               nfp_flower_setup_indr_block_cb,
+                                               cb_priv);
+               if (!block_cb)
+                       return -ENOENT;
 
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index cba97ed3dd5631eb69925dc36c2967cc6fc1a465..1be593a6e20d8b5e72e8b27ecf8389395e36cc2d 100644 (file)
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -579,6 +579,8 @@ static int qede_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        }
 }
 
+static LIST_HEAD(qede_block_cb_list);
+
 static int
 qede_setup_tc_offload(struct net_device *dev, enum tc_setup_type type,
                      void *type_data)
@@ -588,7 +590,8 @@ qede_setup_tc_offload(struct net_device *dev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &qede_block_cb_list,
                                                  qede_setup_tc_block_cb,
                                                  edev, edev, true);
        case TC_SETUP_QDISC_MQPRIO:

diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 93ef80c16f078dc95f719f378f1b72191e99733b..c7c9e5f162e6de73f2534dc5f8d5b5a38222e743 100644 (file)
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -3769,6 +3769,8 @@ static int stmmac_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
        return ret;
 }
 
+static LIST_HEAD(stmmac_block_cb_list);
+
 static int stmmac_setup_tc(struct net_device *ndev, enum tc_setup_type type,
                           void *type_data)
 {
@@ -3776,7 +3778,8 @@ static int stmmac_setup_tc(struct net_device *ndev, enum tc_setup_type type,
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &stmmac_block_cb_list,
                                                  stmmac_setup_tc_block_cb,
                                                  priv, priv, true);
        case TC_SETUP_QDISC_CBS:

diff --git a/drivers/net/netdevsim/netdev.c b/drivers/net/netdevsim/netdev.c
index 920dc79e9dc94063beed6578969938640cbee364..0740940f41b12949558b6150edec27917d3cfe3c 100644 (file)
--- a/drivers/net/netdevsim/netdev.c
+++ b/drivers/net/netdevsim/netdev.c
@@ -203,6 +203,8 @@ static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
        return 0;
 }
 
+static LIST_HEAD(nsim_block_cb_list);
+
 static int
 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
 {
@@ -210,7 +212,8 @@ nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
 
        switch (type) {
        case TC_SETUP_BLOCK:
-               return flow_block_cb_setup_simple(type_data, NULL,
+               return flow_block_cb_setup_simple(type_data,
+                                                 &nsim_block_cb_list,
                                                  nsim_setup_tc_block_cb,
                                                  ns, ns, true);
        default:

diff --git a/include/net/flow_offload.h b/include/net/flow_offload.h
index 3fb9cc4da63eec4ac7a87d17793924161f3b8496..377ba0004370bb87960c56147c23eb17d7bb73bd 100644 (file)
--- a/include/net/flow_offload.h
+++ b/include/net/flow_offload.h
@@ -249,13 +249,12 @@ enum flow_block_binder_type {
        FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
 };
 
-struct tcf_block;
 struct netlink_ext_ack;
 
 struct flow_block_offload {
        enum flow_block_command command;
        enum flow_block_binder_type binder_type;
-       struct tcf_block *block;
+       bool block_shared;
        struct net *net;
        struct list_head cb_list;
        struct list_head *driver_block_list;

diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index e4499526fde80c7a6333a43058f74498c14e7382..9cf606b88526340beaac1ceebef660868e8657f5 100644 (file)
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -26,8 +26,6 @@ struct tcf_walker {
 int register_tcf_proto_ops(struct tcf_proto_ops *ops);
 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
 
-#define tc_block_offload flow_block_offload
-
 struct tcf_block_ext_info {
        enum flow_block_binder_type binder_type;
        tcf_chain_head_change_t *chain_head_change;

diff --git a/net/core/flow_offload.c b/net/core/flow_offload.c
index a36a9dc1c6df74939235ddba3554ca05db85c47e..a1b36b47dd89a9aed4b650fbcdc7a0647173e7a3 100644 (file)
--- a/net/core/flow_offload.c
+++ b/net/core/flow_offload.c
@@ -2,7 +2,6 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <net/flow_offload.h>
-#include <net/pkt_cls.h>
 
 struct flow_rule *flow_rule_alloc(unsigned int num_actions)
 {
@@ -234,6 +233,8 @@ int flow_block_cb_setup_simple(struct flow_block_offload *f,
                               tc_setup_cb_t *cb, void *cb_ident, void *cb_priv,
                               bool ingress_only)
 {
+       struct flow_block_cb *block_cb;
+
        if (ingress_only &&
            f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
                return -EOPNOTSUPP;
@@ -242,10 +243,21 @@ int flow_block_cb_setup_simple(struct flow_block_offload *f,
 
        switch (f->command) {
        case FLOW_BLOCK_BIND:
-               return tcf_block_cb_register(f->block, cb, cb_ident, cb_priv,
-                                            f->extack);
+               block_cb = flow_block_cb_alloc(f->net, cb, cb_ident,
+                                              cb_priv, NULL);
+               if (IS_ERR(block_cb))
+                       return PTR_ERR(block_cb);
+
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, driver_block_list);
+               return 0;
        case FLOW_BLOCK_UNBIND:
-               tcf_block_cb_unregister(f->block, cb, cb_ident);
+               block_cb = flow_block_cb_lookup(f, cb, cb_ident);
+               if (!block_cb)
+                       return -ENOENT;
+
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index 9b5e202c255e4dcb8adcbb6b8cdd38ef7452c6a7..90c32fd680dbc7981d6fb092b7998c908ef2022b 100644 (file)
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -942,9 +942,12 @@ static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
        return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
 }
 
+static LIST_HEAD(dsa_slave_block_cb_list);
+
 static int dsa_slave_setup_tc_block(struct net_device *dev,
-                                   struct tc_block_offload *f)
+                                   struct flow_block_offload *f)
 {
+       struct flow_block_cb *block_cb;
        tc_setup_cb_t *cb;
 
        if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
@@ -954,11 +957,24 @@ static int dsa_slave_setup_tc_block(struct net_device *dev,
        else
                return -EOPNOTSUPP;
 
+       f->driver_block_list = &dsa_slave_block_cb_list;
+
        switch (f->command) {
        case FLOW_BLOCK_BIND:
-               return tcf_block_cb_register(f->block, cb, dev, dev, f->extack);
+               block_cb = flow_block_cb_alloc(f->net, cb, dev, dev, NULL);
+               if (IS_ERR(block_cb))
+                       return PTR_ERR(block_cb);
+
+               flow_block_cb_add(block_cb, f);
+               list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
+               return 0;
        case FLOW_BLOCK_UNBIND:
-               tcf_block_cb_unregister(f->block, cb, dev);
+               block_cb = flow_block_cb_lookup(f, cb, dev);
+               if (!block_cb)
+                       return -ENOENT;
+
+               flow_block_cb_remove(block_cb, f);
+               list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;

diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index f6602d0000e87301169dbfb7503f775d2c2c005a..3589ccff5570277ba4a51bad94f707390d25a0d6 100644 (file)
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -680,11 +680,11 @@ static void tc_indr_block_ing_cmd(struct tc_indr_block_dev *indr_dev,
                                  struct tc_indr_block_cb *indr_block_cb,
                                  enum flow_block_command command)
 {
-       struct tc_block_offload bo = {
+       struct flow_block_offload bo = {
                .command        = command,
                .binder_type    = FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
                .net            = dev_net(indr_dev->dev),
-               .block          = indr_dev->block,
+               .block_shared   = tcf_block_shared(indr_dev->block),
        };
        INIT_LIST_HEAD(&bo.cb_list);
 
@@ -771,11 +771,11 @@ static void tc_indr_block_call(struct tcf_block *block, struct net_device *dev,
 {
        struct tc_indr_block_cb *indr_block_cb;
        struct tc_indr_block_dev *indr_dev;
-       struct tc_block_offload bo = {
+       struct flow_block_offload bo = {
                .command        = command,
                .binder_type    = ei->binder_type,
                .net            = dev_net(dev),
-               .block          = block,
+               .block_shared   = tcf_block_shared(block),
                .extack         = extack,
        };
        INIT_LIST_HEAD(&bo.cb_list);
@@ -804,13 +804,13 @@ static int tcf_block_offload_cmd(struct tcf_block *block,
                                 enum flow_block_command command,
                                 struct netlink_ext_ack *extack)
 {
-       struct tc_block_offload bo = {};
+       struct flow_block_offload bo = {};
        int err;
 
        bo.net = dev_net(dev);
        bo.command = command;
        bo.binder_type = ei->binder_type;
-       bo.block = block;
+       bo.block_shared = tcf_block_shared(block);
        bo.extack = extack;
        INIT_LIST_HEAD(&bo.cb_list);
 
@@ -3245,7 +3245,7 @@ EXPORT_SYMBOL(tcf_exts_dump_stats);
 int tc_setup_cb_call(struct tcf_block *block, enum tc_setup_type type,
                     void *type_data, bool err_stop)
 {
-       struct tcf_block_cb *block_cb;
+       struct flow_block_cb *block_cb;
        int ok_count = 0;
        int err;