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