drivers/net/sfc/sfc_mae.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 Xilinx, Inc.
   4  * Copyright(c) 2019 Solarflare Communications Inc.
   5  *
   6  * This software was jointly developed between OKTET Labs (under contract
   7  * for Solarflare) and Solarflare Communications, Inc.
   8  */
   9
  10 #include <stdbool.h>
  11
  12 #include <rte_common.h>
  13
  14 #include "efx.h"
  15
  16 #include "sfc.h"
  17 #include "sfc_log.h"
  18
  19 int
  20 sfc_mae_attach(struct sfc_adapter *sa)
  21 {
  22         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
  23         struct sfc_mae *mae = &sa->mae;
  24         efx_mae_limits_t limits;
  25         int rc;
  26
  27         sfc_log_init(sa, "entry");
  28
  29         if (!encp->enc_mae_supported) {
  30                 mae->status = SFC_MAE_STATUS_UNSUPPORTED;
  31                 return 0;
  32         }
  33
  34         sfc_log_init(sa, "init MAE");
  35         rc = efx_mae_init(sa->nic);
  36         if (rc != 0)
  37                 goto fail_mae_init;
  38
  39         sfc_log_init(sa, "get MAE limits");
  40         rc = efx_mae_get_limits(sa->nic, &limits);
  41         if (rc != 0)
  42                 goto fail_mae_get_limits;
  43
  44         mae->status = SFC_MAE_STATUS_SUPPORTED;
  45         mae->nb_action_rule_prios_max = limits.eml_max_n_action_prios;
  46         TAILQ_INIT(&mae->action_sets);
  47
  48         sfc_log_init(sa, "done");
  49
  50         return 0;
  51
  52 fail_mae_get_limits:
  53         efx_mae_fini(sa->nic);
  54
  55 fail_mae_init:
  56         sfc_log_init(sa, "failed %d", rc);
  57
  58         return rc;
  59 }
  60
  61 void
  62 sfc_mae_detach(struct sfc_adapter *sa)
  63 {
  64         struct sfc_mae *mae = &sa->mae;
  65         enum sfc_mae_status status_prev = mae->status;
  66
  67         sfc_log_init(sa, "entry");
  68
  69         mae->nb_action_rule_prios_max = 0;
  70         mae->status = SFC_MAE_STATUS_UNKNOWN;
  71
  72         if (status_prev != SFC_MAE_STATUS_SUPPORTED)
  73                 return;
  74
  75         efx_mae_fini(sa->nic);
  76
  77         sfc_log_init(sa, "done");
  78 }
  79
  80 static struct sfc_mae_action_set *
  81 sfc_mae_action_set_attach(struct sfc_adapter *sa,
  82                           const efx_mae_actions_t *spec)
  83 {
  84         struct sfc_mae_action_set *action_set;
  85         struct sfc_mae *mae = &sa->mae;
  86
  87         SFC_ASSERT(sfc_adapter_is_locked(sa));
  88
  89         TAILQ_FOREACH(action_set, &mae->action_sets, entries) {
  90                 if (efx_mae_action_set_specs_equal(action_set->spec, spec)) {
  91                         ++(action_set->refcnt);
  92                         return action_set;
  93                 }
  94         }
  95
  96         return NULL;
  97 }
  98
  99 static int
 100 sfc_mae_action_set_add(struct sfc_adapter *sa,
 101                        efx_mae_actions_t *spec,
 102                        struct sfc_mae_action_set **action_setp)
 103 {
 104         struct sfc_mae_action_set *action_set;
 105         struct sfc_mae *mae = &sa->mae;
 106
 107         SFC_ASSERT(sfc_adapter_is_locked(sa));
 108
 109         action_set = rte_zmalloc("sfc_mae_action_set", sizeof(*action_set), 0);
 110         if (action_set == NULL)
 111                 return ENOMEM;
 112
 113         action_set->refcnt = 1;
 114         action_set->spec = spec;
 115
 116         action_set->fw_rsrc.aset_id.id = EFX_MAE_RSRC_ID_INVALID;
 117
 118         TAILQ_INSERT_TAIL(&mae->action_sets, action_set, entries);
 119
 120         *action_setp = action_set;
 121
 122         return 0;
 123 }
 124
 125 static void
 126 sfc_mae_action_set_del(struct sfc_adapter *sa,
 127                        struct sfc_mae_action_set *action_set)
 128 {
 129         struct sfc_mae *mae = &sa->mae;
 130
 131         SFC_ASSERT(sfc_adapter_is_locked(sa));
 132         SFC_ASSERT(action_set->refcnt != 0);
 133
 134         --(action_set->refcnt);
 135
 136         if (action_set->refcnt != 0)
 137                 return;
 138
 139         SFC_ASSERT(action_set->fw_rsrc.aset_id.id == EFX_MAE_RSRC_ID_INVALID);
 140         SFC_ASSERT(action_set->fw_rsrc.refcnt == 0);
 141
 142         efx_mae_action_set_spec_fini(sa->nic, action_set->spec);
 143         TAILQ_REMOVE(&mae->action_sets, action_set, entries);
 144         rte_free(action_set);
 145 }
 146
 147 static int
 148 sfc_mae_action_set_enable(struct sfc_adapter *sa,
 149                           struct sfc_mae_action_set *action_set)
 150 {
 151         struct sfc_mae_fw_rsrc *fw_rsrc = &action_set->fw_rsrc;
 152         int rc;
 153
 154         SFC_ASSERT(sfc_adapter_is_locked(sa));
 155
 156         if (fw_rsrc->refcnt == 0) {
 157                 SFC_ASSERT(fw_rsrc->aset_id.id == EFX_MAE_RSRC_ID_INVALID);
 158                 SFC_ASSERT(action_set->spec != NULL);
 159
 160                 rc = efx_mae_action_set_alloc(sa->nic, action_set->spec,
 161                                               &fw_rsrc->aset_id);
 162                 if (rc != 0)
 163                         return rc;
 164         }
 165
 166         ++(fw_rsrc->refcnt);
 167
 168         return 0;
 169 }
 170
 171 static int
 172 sfc_mae_action_set_disable(struct sfc_adapter *sa,
 173                            struct sfc_mae_action_set *action_set)
 174 {
 175         struct sfc_mae_fw_rsrc *fw_rsrc = &action_set->fw_rsrc;
 176         int rc;
 177
 178         SFC_ASSERT(sfc_adapter_is_locked(sa));
 179         SFC_ASSERT(fw_rsrc->aset_id.id != EFX_MAE_RSRC_ID_INVALID);
 180         SFC_ASSERT(fw_rsrc->refcnt != 0);
 181
 182         if (fw_rsrc->refcnt == 1) {
 183                 rc = efx_mae_action_set_free(sa->nic, &fw_rsrc->aset_id);
 184                 if (rc != 0)
 185                         return rc;
 186
 187                 fw_rsrc->aset_id.id = EFX_MAE_RSRC_ID_INVALID;
 188         }
 189
 190         --(fw_rsrc->refcnt);
 191
 192         return 0;
 193 }
 194
 195 void
 196 sfc_mae_flow_cleanup(struct sfc_adapter *sa,
 197                      struct rte_flow *flow)
 198 {
 199         struct sfc_flow_spec *spec;
 200         struct sfc_flow_spec_mae *spec_mae;
 201
 202         if (flow == NULL)
 203                 return;
 204
 205         spec = &flow->spec;
 206
 207         if (spec == NULL)
 208                 return;
 209
 210         spec_mae = &spec->mae;
 211
 212         SFC_ASSERT(spec_mae->rule_id.id == EFX_MAE_RSRC_ID_INVALID);
 213
 214         if (spec_mae->action_set != NULL)
 215                 sfc_mae_action_set_del(sa, spec_mae->action_set);
 216
 217         if (spec_mae->match_spec != NULL)
 218                 efx_mae_match_spec_fini(sa->nic, spec_mae->match_spec);
 219 }
 220
 221 static int
 222 sfc_mae_rule_parse_item_phy_port(const struct rte_flow_item *item,
 223                                  struct sfc_flow_parse_ctx *ctx,
 224                                  struct rte_flow_error *error)
 225 {
 226         struct sfc_mae_parse_ctx *ctx_mae = ctx->mae;
 227         const struct rte_flow_item_phy_port supp_mask = {
 228                 .index = 0xffffffff,
 229         };
 230         const void *def_mask = &rte_flow_item_phy_port_mask;
 231         const struct rte_flow_item_phy_port *spec = NULL;
 232         const struct rte_flow_item_phy_port *mask = NULL;
 233         efx_mport_sel_t mport_v;
 234         int rc;
 235
 236         if (ctx_mae->match_mport_set) {
 237                 return rte_flow_error_set(error, ENOTSUP,
 238                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 239                                 "Can't handle multiple traffic source items");
 240         }
 241
 242         rc = sfc_flow_parse_init(item,
 243                                  (const void **)&spec, (const void **)&mask,
 244                                  (const void *)&supp_mask, def_mask,
 245                                  sizeof(struct rte_flow_item_phy_port), error);
 246         if (rc != 0)
 247                 return rc;
 248
 249         if (mask->index != supp_mask.index) {
 250                 return rte_flow_error_set(error, EINVAL,
 251                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 252                                 "Bad mask in the PHY_PORT pattern item");
 253         }
 254
 255         /* If "spec" is not set, could be any physical port */
 256         if (spec == NULL)
 257                 return 0;
 258
 259         rc = efx_mae_mport_by_phy_port(spec->index, &mport_v);
 260         if (rc != 0) {
 261                 return rte_flow_error_set(error, rc,
 262                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 263                                 "Failed to convert the PHY_PORT index");
 264         }
 265
 266         rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec_action,
 267                                           &mport_v, NULL);
 268         if (rc != 0) {
 269                 return rte_flow_error_set(error, rc,
 270                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 271                                 "Failed to set MPORT for the PHY_PORT");
 272         }
 273
 274         ctx_mae->match_mport_set = B_TRUE;
 275
 276         return 0;
 277 }
 278
 279 struct sfc_mae_field_locator {
 280         efx_mae_field_id_t              field_id;
 281         size_t                          size;
 282         /* Field offset in the corresponding rte_flow_item_ struct */
 283         size_t                          ofst;
 284 };
 285
 286 static void
 287 sfc_mae_item_build_supp_mask(const struct sfc_mae_field_locator *field_locators,
 288                              unsigned int nb_field_locators, void *mask_ptr,
 289                              size_t mask_size)
 290 {
 291         unsigned int i;
 292
 293         memset(mask_ptr, 0, mask_size);
 294
 295         for (i = 0; i < nb_field_locators; ++i) {
 296                 const struct sfc_mae_field_locator *fl = &field_locators[i];
 297
 298                 SFC_ASSERT(fl->ofst + fl->size <= mask_size);
 299                 memset(RTE_PTR_ADD(mask_ptr, fl->ofst), 0xff, fl->size);
 300         }
 301 }
 302
 303 static int
 304 sfc_mae_parse_item(const struct sfc_mae_field_locator *field_locators,
 305                    unsigned int nb_field_locators, const uint8_t *spec,
 306                    const uint8_t *mask, efx_mae_match_spec_t *efx_spec,
 307                    struct rte_flow_error *error)
 308 {
 309         unsigned int i;
 310         int rc = 0;
 311
 312         for (i = 0; i < nb_field_locators; ++i) {
 313                 const struct sfc_mae_field_locator *fl = &field_locators[i];
 314
 315                 rc = efx_mae_match_spec_field_set(efx_spec, fl->field_id,
 316                                                   fl->size, spec + fl->ofst,
 317                                                   fl->size, mask + fl->ofst);
 318                 if (rc != 0)
 319                         break;
 320         }
 321
 322         if (rc != 0) {
 323                 rc = rte_flow_error_set(error, rc, RTE_FLOW_ERROR_TYPE_ITEM,
 324                                 NULL, "Failed to process item fields");
 325         }
 326
 327         return rc;
 328 }
 329
 330 static const struct sfc_mae_field_locator flocs_eth[] = {
 331         {
 332                 EFX_MAE_FIELD_ETHER_TYPE_BE,
 333                 RTE_SIZEOF_FIELD(struct rte_flow_item_eth, type),
 334                 offsetof(struct rte_flow_item_eth, type),
 335         },
 336         {
 337                 EFX_MAE_FIELD_ETH_DADDR_BE,
 338                 RTE_SIZEOF_FIELD(struct rte_flow_item_eth, dst),
 339                 offsetof(struct rte_flow_item_eth, dst),
 340         },
 341         {
 342                 EFX_MAE_FIELD_ETH_SADDR_BE,
 343                 RTE_SIZEOF_FIELD(struct rte_flow_item_eth, src),
 344                 offsetof(struct rte_flow_item_eth, src),
 345         },
 346 };
 347
 348 static int
 349 sfc_mae_rule_parse_item_eth(const struct rte_flow_item *item,
 350                             struct sfc_flow_parse_ctx *ctx,
 351                             struct rte_flow_error *error)
 352 {
 353         struct sfc_mae_parse_ctx *ctx_mae = ctx->mae;
 354         struct rte_flow_item_eth supp_mask;
 355         const uint8_t *spec = NULL;
 356         const uint8_t *mask = NULL;
 357         int rc;
 358
 359         sfc_mae_item_build_supp_mask(flocs_eth, RTE_DIM(flocs_eth),
 360                                      &supp_mask, sizeof(supp_mask));
 361
 362         rc = sfc_flow_parse_init(item,
 363                                  (const void **)&spec, (const void **)&mask,
 364                                  (const void *)&supp_mask,
 365                                  &rte_flow_item_eth_mask,
 366                                  sizeof(struct rte_flow_item_eth), error);
 367         if (rc != 0)
 368                 return rc;
 369
 370         /* If "spec" is not set, could be any Ethernet */
 371         if (spec == NULL)
 372                 return 0;
 373
 374         return sfc_mae_parse_item(flocs_eth, RTE_DIM(flocs_eth), spec, mask,
 375                                   ctx_mae->match_spec_action, error);
 376 }
 377
 378 static const struct sfc_flow_item sfc_flow_items[] = {
 379         {
 380                 .type = RTE_FLOW_ITEM_TYPE_PHY_PORT,
 381                 /*
 382                  * In terms of RTE flow, this item is a META one,
 383                  * and its position in the pattern is don't care.
 384                  */
 385                 .prev_layer = SFC_FLOW_ITEM_ANY_LAYER,
 386                 .layer = SFC_FLOW_ITEM_ANY_LAYER,
 387                 .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
 388                 .parse = sfc_mae_rule_parse_item_phy_port,
 389         },
 390         {
 391                 .type = RTE_FLOW_ITEM_TYPE_ETH,
 392                 .prev_layer = SFC_FLOW_ITEM_START_LAYER,
 393                 .layer = SFC_FLOW_ITEM_L2,
 394                 .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
 395                 .parse = sfc_mae_rule_parse_item_eth,
 396         },
 397 };
 398
 399 int
 400 sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
 401                            const struct rte_flow_item pattern[],
 402                            struct sfc_flow_spec_mae *spec,
 403                            struct rte_flow_error *error)
 404 {
 405         struct sfc_mae_parse_ctx ctx_mae;
 406         struct sfc_flow_parse_ctx ctx;
 407         int rc;
 408
 409         memset(&ctx_mae, 0, sizeof(ctx_mae));
 410
 411         rc = efx_mae_match_spec_init(sa->nic, EFX_MAE_RULE_ACTION,
 412                                      spec->priority,
 413                                      &ctx_mae.match_spec_action);
 414         if (rc != 0) {
 415                 rc = rte_flow_error_set(error, rc,
 416                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
 417                         "Failed to initialise action rule match specification");
 418                 goto fail_init_match_spec_action;
 419         }
 420
 421         ctx.type = SFC_FLOW_PARSE_CTX_MAE;
 422         ctx.mae = &ctx_mae;
 423
 424         rc = sfc_flow_parse_pattern(sfc_flow_items, RTE_DIM(sfc_flow_items),
 425                                     pattern, &ctx, error);
 426         if (rc != 0)
 427                 goto fail_parse_pattern;
 428
 429         if (!efx_mae_match_spec_is_valid(sa->nic, ctx_mae.match_spec_action)) {
 430                 rc = rte_flow_error_set(error, ENOTSUP,
 431                                         RTE_FLOW_ERROR_TYPE_ITEM, NULL,
 432                                         "Inconsistent pattern");
 433                 goto fail_validate_match_spec_action;
 434         }
 435
 436         spec->match_spec = ctx_mae.match_spec_action;
 437
 438         return 0;
 439
 440 fail_validate_match_spec_action:
 441 fail_parse_pattern:
 442         efx_mae_match_spec_fini(sa->nic, ctx_mae.match_spec_action);
 443
 444 fail_init_match_spec_action:
 445         return rc;
 446 }
 447
 448 static int
 449 sfc_mae_rule_parse_action_phy_port(struct sfc_adapter *sa,
 450                                    const struct rte_flow_action_phy_port *conf,
 451                                    efx_mae_actions_t *spec)
 452 {
 453         efx_mport_sel_t mport;
 454         uint32_t phy_port;
 455         int rc;
 456
 457         if (conf->original != 0)
 458                 phy_port = efx_nic_cfg_get(sa->nic)->enc_assigned_port;
 459         else
 460                 phy_port = conf->index;
 461
 462         rc = efx_mae_mport_by_phy_port(phy_port, &mport);
 463         if (rc != 0)
 464                 return rc;
 465
 466         return efx_mae_action_set_populate_deliver(spec, &mport);
 467 }
 468
 469 static int
 470 sfc_mae_rule_parse_action(struct sfc_adapter *sa,
 471                           const struct rte_flow_action *action,
 472                           efx_mae_actions_t *spec,
 473                           struct rte_flow_error *error)
 474 {
 475         int rc;
 476
 477         switch (action->type) {
 478         case RTE_FLOW_ACTION_TYPE_OF_POP_VLAN:
 479                 rc = efx_mae_action_set_populate_vlan_pop(spec);
 480                 break;
 481         case RTE_FLOW_ACTION_TYPE_PHY_PORT:
 482                 rc = sfc_mae_rule_parse_action_phy_port(sa, action->conf, spec);
 483                 break;
 484         default:
 485                 return rte_flow_error_set(error, ENOTSUP,
 486                                 RTE_FLOW_ERROR_TYPE_ACTION, NULL,
 487                                 "Unsupported action");
 488         }
 489
 490         if (rc != 0) {
 491                 rc = rte_flow_error_set(error, rc, RTE_FLOW_ERROR_TYPE_ACTION,
 492                                 NULL, "Failed to request the action");
 493         }
 494
 495         return rc;
 496 }
 497
 498 int
 499 sfc_mae_rule_parse_actions(struct sfc_adapter *sa,
 500                            const struct rte_flow_action actions[],
 501                            struct sfc_mae_action_set **action_setp,
 502                            struct rte_flow_error *error)
 503 {
 504         const struct rte_flow_action *action;
 505         efx_mae_actions_t *spec;
 506         int rc;
 507
 508         if (actions == NULL) {
 509                 return rte_flow_error_set(error, EINVAL,
 510                                 RTE_FLOW_ERROR_TYPE_ACTION_NUM, NULL,
 511                                 "NULL actions");
 512         }
 513
 514         rc = efx_mae_action_set_spec_init(sa->nic, &spec);
 515         if (rc != 0)
 516                 goto fail_action_set_spec_init;
 517
 518         for (action = actions;
 519              action->type != RTE_FLOW_ACTION_TYPE_END; ++action) {
 520                 rc = sfc_mae_rule_parse_action(sa, action, spec, error);
 521                 if (rc != 0)
 522                         goto fail_rule_parse_action;
 523         }
 524
 525         *action_setp = sfc_mae_action_set_attach(sa, spec);
 526         if (*action_setp != NULL) {
 527                 efx_mae_action_set_spec_fini(sa->nic, spec);
 528                 return 0;
 529         }
 530
 531         rc = sfc_mae_action_set_add(sa, spec, action_setp);
 532         if (rc != 0)
 533                 goto fail_action_set_add;
 534
 535         return 0;
 536
 537 fail_action_set_add:
 538 fail_rule_parse_action:
 539         efx_mae_action_set_spec_fini(sa->nic, spec);
 540
 541 fail_action_set_spec_init:
 542         if (rc > 0) {
 543                 rc = rte_flow_error_set(error, rc,
 544                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 545                         NULL, "Failed to process the action");
 546         }
 547         return rc;
 548 }
 549
 550 static bool
 551 sfc_mae_rules_class_cmp(struct sfc_adapter *sa,
 552                         const efx_mae_match_spec_t *left,
 553                         const efx_mae_match_spec_t *right)
 554 {
 555         bool have_same_class;
 556         int rc;
 557
 558         rc = efx_mae_match_specs_class_cmp(sa->nic, left, right,
 559                                            &have_same_class);
 560
 561         return (rc == 0) ? have_same_class : false;
 562 }
 563
 564 static int
 565 sfc_mae_action_rule_class_verify(struct sfc_adapter *sa,
 566                                  struct sfc_flow_spec_mae *spec)
 567 {
 568         const struct rte_flow *entry;
 569
 570         TAILQ_FOREACH_REVERSE(entry, &sa->flow_list, sfc_flow_list, entries) {
 571                 const struct sfc_flow_spec *entry_spec = &entry->spec;
 572                 const struct sfc_flow_spec_mae *es_mae = &entry_spec->mae;
 573                 const efx_mae_match_spec_t *left = es_mae->match_spec;
 574                 const efx_mae_match_spec_t *right = spec->match_spec;
 575
 576                 switch (entry_spec->type) {
 577                 case SFC_FLOW_SPEC_FILTER:
 578                         /* Ignore VNIC-level flows */
 579                         break;
 580                 case SFC_FLOW_SPEC_MAE:
 581                         if (sfc_mae_rules_class_cmp(sa, left, right))
 582                                 return 0;
 583                         break;
 584                 default:
 585                         SFC_ASSERT(false);
 586                 }
 587         }
 588
 589         sfc_info(sa, "for now, the HW doesn't support rule validation, and HW "
 590                  "support for inner frame pattern items is not guaranteed; "
 591                  "other than that, the items are valid from SW standpoint");
 592         return 0;
 593 }
 594
 595 /**
 596  * Confirm that a given flow can be accepted by the FW.
 597  *
 598  * @param sa
 599  *   Software adapter context
 600  * @param flow
 601  *   Flow to be verified
 602  * @return
 603  *   Zero on success and non-zero in the case of error.
 604  *   A special value of EAGAIN indicates that the adapter is
 605  *   not in started state. This state is compulsory because
 606  *   it only makes sense to compare the rule class of the flow
 607  *   being validated with classes of the active rules.
 608  *   Such classes are wittingly supported by the FW.
 609  */
 610 int
 611 sfc_mae_flow_verify(struct sfc_adapter *sa,
 612                     struct rte_flow *flow)
 613 {
 614         struct sfc_flow_spec *spec = &flow->spec;
 615         struct sfc_flow_spec_mae *spec_mae = &spec->mae;
 616
 617         SFC_ASSERT(sfc_adapter_is_locked(sa));
 618
 619         if (sa->state != SFC_ADAPTER_STARTED)
 620                 return EAGAIN;
 621
 622         return sfc_mae_action_rule_class_verify(sa, spec_mae);
 623 }
 624
 625 int
 626 sfc_mae_flow_insert(struct sfc_adapter *sa,
 627                     struct rte_flow *flow)
 628 {
 629         struct sfc_flow_spec *spec = &flow->spec;
 630         struct sfc_flow_spec_mae *spec_mae = &spec->mae;
 631         struct sfc_mae_action_set *action_set = spec_mae->action_set;
 632         struct sfc_mae_fw_rsrc *fw_rsrc = &action_set->fw_rsrc;
 633         int rc;
 634
 635         SFC_ASSERT(spec_mae->rule_id.id == EFX_MAE_RSRC_ID_INVALID);
 636         SFC_ASSERT(action_set != NULL);
 637
 638         rc = sfc_mae_action_set_enable(sa, action_set);
 639         if (rc != 0)
 640                 goto fail_action_set_enable;
 641
 642         rc = efx_mae_action_rule_insert(sa->nic, spec_mae->match_spec,
 643                                         NULL, &fw_rsrc->aset_id,
 644                                         &spec_mae->rule_id);
 645         if (rc != 0)
 646                 goto fail_action_rule_insert;
 647
 648         return 0;
 649
 650 fail_action_rule_insert:
 651         (void)sfc_mae_action_set_disable(sa, action_set);
 652
 653 fail_action_set_enable:
 654         return rc;
 655 }
 656
 657 int
 658 sfc_mae_flow_remove(struct sfc_adapter *sa,
 659                     struct rte_flow *flow)
 660 {
 661         struct sfc_flow_spec *spec = &flow->spec;
 662         struct sfc_flow_spec_mae *spec_mae = &spec->mae;
 663         struct sfc_mae_action_set *action_set = spec_mae->action_set;
 664         int rc;
 665
 666         SFC_ASSERT(spec_mae->rule_id.id != EFX_MAE_RSRC_ID_INVALID);
 667         SFC_ASSERT(action_set != NULL);
 668
 669         rc = efx_mae_action_rule_remove(sa->nic, &spec_mae->rule_id);
 670         if (rc != 0)
 671                 return rc;
 672
 673         spec_mae->rule_id.id = EFX_MAE_RSRC_ID_INVALID;
 674
 675         return sfc_mae_action_set_disable(sa, action_set);
 676 }