1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2/* Copyright (c) 2020-2021 Marvell International Ltd. All rights reserved */ 3 4#include <linux/rhashtable.h> 5 6#include "prestera_acl.h" 7#include "prestera_flow.h" 8#include "prestera_hw.h" 9#include "prestera.h" 10 11#define ACL_KEYMASK_SIZE \ 12 (sizeof(__be32) * __PRESTERA_ACL_RULE_MATCH_TYPE_MAX) 13 14struct prestera_acl { 15 struct prestera_switch *sw; 16 struct list_head vtcam_list; 17 struct list_head rules; 18 struct rhashtable ruleset_ht; 19 struct rhashtable acl_rule_entry_ht; 20 struct idr uid; 21}; 22 23struct prestera_acl_ruleset_ht_key { 24 struct prestera_flow_block *block; 25 u32 chain_index; 26}; 27 28struct prestera_acl_rule_entry { 29 struct rhash_head ht_node; 30 struct prestera_acl_rule_entry_key key; 31 u32 hw_id; 32 u32 vtcam_id; 33 struct { 34 struct { 35 u8 valid:1; 36 } accept, drop, trap; 37 struct { 38 u8 valid:1; 39 struct prestera_acl_action_police i; 40 } police; 41 struct { 42 struct prestera_acl_action_jump i; 43 u8 valid:1; 44 } jump; 45 struct { 46 u32 id; 47 struct prestera_counter_block *block; 48 } counter; 49 }; 50}; 51 52struct prestera_acl_ruleset { 53 struct rhash_head ht_node; /* Member of acl HT */ 54 struct prestera_acl_ruleset_ht_key ht_key; 55 struct rhashtable rule_ht; 56 struct prestera_acl *acl; 57 struct { 58 u32 min; 59 u32 max; 60 } prio; 61 unsigned long rule_count; 62 refcount_t refcount; 63 void *keymask; 64 u32 vtcam_id; 65 u32 index; 66 u16 pcl_id; 67 bool offload; 68 bool ingress; 69}; 70 71struct prestera_acl_vtcam { 72 struct list_head list; 73 __be32 keymask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX]; 74 refcount_t refcount; 75 u32 id; 76 bool is_keymask_set; 77 u8 lookup; 78 u8 direction; 79}; 80 81static const struct rhashtable_params prestera_acl_ruleset_ht_params = { 82 .key_len = sizeof(struct prestera_acl_ruleset_ht_key), 83 .key_offset = offsetof(struct prestera_acl_ruleset, ht_key), 84 .head_offset = offsetof(struct prestera_acl_ruleset, ht_node), 85 .automatic_shrinking = true, 86}; 87 88static const struct rhashtable_params prestera_acl_rule_ht_params = { 89 .key_len = sizeof(unsigned long), 90 .key_offset = offsetof(struct prestera_acl_rule, cookie), 91 .head_offset = offsetof(struct prestera_acl_rule, ht_node), 92 .automatic_shrinking = true, 93}; 94 95static const struct rhashtable_params __prestera_acl_rule_entry_ht_params = { 96 .key_offset = offsetof(struct prestera_acl_rule_entry, key), 97 .head_offset = offsetof(struct prestera_acl_rule_entry, ht_node), 98 .key_len = sizeof(struct prestera_acl_rule_entry_key), 99 .automatic_shrinking = true, 100}; 101 102int prestera_acl_chain_to_client(u32 chain_index, bool ingress, u32 *client) 103{ 104 static const u32 ingress_client_map[] = { 105 PRESTERA_HW_COUNTER_CLIENT_INGRESS_LOOKUP_0, 106 PRESTERA_HW_COUNTER_CLIENT_INGRESS_LOOKUP_1, 107 PRESTERA_HW_COUNTER_CLIENT_INGRESS_LOOKUP_2 108 }; 109 110 if (!ingress) { 111 /* prestera supports only one chain on egress */ 112 if (chain_index > 0) 113 return -EINVAL; 114 115 *client = PRESTERA_HW_COUNTER_CLIENT_EGRESS_LOOKUP; 116 return 0; 117 } 118 119 if (chain_index >= ARRAY_SIZE(ingress_client_map)) 120 return -EINVAL; 121 122 *client = ingress_client_map[chain_index]; 123 return 0; 124} 125 126static bool prestera_acl_chain_is_supported(u32 chain_index, bool ingress) 127{ 128 if (!ingress) 129 /* prestera supports only one chain on egress */ 130 return chain_index == 0; 131 132 return (chain_index & ~PRESTERA_ACL_CHAIN_MASK) == 0; 133} 134 135static struct prestera_acl_ruleset * 136prestera_acl_ruleset_create(struct prestera_acl *acl, 137 struct prestera_flow_block *block, 138 u32 chain_index) 139{ 140 struct prestera_acl_ruleset *ruleset; 141 u32 uid = 0; 142 int err; 143 144 if (!prestera_acl_chain_is_supported(chain_index, block->ingress)) 145 return ERR_PTR(-EINVAL); 146 147 ruleset = kzalloc(sizeof(*ruleset), GFP_KERNEL); 148 if (!ruleset) 149 return ERR_PTR(-ENOMEM); 150 151 ruleset->acl = acl; 152 ruleset->ingress = block->ingress; 153 ruleset->ht_key.block = block; 154 ruleset->ht_key.chain_index = chain_index; 155 refcount_set(&ruleset->refcount, 1); 156 157 err = rhashtable_init(&ruleset->rule_ht, &prestera_acl_rule_ht_params); 158 if (err) 159 goto err_rhashtable_init; 160 161 err = idr_alloc_u32(&acl->uid, NULL, &uid, U8_MAX, GFP_KERNEL); 162 if (err) 163 goto err_ruleset_create; 164 165 /* make pcl-id based on uid */ 166 ruleset->pcl_id = PRESTERA_ACL_PCL_ID_MAKE((u8)uid, chain_index); 167 ruleset->index = uid; 168 169 ruleset->prio.min = UINT_MAX; 170 ruleset->prio.max = 0; 171 172 err = rhashtable_insert_fast(&acl->ruleset_ht, &ruleset->ht_node, 173 prestera_acl_ruleset_ht_params); 174 if (err) 175 goto err_ruleset_ht_insert; 176 177 return ruleset; 178 179err_ruleset_ht_insert: 180 idr_remove(&acl->uid, uid); 181err_ruleset_create: 182 rhashtable_destroy(&ruleset->rule_ht); 183err_rhashtable_init: 184 kfree(ruleset); 185 return ERR_PTR(err); 186} 187 188int prestera_acl_ruleset_keymask_set(struct prestera_acl_ruleset *ruleset, 189 void *keymask) 190{ 191 ruleset->keymask = kmemdup(keymask, ACL_KEYMASK_SIZE, GFP_KERNEL); 192 if (!ruleset->keymask) 193 return -ENOMEM; 194 195 return 0; 196} 197 198int prestera_acl_ruleset_offload(struct prestera_acl_ruleset *ruleset) 199{ 200 struct prestera_acl_iface iface; 201 u32 vtcam_id; 202 int dir; 203 int err; 204 205 dir = ruleset->ingress ? 206 PRESTERA_HW_VTCAM_DIR_INGRESS : PRESTERA_HW_VTCAM_DIR_EGRESS; 207 208 if (ruleset->offload) 209 return -EEXIST; 210 211 err = prestera_acl_vtcam_id_get(ruleset->acl, 212 ruleset->ht_key.chain_index, 213 dir, 214 ruleset->keymask, &vtcam_id); 215 if (err) 216 goto err_vtcam_create; 217 218 if (ruleset->ht_key.chain_index) { 219 /* for chain > 0, bind iface index to pcl-id to be able 220 * to jump from any other ruleset to this one using the index. 221 */ 222 iface.index = ruleset->index; 223 iface.type = PRESTERA_ACL_IFACE_TYPE_INDEX; 224 err = prestera_hw_vtcam_iface_bind(ruleset->acl->sw, &iface, 225 vtcam_id, ruleset->pcl_id); 226 if (err) 227 goto err_ruleset_bind; 228 } 229 230 ruleset->vtcam_id = vtcam_id; 231 ruleset->offload = true; 232 return 0; 233 234err_ruleset_bind: 235 prestera_acl_vtcam_id_put(ruleset->acl, ruleset->vtcam_id); 236err_vtcam_create: 237 return err; 238} 239 240static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset) 241{ 242 struct prestera_acl *acl = ruleset->acl; 243 u8 uid = ruleset->pcl_id & PRESTERA_ACL_KEYMASK_PCL_ID_USER; 244 int err; 245 246 rhashtable_remove_fast(&acl->ruleset_ht, &ruleset->ht_node, 247 prestera_acl_ruleset_ht_params); 248 249 if (ruleset->offload) { 250 if (ruleset->ht_key.chain_index) { 251 struct prestera_acl_iface iface = { 252 .type = PRESTERA_ACL_IFACE_TYPE_INDEX, 253 .index = ruleset->index 254 }; 255 err = prestera_hw_vtcam_iface_unbind(acl->sw, &iface, 256 ruleset->vtcam_id); 257 WARN_ON(err); 258 } 259 WARN_ON(prestera_acl_vtcam_id_put(acl, ruleset->vtcam_id)); 260 } 261 262 idr_remove(&acl->uid, uid); 263 rhashtable_destroy(&ruleset->rule_ht); 264 kfree(ruleset->keymask); 265 kfree(ruleset); 266} 267 268static struct prestera_acl_ruleset * 269__prestera_acl_ruleset_lookup(struct prestera_acl *acl, 270 struct prestera_flow_block *block, 271 u32 chain_index) 272{ 273 struct prestera_acl_ruleset_ht_key ht_key; 274 275 memset(&ht_key, 0, sizeof(ht_key)); 276 ht_key.block = block; 277 ht_key.chain_index = chain_index; 278 return rhashtable_lookup_fast(&acl->ruleset_ht, &ht_key, 279 prestera_acl_ruleset_ht_params); 280} 281 282struct prestera_acl_ruleset * 283prestera_acl_ruleset_lookup(struct prestera_acl *acl, 284 struct prestera_flow_block *block, 285 u32 chain_index) 286{ 287 struct prestera_acl_ruleset *ruleset; 288 289 ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index); 290 if (!ruleset) 291 return ERR_PTR(-ENOENT); 292 293 refcount_inc(&ruleset->refcount); 294 return ruleset; 295} 296 297struct prestera_acl_ruleset * 298prestera_acl_ruleset_get(struct prestera_acl *acl, 299 struct prestera_flow_block *block, 300 u32 chain_index) 301{ 302 struct prestera_acl_ruleset *ruleset; 303 304 ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index); 305 if (ruleset) { 306 refcount_inc(&ruleset->refcount); 307 return ruleset; 308 } 309 310 return prestera_acl_ruleset_create(acl, block, chain_index); 311} 312 313void prestera_acl_ruleset_put(struct prestera_acl_ruleset *ruleset) 314{ 315 if (!refcount_dec_and_test(&ruleset->refcount)) 316 return; 317 318 prestera_acl_ruleset_destroy(ruleset); 319} 320 321int prestera_acl_ruleset_bind(struct prestera_acl_ruleset *ruleset, 322 struct prestera_port *port) 323{ 324 struct prestera_acl_iface iface = { 325 .type = PRESTERA_ACL_IFACE_TYPE_PORT, 326 .port = port 327 }; 328 329 return prestera_hw_vtcam_iface_bind(port->sw, &iface, ruleset->vtcam_id, 330 ruleset->pcl_id); 331} 332 333int prestera_acl_ruleset_unbind(struct prestera_acl_ruleset *ruleset, 334 struct prestera_port *port) 335{ 336 struct prestera_acl_iface iface = { 337 .type = PRESTERA_ACL_IFACE_TYPE_PORT, 338 .port = port 339 }; 340 341 return prestera_hw_vtcam_iface_unbind(port->sw, &iface, 342 ruleset->vtcam_id); 343} 344 345static int prestera_acl_ruleset_block_bind(struct prestera_acl_ruleset *ruleset, 346 struct prestera_flow_block *block) 347{ 348 struct prestera_flow_block_binding *binding; 349 int err; 350 351 block->ruleset_zero = ruleset; 352 list_for_each_entry(binding, &block->binding_list, list) { 353 err = prestera_acl_ruleset_bind(ruleset, binding->port); 354 if (err) 355 goto rollback; 356 } 357 return 0; 358 359rollback: 360 list_for_each_entry_continue_reverse(binding, &block->binding_list, 361 list) 362 err = prestera_acl_ruleset_unbind(ruleset, binding->port); 363 block->ruleset_zero = NULL; 364 365 return err; 366} 367 368static void 369prestera_acl_ruleset_block_unbind(struct prestera_acl_ruleset *ruleset, 370 struct prestera_flow_block *block) 371{ 372 struct prestera_flow_block_binding *binding; 373 374 list_for_each_entry(binding, &block->binding_list, list) 375 prestera_acl_ruleset_unbind(ruleset, binding->port); 376 block->ruleset_zero = NULL; 377} 378 379static void 380prestera_acl_ruleset_prio_refresh(struct prestera_acl *acl, 381 struct prestera_acl_ruleset *ruleset) 382{ 383 struct prestera_acl_rule *rule; 384 385 ruleset->prio.min = UINT_MAX; 386 ruleset->prio.max = 0; 387 388 list_for_each_entry(rule, &acl->rules, list) { 389 if (ruleset->ingress != rule->ruleset->ingress) 390 continue; 391 if (ruleset->ht_key.chain_index != rule->chain_index) 392 continue; 393 394 ruleset->prio.min = min(ruleset->prio.min, rule->priority); 395 ruleset->prio.max = max(ruleset->prio.max, rule->priority); 396 } 397} 398 399void 400prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule, u16 pcl_id) 401{ 402 struct prestera_acl_match *r_match = &rule->re_key.match; 403 __be16 pcl_id_mask = htons(PRESTERA_ACL_KEYMASK_PCL_ID); 404 __be16 pcl_id_key = htons(pcl_id); 405 406 rule_match_set(r_match->key, PCL_ID, pcl_id_key); 407 rule_match_set(r_match->mask, PCL_ID, pcl_id_mask); 408} 409 410struct prestera_acl_rule * 411prestera_acl_rule_lookup(struct prestera_acl_ruleset *ruleset, 412 unsigned long cookie) 413{ 414 return rhashtable_lookup_fast(&ruleset->rule_ht, &cookie, 415 prestera_acl_rule_ht_params); 416} 417 418u32 prestera_acl_ruleset_index_get(const struct prestera_acl_ruleset *ruleset) 419{ 420 return ruleset->index; 421} 422 423void prestera_acl_ruleset_prio_get(struct prestera_acl_ruleset *ruleset, 424 u32 *prio_min, u32 *prio_max) 425{ 426 *prio_min = ruleset->prio.min; 427 *prio_max = ruleset->prio.max; 428} 429 430bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset) 431{ 432 return ruleset->offload; 433} 434 435struct prestera_acl_rule * 436prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset, 437 unsigned long cookie, u32 chain_index) 438{ 439 struct prestera_acl_rule *rule; 440 441 rule = kzalloc(sizeof(*rule), GFP_KERNEL); 442 if (!rule) 443 return ERR_PTR(-ENOMEM); 444 445 rule->ruleset = ruleset; 446 rule->cookie = cookie; 447 rule->chain_index = chain_index; 448 449 refcount_inc(&ruleset->refcount); 450 451 return rule; 452} 453 454void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule, 455 u32 priority) 456{ 457 rule->priority = priority; 458} 459 460void prestera_acl_rule_destroy(struct prestera_acl_rule *rule) 461{ 462 if (rule->jump_ruleset) 463 /* release ruleset kept by jump action */ 464 prestera_acl_ruleset_put(rule->jump_ruleset); 465 466 prestera_acl_ruleset_put(rule->ruleset); 467 kfree(rule); 468} 469 470static void prestera_acl_ruleset_prio_update(struct prestera_acl_ruleset *ruleset, 471 u32 prio) 472{ 473 ruleset->prio.min = min(ruleset->prio.min, prio); 474 ruleset->prio.max = max(ruleset->prio.max, prio); 475} 476 477int prestera_acl_rule_add(struct prestera_switch *sw, 478 struct prestera_acl_rule *rule) 479{ 480 int err; 481 struct prestera_acl_ruleset *ruleset = rule->ruleset; 482 struct prestera_flow_block *block = ruleset->ht_key.block; 483 484 /* try to add rule to hash table first */ 485 err = rhashtable_insert_fast(&ruleset->rule_ht, &rule->ht_node, 486 prestera_acl_rule_ht_params); 487 if (err) 488 goto err_ht_insert; 489 490 prestera_acl_rule_keymask_pcl_id_set(rule, ruleset->pcl_id); 491 rule->re_arg.vtcam_id = ruleset->vtcam_id; 492 rule->re_key.prio = rule->priority; 493 494 rule->re = prestera_acl_rule_entry_find(sw->acl, &rule->re_key); 495 err = WARN_ON(rule->re) ? -EEXIST : 0; 496 if (err) 497 goto err_rule_add; 498 499 rule->re = prestera_acl_rule_entry_create(sw->acl, &rule->re_key, 500 &rule->re_arg); 501 err = !rule->re ? -EINVAL : 0; 502 if (err) 503 goto err_rule_add; 504 505 /* bind the block (all ports) to chain index 0, rest of 506 * the chains are bound to goto action 507 */ 508 if (!ruleset->ht_key.chain_index && !ruleset->rule_count) { 509 err = prestera_acl_ruleset_block_bind(ruleset, block); 510 if (err) 511 goto err_acl_block_bind; 512 } 513 514 list_add_tail(&rule->list, &sw->acl->rules); 515 ruleset->rule_count++; 516 prestera_acl_ruleset_prio_update(ruleset, rule->priority); 517 return 0; 518 519err_acl_block_bind: 520 prestera_acl_rule_entry_destroy(sw->acl, rule->re); 521err_rule_add: 522 rule->re = NULL; 523 rhashtable_remove_fast(&ruleset->rule_ht, &rule->ht_node, 524 prestera_acl_rule_ht_params); 525err_ht_insert: 526 return err; 527} 528 529void prestera_acl_rule_del(struct prestera_switch *sw, 530 struct prestera_acl_rule *rule) 531{ 532 struct prestera_acl_ruleset *ruleset = rule->ruleset; 533 struct prestera_flow_block *block = ruleset->ht_key.block; 534 535 rhashtable_remove_fast(&ruleset->rule_ht, &rule->ht_node, 536 prestera_acl_rule_ht_params); 537 ruleset->rule_count--; 538 list_del(&rule->list); 539 540 prestera_acl_rule_entry_destroy(sw->acl, rule->re); 541 prestera_acl_ruleset_prio_refresh(sw->acl, ruleset); 542 543 /* unbind block (all ports) */ 544 if (!ruleset->ht_key.chain_index && !ruleset->rule_count) 545 prestera_acl_ruleset_block_unbind(ruleset, block); 546} 547 548int prestera_acl_rule_get_stats(struct prestera_acl *acl, 549 struct prestera_acl_rule *rule, 550 u64 *packets, u64 *bytes, u64 *last_use) 551{ 552 u64 current_packets; 553 u64 current_bytes; 554 int err; 555 556 err = prestera_counter_stats_get(acl->sw->counter, 557 rule->re->counter.block, 558 rule->re->counter.id, 559 ¤t_packets, ¤t_bytes); 560 if (err) 561 return err; 562 563 *packets = current_packets; 564 *bytes = current_bytes; 565 *last_use = jiffies; 566 567 return 0; 568} 569 570struct prestera_acl_rule_entry * 571prestera_acl_rule_entry_find(struct prestera_acl *acl, 572 struct prestera_acl_rule_entry_key *key) 573{ 574 return rhashtable_lookup_fast(&acl->acl_rule_entry_ht, key, 575 __prestera_acl_rule_entry_ht_params); 576} 577 578static int __prestera_acl_rule_entry2hw_del(struct prestera_switch *sw, 579 struct prestera_acl_rule_entry *e) 580{ 581 return prestera_hw_vtcam_rule_del(sw, e->vtcam_id, e->hw_id); 582} 583 584static int __prestera_acl_rule_entry2hw_add(struct prestera_switch *sw, 585 struct prestera_acl_rule_entry *e) 586{ 587 struct prestera_acl_hw_action_info act_hw[PRESTERA_ACL_RULE_ACTION_MAX]; 588 int act_num; 589 590 memset(&act_hw, 0, sizeof(act_hw)); 591 act_num = 0; 592 593 /* accept */ 594 if (e->accept.valid) { 595 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_ACCEPT; 596 act_num++; 597 } 598 /* drop */ 599 if (e->drop.valid) { 600 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_DROP; 601 act_num++; 602 } 603 /* trap */ 604 if (e->trap.valid) { 605 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_TRAP; 606 act_num++; 607 } 608 /* police */ 609 if (e->police.valid) { 610 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_POLICE; 611 act_hw[act_num].police = e->police.i; 612 act_num++; 613 } 614 /* jump */ 615 if (e->jump.valid) { 616 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_JUMP; 617 act_hw[act_num].jump = e->jump.i; 618 act_num++; 619 } 620 /* counter */ 621 if (e->counter.block) { 622 act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_COUNT; 623 act_hw[act_num].count.id = e->counter.id; 624 act_num++; 625 } 626 627 return prestera_hw_vtcam_rule_add(sw, e->vtcam_id, e->key.prio, 628 e->key.match.key, e->key.match.mask, 629 act_hw, act_num, &e->hw_id); 630} 631 632static void 633__prestera_acl_rule_entry_act_destruct(struct prestera_switch *sw, 634 struct prestera_acl_rule_entry *e) 635{ 636 /* counter */ 637 prestera_counter_put(sw->counter, e->counter.block, e->counter.id); 638 /* police */ 639 if (e->police.valid) 640 prestera_hw_policer_release(sw, e->police.i.id); 641} 642 643void prestera_acl_rule_entry_destroy(struct prestera_acl *acl, 644 struct prestera_acl_rule_entry *e) 645{ 646 int ret; 647 648 rhashtable_remove_fast(&acl->acl_rule_entry_ht, &e->ht_node, 649 __prestera_acl_rule_entry_ht_params); 650 651 ret = __prestera_acl_rule_entry2hw_del(acl->sw, e); 652 WARN_ON(ret && ret != -ENODEV); 653 654 __prestera_acl_rule_entry_act_destruct(acl->sw, e); 655 kfree(e); 656} 657 658static int 659__prestera_acl_rule_entry_act_construct(struct prestera_switch *sw, 660 struct prestera_acl_rule_entry *e, 661 struct prestera_acl_rule_entry_arg *arg) 662{ 663 int err; 664 665 /* accept */ 666 e->accept.valid = arg->accept.valid; 667 /* drop */ 668 e->drop.valid = arg->drop.valid; 669 /* trap */ 670 e->trap.valid = arg->trap.valid; 671 /* jump */ 672 e->jump.valid = arg->jump.valid; 673 e->jump.i = arg->jump.i; 674 /* police */ 675 if (arg->police.valid) { 676 u8 type = arg->police.ingress ? PRESTERA_POLICER_TYPE_INGRESS : 677 PRESTERA_POLICER_TYPE_EGRESS; 678 679 err = prestera_hw_policer_create(sw, type, &e->police.i.id); 680 if (err) 681 goto err_out; 682 683 err = prestera_hw_policer_sr_tcm_set(sw, e->police.i.id, 684 arg->police.rate, 685 arg->police.burst); 686 if (err) { 687 prestera_hw_policer_release(sw, e->police.i.id); 688 goto err_out; 689 } 690 e->police.valid = arg->police.valid; 691 } 692 /* counter */ 693 if (arg->count.valid) { 694 err = prestera_counter_get(sw->counter, arg->count.client, 695 &e->counter.block, 696 &e->counter.id); 697 if (err) 698 goto err_out; 699 } 700 701 return 0; 702 703err_out: 704 __prestera_acl_rule_entry_act_destruct(sw, e); 705 return -EINVAL; 706} 707 708struct prestera_acl_rule_entry * 709prestera_acl_rule_entry_create(struct prestera_acl *acl, 710 struct prestera_acl_rule_entry_key *key, 711 struct prestera_acl_rule_entry_arg *arg) 712{ 713 struct prestera_acl_rule_entry *e; 714 int err; 715 716 e = kzalloc(sizeof(*e), GFP_KERNEL); 717 if (!e) 718 goto err_kzalloc; 719 720 memcpy(&e->key, key, sizeof(*key)); 721 e->vtcam_id = arg->vtcam_id; 722 err = __prestera_acl_rule_entry_act_construct(acl->sw, e, arg); 723 if (err) 724 goto err_act_construct; 725 726 err = __prestera_acl_rule_entry2hw_add(acl->sw, e); 727 if (err) 728 goto err_hw_add; 729 730 err = rhashtable_insert_fast(&acl->acl_rule_entry_ht, &e->ht_node, 731 __prestera_acl_rule_entry_ht_params); 732 if (err) 733 goto err_ht_insert; 734 735 return e; 736 737err_ht_insert: 738 WARN_ON(__prestera_acl_rule_entry2hw_del(acl->sw, e)); 739err_hw_add: 740 __prestera_acl_rule_entry_act_destruct(acl->sw, e); 741err_act_construct: 742 kfree(e); 743err_kzalloc: 744 return NULL; 745} 746 747static int __prestera_acl_vtcam_id_try_fit(struct prestera_acl *acl, u8 lookup, 748 void *keymask, u32 *vtcam_id) 749{ 750 struct prestera_acl_vtcam *vtcam; 751 int i; 752 753 list_for_each_entry(vtcam, &acl->vtcam_list, list) { 754 if (lookup != vtcam->lookup) 755 continue; 756 757 if (!keymask && !vtcam->is_keymask_set) 758 goto vtcam_found; 759 760 if (!(keymask && vtcam->is_keymask_set)) 761 continue; 762 763 /* try to fit with vtcam keymask */ 764 for (i = 0; i < __PRESTERA_ACL_RULE_MATCH_TYPE_MAX; i++) { 765 __be32 __keymask = ((__be32 *)keymask)[i]; 766 767 if (!__keymask) 768 /* vtcam keymask in not interested */ 769 continue; 770 771 if (__keymask & ~vtcam->keymask[i]) 772 /* keymask does not fit the vtcam keymask */ 773 break; 774 } 775 776 if (i == __PRESTERA_ACL_RULE_MATCH_TYPE_MAX) 777 /* keymask fits vtcam keymask, return it */ 778 goto vtcam_found; 779 } 780 781 /* nothing is found */ 782 return -ENOENT; 783 784vtcam_found: 785 refcount_inc(&vtcam->refcount); 786 *vtcam_id = vtcam->id; 787 return 0; 788} 789 790int prestera_acl_vtcam_id_get(struct prestera_acl *acl, u8 lookup, u8 dir, 791 void *keymask, u32 *vtcam_id) 792{ 793 struct prestera_acl_vtcam *vtcam; 794 u32 new_vtcam_id; 795 int err; 796 797 /* find the vtcam that suits keymask. We do not expect to have 798 * a big number of vtcams, so, the list type for vtcam list is 799 * fine for now 800 */ 801 list_for_each_entry(vtcam, &acl->vtcam_list, list) { 802 if (lookup != vtcam->lookup || 803 dir != vtcam->direction) 804 continue; 805 806 if (!keymask && !vtcam->is_keymask_set) { 807 refcount_inc(&vtcam->refcount); 808 goto vtcam_found; 809 } 810 811 if (keymask && vtcam->is_keymask_set && 812 !memcmp(keymask, vtcam->keymask, sizeof(vtcam->keymask))) { 813 refcount_inc(&vtcam->refcount); 814 goto vtcam_found; 815 } 816 } 817 818 /* vtcam not found, try to create new one */ 819 vtcam = kzalloc(sizeof(*vtcam), GFP_KERNEL); 820 if (!vtcam) 821 return -ENOMEM; 822 823 err = prestera_hw_vtcam_create(acl->sw, lookup, keymask, &new_vtcam_id, 824 dir); 825 if (err) { 826 kfree(vtcam); 827 828 /* cannot create new, try to fit into existing vtcam */ 829 if (__prestera_acl_vtcam_id_try_fit(acl, lookup, 830 keymask, &new_vtcam_id)) 831 return err; 832 833 *vtcam_id = new_vtcam_id; 834 return 0; 835 } 836 837 vtcam->direction = dir; 838 vtcam->id = new_vtcam_id; 839 vtcam->lookup = lookup; 840 if (keymask) { 841 memcpy(vtcam->keymask, keymask, sizeof(vtcam->keymask)); 842 vtcam->is_keymask_set = true; 843 } 844 refcount_set(&vtcam->refcount, 1); 845 list_add_rcu(&vtcam->list, &acl->vtcam_list); 846 847vtcam_found: 848 *vtcam_id = vtcam->id; 849 return 0; 850} 851 852int prestera_acl_vtcam_id_put(struct prestera_acl *acl, u32 vtcam_id) 853{ 854 struct prestera_acl_vtcam *vtcam; 855 int err; 856 857 list_for_each_entry(vtcam, &acl->vtcam_list, list) { 858 if (vtcam_id != vtcam->id) 859 continue; 860 861 if (!refcount_dec_and_test(&vtcam->refcount)) 862 return 0; 863 864 err = prestera_hw_vtcam_destroy(acl->sw, vtcam->id); 865 if (err && err != -ENODEV) { 866 refcount_set(&vtcam->refcount, 1); 867 return err; 868 } 869 870 list_del(&vtcam->list); 871 kfree(vtcam); 872 return 0; 873 } 874 875 return -ENOENT; 876} 877 878int prestera_acl_init(struct prestera_switch *sw) 879{ 880 struct prestera_acl *acl; 881 int err; 882 883 acl = kzalloc(sizeof(*acl), GFP_KERNEL); 884 if (!acl) 885 return -ENOMEM; 886 887 acl->sw = sw; 888 INIT_LIST_HEAD(&acl->rules); 889 INIT_LIST_HEAD(&acl->vtcam_list); 890 idr_init(&acl->uid); 891 892 err = rhashtable_init(&acl->acl_rule_entry_ht, 893 &__prestera_acl_rule_entry_ht_params); 894 if (err) 895 goto err_acl_rule_entry_ht_init; 896 897 err = rhashtable_init(&acl->ruleset_ht, 898 &prestera_acl_ruleset_ht_params); 899 if (err) 900 goto err_ruleset_ht_init; 901 902 sw->acl = acl; 903 904 return 0; 905 906err_ruleset_ht_init: 907 rhashtable_destroy(&acl->acl_rule_entry_ht); 908err_acl_rule_entry_ht_init: 909 kfree(acl); 910 return err; 911} 912 913void prestera_acl_fini(struct prestera_switch *sw) 914{ 915 struct prestera_acl *acl = sw->acl; 916 917 WARN_ON(!idr_is_empty(&acl->uid)); 918 idr_destroy(&acl->uid); 919 920 WARN_ON(!list_empty(&acl->vtcam_list)); 921 WARN_ON(!list_empty(&acl->rules)); 922 923 rhashtable_destroy(&acl->ruleset_ht); 924 rhashtable_destroy(&acl->acl_rule_entry_ht); 925 926 kfree(acl); 927} 928