drivers/net/ethernet/sfc/tc_bindings.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /****************************************************************************
   3  * Driver for Solarflare network controllers and boards
   4  * Copyright 2022 Xilinx Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include "tc_bindings.h"
  12 #include "tc.h"
  13 #include "tc_encap_actions.h"
  14
  15 struct efx_tc_block_binding {
  16         struct list_head list;
  17         struct efx_nic *efx;
  18         struct efx_rep *efv;
  19         struct net_device *otherdev; /* may actually be us */
  20         struct flow_block *block;
  21 };
  22
  23 static struct efx_tc_block_binding *efx_tc_find_binding(struct efx_nic *efx,
  24                                                         struct net_device *otherdev)
  25 {
  26         struct efx_tc_block_binding *binding;
  27
  28         ASSERT_RTNL();
  29         list_for_each_entry(binding, &efx->tc->block_list, list)
  30                 if (binding->otherdev == otherdev)
  31                         return binding;
  32         return NULL;
  33 }
  34
  35 static int efx_tc_block_cb(enum tc_setup_type type, void *type_data,
  36                            void *cb_priv)
  37 {
  38         struct efx_tc_block_binding *binding = cb_priv;
  39         struct flow_cls_offload *tcf = type_data;
  40
  41         switch (type) {
  42         case TC_SETUP_CLSFLOWER:
  43                 return efx_tc_flower(binding->efx, binding->otherdev,
  44                                      tcf, binding->efv);
  45         default:
  46                 return -EOPNOTSUPP;
  47         }
  48 }
  49
  50 void efx_tc_block_unbind(void *cb_priv)
  51 {
  52         struct efx_tc_block_binding *binding = cb_priv;
  53
  54         list_del(&binding->list);
  55         kfree(binding);
  56 }
  57
  58 static struct efx_tc_block_binding *efx_tc_create_binding(
  59                         struct efx_nic *efx, struct efx_rep *efv,
  60                         struct net_device *otherdev, struct flow_block *block)
  61 {
  62         struct efx_tc_block_binding *binding = kmalloc(sizeof(*binding), GFP_KERNEL);
  63
  64         if (!binding)
  65                 return ERR_PTR(-ENOMEM);
  66         binding->efx = efx;
  67         binding->efv = efv;
  68         binding->otherdev = otherdev;
  69         binding->block = block;
  70         list_add(&binding->list, &efx->tc->block_list);
  71         return binding;
  72 }
  73
  74 int efx_tc_setup_block(struct net_device *net_dev, struct efx_nic *efx,
  75                        struct flow_block_offload *tcb, struct efx_rep *efv)
  76 {
  77         struct efx_tc_block_binding *binding;
  78         struct flow_block_cb *block_cb;
  79         int rc;
  80
  81         if (tcb->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
  82                 return -EOPNOTSUPP;
  83
  84         if (WARN_ON(!efx->tc))
  85                 return -ENETDOWN;
  86
  87         switch (tcb->command) {
  88         case FLOW_BLOCK_BIND:
  89                 binding = efx_tc_create_binding(efx, efv, net_dev, tcb->block);
  90                 if (IS_ERR(binding))
  91                         return PTR_ERR(binding);
  92                 block_cb = flow_block_cb_alloc(efx_tc_block_cb, binding,
  93                                                binding, efx_tc_block_unbind);
  94                 rc = PTR_ERR_OR_ZERO(block_cb);
  95                 netif_dbg(efx, drv, efx->net_dev,
  96                           "bind %sdirect block for device %s, rc %d\n",
  97                           net_dev == efx->net_dev ? "" :
  98                           efv ? "semi" : "in",
  99                           net_dev ? net_dev->name : NULL, rc);
 100                 if (rc) {
 101                         list_del(&binding->list);
 102                         kfree(binding);
 103                 } else {
 104                         flow_block_cb_add(block_cb, tcb);
 105                 }
 106                 return rc;
 107         case FLOW_BLOCK_UNBIND:
 108                 binding = efx_tc_find_binding(efx, net_dev);
 109                 if (binding) {
 110                         block_cb = flow_block_cb_lookup(tcb->block,
 111                                                         efx_tc_block_cb,
 112                                                         binding);
 113                         if (block_cb) {
 114                                 flow_block_cb_remove(block_cb, tcb);
 115                                 netif_dbg(efx, drv, efx->net_dev,
 116                                           "unbound %sdirect block for device %s\n",
 117                                           net_dev == efx->net_dev ? "" :
 118                                           binding->efv ? "semi" : "in",
 119                                           net_dev ? net_dev->name : NULL);
 120                                 return 0;
 121                         }
 122                 }
 123                 /* If we're in driver teardown, then we expect to have
 124                  * already unbound all our blocks (we did it early while
 125                  * we still had MCDI to remove the filters), so getting
 126                  * unbind callbacks now isn't a problem.
 127                  */
 128                 netif_cond_dbg(efx, drv, efx->net_dev,
 129                                !efx->tc->up, warn,
 130                                "%sdirect block unbind for device %s, was never bound\n",
 131                                net_dev == efx->net_dev ? "" : "in",
 132                                net_dev ? net_dev->name : NULL);
 133                 return -ENOENT;
 134         default:
 135                 return -EOPNOTSUPP;
 136         }
 137 }
 138
 139 int efx_tc_indr_setup_cb(struct net_device *net_dev, struct Qdisc *sch,
 140                          void *cb_priv, enum tc_setup_type type,
 141                          void *type_data, void *data,
 142                          void (*cleanup)(struct flow_block_cb *block_cb))
 143 {
 144         struct flow_block_offload *tcb = type_data;
 145         struct efx_tc_block_binding *binding;
 146         struct flow_block_cb *block_cb;
 147         struct efx_nic *efx = cb_priv;
 148         bool is_ovs_int_port;
 149         int rc;
 150
 151         if (!net_dev)
 152                 return -EOPNOTSUPP;
 153
 154         if (tcb->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS &&
 155             tcb->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
 156                 return -EOPNOTSUPP;
 157
 158         is_ovs_int_port = netif_is_ovs_master(net_dev);
 159         if (tcb->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS &&
 160             !is_ovs_int_port)
 161                 return -EOPNOTSUPP;
 162
 163         if (is_ovs_int_port)
 164                 return -EOPNOTSUPP;
 165
 166         switch (type) {
 167         case TC_SETUP_BLOCK:
 168                 switch (tcb->command) {
 169                 case FLOW_BLOCK_BIND:
 170                         binding = efx_tc_create_binding(efx, NULL, net_dev, tcb->block);
 171                         if (IS_ERR(binding))
 172                                 return PTR_ERR(binding);
 173                         block_cb = flow_indr_block_cb_alloc(efx_tc_block_cb, binding,
 174                                                             binding, efx_tc_block_unbind,
 175                                                             tcb, net_dev, sch, data, binding,
 176                                                             cleanup);
 177                         rc = PTR_ERR_OR_ZERO(block_cb);
 178                         netif_dbg(efx, drv, efx->net_dev,
 179                                   "bind indr block for device %s, rc %d\n",
 180                                   net_dev ? net_dev->name : NULL, rc);
 181                         if (rc) {
 182                                 list_del(&binding->list);
 183                                 kfree(binding);
 184                         } else {
 185                                 flow_block_cb_add(block_cb, tcb);
 186                         }
 187                         return rc;
 188                 case FLOW_BLOCK_UNBIND:
 189                         binding = efx_tc_find_binding(efx, net_dev);
 190                         if (!binding)
 191                                 return -ENOENT;
 192                         block_cb = flow_block_cb_lookup(tcb->block,
 193                                                         efx_tc_block_cb,
 194                                                         binding);
 195                         if (!block_cb)
 196                                 return -ENOENT;
 197                         flow_indr_block_cb_remove(block_cb, tcb);
 198                         netif_dbg(efx, drv, efx->net_dev,
 199                                   "unbind indr block for device %s\n",
 200                                   net_dev ? net_dev->name : NULL);
 201                         return 0;
 202                 default:
 203                         return -EOPNOTSUPP;
 204                 }
 205         default:
 206                 return -EOPNOTSUPP;
 207         }
 208 }
 209
 210 /* .ndo_setup_tc implementation
 211  * Entry point for flower block and filter management.
 212  */
 213 int efx_tc_setup(struct net_device *net_dev, enum tc_setup_type type,
 214                  void *type_data)
 215 {
 216         struct efx_nic *efx = efx_netdev_priv(net_dev);
 217
 218         if (efx->type->is_vf)
 219                 return -EOPNOTSUPP;
 220         if (!efx->tc)
 221                 return -EOPNOTSUPP;
 222
 223         if (type == TC_SETUP_CLSFLOWER)
 224                 return efx_tc_flower(efx, net_dev, type_data, NULL);
 225         if (type == TC_SETUP_BLOCK)
 226                 return efx_tc_setup_block(net_dev, efx, type_data, NULL);
 227
 228         return -EOPNOTSUPP;
 229 }
 230
 231 int efx_tc_netdev_event(struct efx_nic *efx, unsigned long event,
 232                         struct net_device *net_dev)
 233 {
 234         if (efx->type->is_vf)
 235                 return NOTIFY_DONE;
 236
 237         if (event == NETDEV_UNREGISTER)
 238                 efx_tc_unregister_egdev(efx, net_dev);
 239
 240         return NOTIFY_OK;
 241 }