drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_matchall.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (C) 2019 Chelsio Communications.  All rights reserved. */
   3
   4 #include "cxgb4.h"
   5 #include "cxgb4_tc_matchall.h"
   6 #include "sched.h"
   7 #include "cxgb4_uld.h"
   8 #include "cxgb4_filter.h"
   9 #include "cxgb4_tc_flower.h"
  10
  11 static int cxgb4_policer_validate(const struct flow_action *action,
  12                                   const struct flow_action_entry *act,
  13                                   struct netlink_ext_ack *extack)
  14 {
  15         if (act->police.exceed.act_id != FLOW_ACTION_DROP) {
  16                 NL_SET_ERR_MSG_MOD(extack,
  17                                    "Offload not supported when exceed action is not drop");
  18                 return -EOPNOTSUPP;
  19         }
  20
  21         if (act->police.notexceed.act_id != FLOW_ACTION_PIPE &&
  22             act->police.notexceed.act_id != FLOW_ACTION_ACCEPT) {
  23                 NL_SET_ERR_MSG_MOD(extack,
  24                                    "Offload not supported when conform action is not pipe or ok");
  25                 return -EOPNOTSUPP;
  26         }
  27
  28         if (act->police.notexceed.act_id == FLOW_ACTION_ACCEPT &&
  29             !flow_action_is_last_entry(action, act)) {
  30                 NL_SET_ERR_MSG_MOD(extack,
  31                                    "Offload not supported when conform action is ok, but action is not last");
  32                 return -EOPNOTSUPP;
  33         }
  34
  35         if (act->police.peakrate_bytes_ps ||
  36             act->police.avrate || act->police.overhead) {
  37                 NL_SET_ERR_MSG_MOD(extack,
  38                                    "Offload not supported when peakrate/avrate/overhead is configured");
  39                 return -EOPNOTSUPP;
  40         }
  41
  42         if (act->police.rate_pkt_ps) {
  43                 NL_SET_ERR_MSG_MOD(extack,
  44                                    "QoS offload not support packets per second");
  45                 return -EOPNOTSUPP;
  46         }
  47
  48         return 0;
  49 }
  50
  51 static int cxgb4_matchall_egress_validate(struct net_device *dev,
  52                                           struct tc_cls_matchall_offload *cls)
  53 {
  54         struct netlink_ext_ack *extack = cls->common.extack;
  55         struct flow_action *actions = &cls->rule->action;
  56         struct port_info *pi = netdev2pinfo(dev);
  57         struct flow_action_entry *entry;
  58         struct ch_sched_queue qe;
  59         struct sched_class *e;
  60         u64 max_link_rate;
  61         u32 i, speed;
  62         int ret;
  63
  64         if (!flow_action_has_entries(actions)) {
  65                 NL_SET_ERR_MSG_MOD(extack,
  66                                    "Egress MATCHALL offload needs at least 1 policing action");
  67                 return -EINVAL;
  68         } else if (!flow_offload_has_one_action(actions)) {
  69                 NL_SET_ERR_MSG_MOD(extack,
  70                                    "Egress MATCHALL offload only supports 1 policing action");
  71                 return -EINVAL;
  72         } else if (pi->tc_block_shared) {
  73                 NL_SET_ERR_MSG_MOD(extack,
  74                                    "Egress MATCHALL offload not supported with shared blocks");
  75                 return -EINVAL;
  76         }
  77
  78         ret = t4_get_link_params(pi, NULL, &speed, NULL);
  79         if (ret) {
  80                 NL_SET_ERR_MSG_MOD(extack,
  81                                    "Failed to get max speed supported by the link");
  82                 return -EINVAL;
  83         }
  84
  85         /* Convert from Mbps to bps */
  86         max_link_rate = (u64)speed * 1000 * 1000;
  87
  88         flow_action_for_each(i, entry, actions) {
  89                 switch (entry->id) {
  90                 case FLOW_ACTION_POLICE:
  91                         ret = cxgb4_policer_validate(actions, entry, extack);
  92                         if (ret)
  93                                 return ret;
  94
  95                         /* Convert bytes per second to bits per second */
  96                         if (entry->police.rate_bytes_ps * 8 > max_link_rate) {
  97                                 NL_SET_ERR_MSG_MOD(extack,
  98                                                    "Specified policing max rate is larger than underlying link speed");
  99                                 return -ERANGE;
 100                         }
 101                         break;
 102                 default:
 103                         NL_SET_ERR_MSG_MOD(extack,
 104                                            "Only policing action supported with Egress MATCHALL offload");
 105                         return -EOPNOTSUPP;
 106                 }
 107         }
 108
 109         for (i = 0; i < pi->nqsets; i++) {
 110                 memset(&qe, 0, sizeof(qe));
 111                 qe.queue = i;
 112
 113                 e = cxgb4_sched_queue_lookup(dev, &qe);
 114                 if (e && e->info.u.params.level != SCHED_CLASS_LEVEL_CH_RL) {
 115                         NL_SET_ERR_MSG_MOD(extack,
 116                                            "Some queues are already bound to different class");
 117                         return -EBUSY;
 118                 }
 119         }
 120
 121         return 0;
 122 }
 123
 124 static int cxgb4_matchall_tc_bind_queues(struct net_device *dev, u32 tc)
 125 {
 126         struct port_info *pi = netdev2pinfo(dev);
 127         struct ch_sched_queue qe;
 128         int ret;
 129         u32 i;
 130
 131         for (i = 0; i < pi->nqsets; i++) {
 132                 qe.queue = i;
 133                 qe.class = tc;
 134                 ret = cxgb4_sched_class_bind(dev, &qe, SCHED_QUEUE);
 135                 if (ret)
 136                         goto out_free;
 137         }
 138
 139         return 0;
 140
 141 out_free:
 142         while (i--) {
 143                 qe.queue = i;
 144                 qe.class = SCHED_CLS_NONE;
 145                 cxgb4_sched_class_unbind(dev, &qe, SCHED_QUEUE);
 146         }
 147
 148         return ret;
 149 }
 150
 151 static void cxgb4_matchall_tc_unbind_queues(struct net_device *dev)
 152 {
 153         struct port_info *pi = netdev2pinfo(dev);
 154         struct ch_sched_queue qe;
 155         u32 i;
 156
 157         for (i = 0; i < pi->nqsets; i++) {
 158                 qe.queue = i;
 159                 qe.class = SCHED_CLS_NONE;
 160                 cxgb4_sched_class_unbind(dev, &qe, SCHED_QUEUE);
 161         }
 162 }
 163
 164 static int cxgb4_matchall_alloc_tc(struct net_device *dev,
 165                                    struct tc_cls_matchall_offload *cls)
 166 {
 167         struct ch_sched_params p = {
 168                 .type = SCHED_CLASS_TYPE_PACKET,
 169                 .u.params.level = SCHED_CLASS_LEVEL_CH_RL,
 170                 .u.params.mode = SCHED_CLASS_MODE_CLASS,
 171                 .u.params.rateunit = SCHED_CLASS_RATEUNIT_BITS,
 172                 .u.params.ratemode = SCHED_CLASS_RATEMODE_ABS,
 173                 .u.params.class = SCHED_CLS_NONE,
 174                 .u.params.minrate = 0,
 175                 .u.params.weight = 0,
 176                 .u.params.pktsize = dev->mtu,
 177         };
 178         struct netlink_ext_ack *extack = cls->common.extack;
 179         struct cxgb4_tc_port_matchall *tc_port_matchall;
 180         struct port_info *pi = netdev2pinfo(dev);
 181         struct adapter *adap = netdev2adap(dev);
 182         struct flow_action_entry *entry;
 183         struct sched_class *e;
 184         int ret;
 185         u32 i;
 186
 187         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 188
 189         flow_action_for_each(i, entry, &cls->rule->action)
 190                 if (entry->id == FLOW_ACTION_POLICE)
 191                         break;
 192
 193         ret = cxgb4_policer_validate(&cls->rule->action, entry, extack);
 194         if (ret)
 195                 return ret;
 196
 197         /* Convert from bytes per second to Kbps */
 198         p.u.params.maxrate = div_u64(entry->police.rate_bytes_ps * 8, 1000);
 199         p.u.params.channel = pi->tx_chan;
 200         e = cxgb4_sched_class_alloc(dev, &p);
 201         if (!e) {
 202                 NL_SET_ERR_MSG_MOD(extack,
 203                                    "No free traffic class available for policing action");
 204                 return -ENOMEM;
 205         }
 206
 207         ret = cxgb4_matchall_tc_bind_queues(dev, e->idx);
 208         if (ret) {
 209                 NL_SET_ERR_MSG_MOD(extack,
 210                                    "Could not bind queues to traffic class");
 211                 goto out_free;
 212         }
 213
 214         tc_port_matchall->egress.hwtc = e->idx;
 215         tc_port_matchall->egress.cookie = cls->cookie;
 216         tc_port_matchall->egress.state = CXGB4_MATCHALL_STATE_ENABLED;
 217         return 0;
 218
 219 out_free:
 220         cxgb4_sched_class_free(dev, e->idx);
 221         return ret;
 222 }
 223
 224 static void cxgb4_matchall_free_tc(struct net_device *dev)
 225 {
 226         struct cxgb4_tc_port_matchall *tc_port_matchall;
 227         struct port_info *pi = netdev2pinfo(dev);
 228         struct adapter *adap = netdev2adap(dev);
 229
 230         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 231         cxgb4_matchall_tc_unbind_queues(dev);
 232         cxgb4_sched_class_free(dev, tc_port_matchall->egress.hwtc);
 233
 234         tc_port_matchall->egress.hwtc = SCHED_CLS_NONE;
 235         tc_port_matchall->egress.cookie = 0;
 236         tc_port_matchall->egress.state = CXGB4_MATCHALL_STATE_DISABLED;
 237 }
 238
 239 static int cxgb4_matchall_mirror_alloc(struct net_device *dev,
 240                                        struct tc_cls_matchall_offload *cls)
 241 {
 242         struct netlink_ext_ack *extack = cls->common.extack;
 243         struct cxgb4_tc_port_matchall *tc_port_matchall;
 244         struct port_info *pi = netdev2pinfo(dev);
 245         struct adapter *adap = netdev2adap(dev);
 246         struct flow_action_entry *act;
 247         int ret;
 248         u32 i;
 249
 250         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 251         flow_action_for_each(i, act, &cls->rule->action) {
 252                 if (act->id == FLOW_ACTION_MIRRED) {
 253                         ret = cxgb4_port_mirror_alloc(dev);
 254                         if (ret) {
 255                                 NL_SET_ERR_MSG_MOD(extack,
 256                                                    "Couldn't allocate mirror");
 257                                 return ret;
 258                         }
 259
 260                         tc_port_matchall->ingress.viid_mirror = pi->viid_mirror;
 261                         break;
 262                 }
 263         }
 264
 265         return 0;
 266 }
 267
 268 static void cxgb4_matchall_mirror_free(struct net_device *dev)
 269 {
 270         struct cxgb4_tc_port_matchall *tc_port_matchall;
 271         struct port_info *pi = netdev2pinfo(dev);
 272         struct adapter *adap = netdev2adap(dev);
 273
 274         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 275         if (!tc_port_matchall->ingress.viid_mirror)
 276                 return;
 277
 278         cxgb4_port_mirror_free(dev);
 279         tc_port_matchall->ingress.viid_mirror = 0;
 280 }
 281
 282 static int cxgb4_matchall_del_filter(struct net_device *dev, u8 filter_type)
 283 {
 284         struct cxgb4_tc_port_matchall *tc_port_matchall;
 285         struct port_info *pi = netdev2pinfo(dev);
 286         struct adapter *adap = netdev2adap(dev);
 287         int ret;
 288
 289         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 290         ret = cxgb4_del_filter(dev, tc_port_matchall->ingress.tid[filter_type],
 291                                &tc_port_matchall->ingress.fs[filter_type]);
 292         if (ret)
 293                 return ret;
 294
 295         tc_port_matchall->ingress.tid[filter_type] = 0;
 296         return 0;
 297 }
 298
 299 static int cxgb4_matchall_add_filter(struct net_device *dev,
 300                                      struct tc_cls_matchall_offload *cls,
 301                                      u8 filter_type)
 302 {
 303         struct netlink_ext_ack *extack = cls->common.extack;
 304         struct cxgb4_tc_port_matchall *tc_port_matchall;
 305         struct port_info *pi = netdev2pinfo(dev);
 306         struct adapter *adap = netdev2adap(dev);
 307         struct ch_filter_specification *fs;
 308         int ret, fidx;
 309
 310         /* Get a free filter entry TID, where we can insert this new
 311          * rule. Only insert rule if its prio doesn't conflict with
 312          * existing rules.
 313          */
 314         fidx = cxgb4_get_free_ftid(dev, filter_type ? PF_INET6 : PF_INET,
 315                                    false, cls->common.prio);
 316         if (fidx < 0) {
 317                 NL_SET_ERR_MSG_MOD(extack,
 318                                    "No free LETCAM index available");
 319                 return -ENOMEM;
 320         }
 321
 322         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 323         fs = &tc_port_matchall->ingress.fs[filter_type];
 324         memset(fs, 0, sizeof(*fs));
 325
 326         if (fidx < adap->tids.nhpftids)
 327                 fs->prio = 1;
 328         fs->tc_prio = cls->common.prio;
 329         fs->tc_cookie = cls->cookie;
 330         fs->type = filter_type;
 331         fs->hitcnts = 1;
 332
 333         fs->val.pfvf_vld = 1;
 334         fs->val.pf = adap->pf;
 335         fs->val.vf = pi->vin;
 336
 337         cxgb4_process_flow_actions(dev, &cls->rule->action, fs);
 338
 339         ret = cxgb4_set_filter(dev, fidx, fs);
 340         if (ret)
 341                 return ret;
 342
 343         tc_port_matchall->ingress.tid[filter_type] = fidx;
 344         return 0;
 345 }
 346
 347 static int cxgb4_matchall_alloc_filter(struct net_device *dev,
 348                                        struct tc_cls_matchall_offload *cls)
 349 {
 350         struct cxgb4_tc_port_matchall *tc_port_matchall;
 351         struct port_info *pi = netdev2pinfo(dev);
 352         struct adapter *adap = netdev2adap(dev);
 353         int ret, i;
 354
 355         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 356
 357         ret = cxgb4_matchall_mirror_alloc(dev, cls);
 358         if (ret)
 359                 return ret;
 360
 361         for (i = 0; i < CXGB4_FILTER_TYPE_MAX; i++) {
 362                 ret = cxgb4_matchall_add_filter(dev, cls, i);
 363                 if (ret)
 364                         goto out_free;
 365         }
 366
 367         tc_port_matchall->ingress.state = CXGB4_MATCHALL_STATE_ENABLED;
 368         return 0;
 369
 370 out_free:
 371         while (i-- > 0)
 372                 cxgb4_matchall_del_filter(dev, i);
 373
 374         cxgb4_matchall_mirror_free(dev);
 375         return ret;
 376 }
 377
 378 static int cxgb4_matchall_free_filter(struct net_device *dev)
 379 {
 380         struct cxgb4_tc_port_matchall *tc_port_matchall;
 381         struct port_info *pi = netdev2pinfo(dev);
 382         struct adapter *adap = netdev2adap(dev);
 383         int ret;
 384         u8 i;
 385
 386         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 387
 388         for (i = 0; i < CXGB4_FILTER_TYPE_MAX; i++) {
 389                 ret = cxgb4_matchall_del_filter(dev, i);
 390                 if (ret)
 391                         return ret;
 392         }
 393
 394         cxgb4_matchall_mirror_free(dev);
 395
 396         tc_port_matchall->ingress.packets = 0;
 397         tc_port_matchall->ingress.bytes = 0;
 398         tc_port_matchall->ingress.last_used = 0;
 399         tc_port_matchall->ingress.state = CXGB4_MATCHALL_STATE_DISABLED;
 400         return 0;
 401 }
 402
 403 int cxgb4_tc_matchall_replace(struct net_device *dev,
 404                               struct tc_cls_matchall_offload *cls_matchall,
 405                               bool ingress)
 406 {
 407         struct netlink_ext_ack *extack = cls_matchall->common.extack;
 408         struct cxgb4_tc_port_matchall *tc_port_matchall;
 409         struct port_info *pi = netdev2pinfo(dev);
 410         struct adapter *adap = netdev2adap(dev);
 411         int ret;
 412
 413         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 414         if (ingress) {
 415                 if (tc_port_matchall->ingress.state ==
 416                     CXGB4_MATCHALL_STATE_ENABLED) {
 417                         NL_SET_ERR_MSG_MOD(extack,
 418                                            "Only 1 Ingress MATCHALL can be offloaded");
 419                         return -ENOMEM;
 420                 }
 421
 422                 ret = cxgb4_validate_flow_actions(dev,
 423                                                   &cls_matchall->rule->action,
 424                                                   extack, 1);
 425                 if (ret)
 426                         return ret;
 427
 428                 return cxgb4_matchall_alloc_filter(dev, cls_matchall);
 429         }
 430
 431         if (tc_port_matchall->egress.state == CXGB4_MATCHALL_STATE_ENABLED) {
 432                 NL_SET_ERR_MSG_MOD(extack,
 433                                    "Only 1 Egress MATCHALL can be offloaded");
 434                 return -ENOMEM;
 435         }
 436
 437         ret = cxgb4_matchall_egress_validate(dev, cls_matchall);
 438         if (ret)
 439                 return ret;
 440
 441         return cxgb4_matchall_alloc_tc(dev, cls_matchall);
 442 }
 443
 444 int cxgb4_tc_matchall_destroy(struct net_device *dev,
 445                               struct tc_cls_matchall_offload *cls_matchall,
 446                               bool ingress)
 447 {
 448         struct cxgb4_tc_port_matchall *tc_port_matchall;
 449         struct port_info *pi = netdev2pinfo(dev);
 450         struct adapter *adap = netdev2adap(dev);
 451
 452         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 453         if (ingress) {
 454                 /* All the filter types of this matchall rule save the
 455                  * same cookie. So, checking for the first one is
 456                  * enough.
 457                  */
 458                 if (cls_matchall->cookie !=
 459                     tc_port_matchall->ingress.fs[0].tc_cookie)
 460                         return -ENOENT;
 461
 462                 return cxgb4_matchall_free_filter(dev);
 463         }
 464
 465         if (cls_matchall->cookie != tc_port_matchall->egress.cookie)
 466                 return -ENOENT;
 467
 468         cxgb4_matchall_free_tc(dev);
 469         return 0;
 470 }
 471
 472 int cxgb4_tc_matchall_stats(struct net_device *dev,
 473                             struct tc_cls_matchall_offload *cls_matchall)
 474 {
 475         u64 tmp_packets, tmp_bytes, packets = 0, bytes = 0;
 476         struct cxgb4_tc_port_matchall *tc_port_matchall;
 477         struct cxgb4_matchall_ingress_entry *ingress;
 478         struct port_info *pi = netdev2pinfo(dev);
 479         struct adapter *adap = netdev2adap(dev);
 480         int ret;
 481         u8 i;
 482
 483         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 484         if (tc_port_matchall->ingress.state == CXGB4_MATCHALL_STATE_DISABLED)
 485                 return -ENOENT;
 486
 487         ingress = &tc_port_matchall->ingress;
 488         for (i = 0; i < CXGB4_FILTER_TYPE_MAX; i++) {
 489                 ret = cxgb4_get_filter_counters(dev, ingress->tid[i],
 490                                                 &tmp_packets, &tmp_bytes,
 491                                                 ingress->fs[i].hash);
 492                 if (ret)
 493                         return ret;
 494
 495                 packets += tmp_packets;
 496                 bytes += tmp_bytes;
 497         }
 498
 499         if (tc_port_matchall->ingress.packets != packets) {
 500                 flow_stats_update(&cls_matchall->stats,
 501                                   bytes - tc_port_matchall->ingress.bytes,
 502                                   packets - tc_port_matchall->ingress.packets,
 503                                   0, tc_port_matchall->ingress.last_used,
 504                                   FLOW_ACTION_HW_STATS_IMMEDIATE);
 505
 506                 tc_port_matchall->ingress.packets = packets;
 507                 tc_port_matchall->ingress.bytes = bytes;
 508                 tc_port_matchall->ingress.last_used = jiffies;
 509         }
 510
 511         return 0;
 512 }
 513
 514 static void cxgb4_matchall_disable_offload(struct net_device *dev)
 515 {
 516         struct cxgb4_tc_port_matchall *tc_port_matchall;
 517         struct port_info *pi = netdev2pinfo(dev);
 518         struct adapter *adap = netdev2adap(dev);
 519
 520         tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
 521         if (tc_port_matchall->egress.state == CXGB4_MATCHALL_STATE_ENABLED)
 522                 cxgb4_matchall_free_tc(dev);
 523
 524         if (tc_port_matchall->ingress.state == CXGB4_MATCHALL_STATE_ENABLED)
 525                 cxgb4_matchall_free_filter(dev);
 526 }
 527
 528 int cxgb4_init_tc_matchall(struct adapter *adap)
 529 {
 530         struct cxgb4_tc_port_matchall *tc_port_matchall;
 531         struct cxgb4_tc_matchall *tc_matchall;
 532         int ret;
 533
 534         tc_matchall = kzalloc(sizeof(*tc_matchall), GFP_KERNEL);
 535         if (!tc_matchall)
 536                 return -ENOMEM;
 537
 538         tc_port_matchall = kcalloc(adap->params.nports,
 539                                    sizeof(*tc_port_matchall),
 540                                    GFP_KERNEL);
 541         if (!tc_port_matchall) {
 542                 ret = -ENOMEM;
 543                 goto out_free_matchall;
 544         }
 545
 546         tc_matchall->port_matchall = tc_port_matchall;
 547         adap->tc_matchall = tc_matchall;
 548         return 0;
 549
 550 out_free_matchall:
 551         kfree(tc_matchall);
 552         return ret;
 553 }
 554
 555 void cxgb4_cleanup_tc_matchall(struct adapter *adap)
 556 {
 557         u8 i;
 558
 559         if (adap->tc_matchall) {
 560                 if (adap->tc_matchall->port_matchall) {
 561                         for (i = 0; i < adap->params.nports; i++) {
 562                                 struct net_device *dev = adap->port[i];
 563
 564                                 if (dev)
 565                                         cxgb4_matchall_disable_offload(dev);
 566                         }
 567                         kfree(adap->tc_matchall->port_matchall);
 568                 }
 569                 kfree(adap->tc_matchall);
 570         }
 571 }