Skip to content

Commit af78f1c

Browse files
mint570KAVITHA RAMALINGAM
mint570
authored and
KAVITHA RAMALINGAM
committed
[P4Orch] Enable ACL Action SET_ACL_META_DATA and packet action COPY_CANCEL and DENY support
Signed-off-by: KAVITHA RAMALINGAM <karamalingam@google.com>
1 parent 5054495 commit af78f1c

5 files changed

Lines changed: 267 additions & 4 deletions

File tree

‎orchagent/p4orch/acl_rule_manager.cpp‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1399,7 +1399,9 @@ ReturnCode AclRuleManager::setActionValue(const acl_entry_attr_union_t attr_name
13991399
case SAI_ACL_ENTRY_ATTR_ACTION_SET_DSCP:
14001400
case SAI_ACL_ENTRY_ATTR_ACTION_SET_ECN:
14011401
case SAI_ACL_ENTRY_ATTR_ACTION_SET_INNER_VLAN_PRI:
1402-
case SAI_ACL_ENTRY_ATTR_ACTION_SET_OUTER_VLAN_PRI: {
1402+
case SAI_ACL_ENTRY_ATTR_ACTION_SET_OUTER_VLAN_PRI:
1403+
case SAI_ACL_ENTRY_ATTR_ACTION_SET_ACL_META_DATA: {
1404+
14031405
try
14041406
{
14051407
value->aclaction.parameter.u8 = to_uint<uint8_t>(attr_value);
@@ -1516,7 +1518,7 @@ ReturnCode AclRuleManager::createAclRule(P4AclRule &acl_rule)
15161518
{
15171519
SWSS_LOG_ENTER();
15181520

1519-
// Track if the entry creats a new counter or meter
1521+
// Track if the entry creates a new counter or meter
15201522
bool created_meter = false;
15211523
bool created_counter = false;
15221524
const auto &table_name_and_rule_key = concatTableNameAndRuleKey(acl_rule.acl_table_name, acl_rule.acl_rule_key);

‎orchagent/p4orch/acl_util.h‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -355,13 +355,17 @@ using P4AclRuleTables = std::map<std::string, std::map<std::string, P4AclRule>>;
355355
#define P4_ACTION_SET_L4_DST_PORT "SAI_ACL_ENTRY_ATTR_ACTION_SET_L4_DST_PORT"
356356
#define P4_ACTION_SET_DO_NOT_LEARN "SAI_ACL_ENTRY_ATTR_ACTION_SET_DO_NOT_LEARN"
357357
#define P4_ACTION_SET_VRF "SAI_ACL_ENTRY_ATTR_ACTION_SET_VRF"
358+
#define P4_ACTION_SET_ACL_META_DATA "SAI_ACL_ENTRY_ATTR_ACTION_SET_ACL_META_DATA"
358359
#define P4_ACTION_SET_QOS_QUEUE "QOS_QUEUE"
359360

360361
#define P4_PACKET_ACTION_FORWARD "SAI_PACKET_ACTION_FORWARD"
361362
#define P4_PACKET_ACTION_DROP "SAI_PACKET_ACTION_DROP"
362363
#define P4_PACKET_ACTION_COPY "SAI_PACKET_ACTION_COPY"
363364
#define P4_PACKET_ACTION_PUNT "SAI_PACKET_ACTION_TRAP"
364365
#define P4_PACKET_ACTION_LOG "SAI_PACKET_ACTION_LOG"
366+
#define P4_PACKET_ACTION_COPY_CANCEL "SAI_PACKET_ACTION_COPY_CANCEL"
367+
#define P4_PACKET_ACTION_DENY "SAI_PACKET_ACTION_DENY"
368+
365369

366370
#define P4_PACKET_ACTION_REDIRECT "REDIRECT"
367371

@@ -428,7 +432,12 @@ using P4AclRuleTables = std::map<std::string, std::map<std::string, P4AclRule>>;
428432
#define GENL_PACKET_TRAP_GROUP_NAME_PREFIX "trap.group.cpu.queue."
429433

430434
#define EMPTY_STRING ""
431-
#define P4_CPU_QUEUE_MAX_NUM 8
435+
436+
// TODO : To avoid existing p4 tests failure, extend the queue
437+
// temporarily, should set to 7-14 later.
438+
#define P4_CPU_QUEUE_MIN_NUM 1 // 7
439+
#define P4_CPU_QUEUE_MAX_NUM 15 // 14
440+
432441
#define IPV6_SINGLE_WORD_BYTES_LENGTH 4
433442
#define BYTE_BITWIDTH 8
434443

@@ -614,6 +623,8 @@ static const acl_packet_action_lookup_t aclPacketActionLookup = {
614623
{P4_PACKET_ACTION_FORWARD, SAI_PACKET_ACTION_FORWARD}, {P4_PACKET_ACTION_DROP, SAI_PACKET_ACTION_DROP},
615624
{P4_PACKET_ACTION_COPY, SAI_PACKET_ACTION_COPY}, {P4_PACKET_ACTION_PUNT, SAI_PACKET_ACTION_TRAP},
616625
{P4_PACKET_ACTION_LOG, SAI_PACKET_ACTION_LOG},
626+
{P4_PACKET_ACTION_COPY_CANCEL, SAI_PACKET_ACTION_COPY_CANCEL},
627+
{P4_PACKET_ACTION_DENY, SAI_PACKET_ACTION_DENY},
617628
};
618629

619630
static const acl_rule_attr_lookup_t aclActionLookup = {
@@ -643,6 +654,7 @@ static const acl_rule_attr_lookup_t aclActionLookup = {
643654
{P4_ACTION_SET_QOS_QUEUE, SAI_ACL_ENTRY_ATTR_ACTION_SET_USER_TRAP_ID},
644655
{P4_ACTION_SET_DO_NOT_LEARN, SAI_ACL_ENTRY_ATTR_ACTION_SET_DO_NOT_LEARN},
645656
{P4_ACTION_SET_VRF, SAI_ACL_ENTRY_ATTR_ACTION_SET_VRF},
657+
{P4_ACTION_SET_ACL_META_DATA, SAI_ACL_ENTRY_ATTR_ACTION_SET_ACL_META_DATA},
646658
};
647659

648660
static const acl_packet_color_policer_attr_lookup_t aclPacketColorPolicerAttrLookup = {

‎orchagent/p4orch/tests/acl_manager_test.cpp‎

Lines changed: 145 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
#include "table.h"
2424
#include "tokenize.h"
2525
#include "vrforch.h"
26+
#include "logger.h"
2627

2728
using ::p4orch::kTableKeyDelimiter;
2829

@@ -716,9 +717,34 @@ P4AclTableDefinitionAppDbEntry getDefaultAclTableDefAppDbEntry()
716717
app_db_entry.action_field_lookup["do_not_learn"].push_back(
717718
{.sai_action = P4_ACTION_SET_DO_NOT_LEARN, .p4_param_name = EMPTY_STRING});
718719
app_db_entry.action_field_lookup["set_vrf"].push_back({.sai_action = P4_ACTION_SET_VRF, .p4_param_name = "vrf"});
720+
app_db_entry.action_field_lookup["set_metadata"].push_back(
721+
{.sai_action = P4_ACTION_SET_ACL_META_DATA,
722+
.p4_param_name = "acl_metadata"});
719723
app_db_entry.action_field_lookup["qos_queue"].push_back(
720724
{.sai_action = P4_ACTION_SET_QOS_QUEUE, .p4_param_name = "cpu_queue"});
721725

726+
727+
// action/acl_rate_limit_copy = [
728+
// {"action":"SAI_PACKET_ACTION_FORWARD","packet_color":"SAI_PACKET_COLOR_GREEN"},
729+
// {"action":"SAI_PACKET_ACTION_COPY_CANCEL","packet_color":"SAI_PACKET_COLOR_YELLOW"},
730+
// {"action":"SAI_PACKET_ACTION_COPY_CANCEL","packet_color":"SAI_PACKET_COLOR_RED"},
731+
// {"action":"QOS_QUEUE","param":"qos_queue"}
732+
// ]
733+
734+
app_db_entry.packet_action_color_lookup["acl_rate_limit_copy"].push_back(
735+
{.packet_action = P4_PACKET_ACTION_FORWARD,
736+
.packet_color = P4_PACKET_COLOR_GREEN});
737+
app_db_entry.packet_action_color_lookup["acl_rate_limit_copy"].push_back(
738+
{.packet_action = P4_PACKET_ACTION_COPY_CANCEL,
739+
.packet_color = P4_PACKET_COLOR_YELLOW});
740+
app_db_entry.packet_action_color_lookup["acl_rate_limit_copy"].push_back(
741+
{.packet_action = P4_PACKET_ACTION_COPY_CANCEL,
742+
.packet_color = P4_PACKET_COLOR_RED});
743+
app_db_entry.action_field_lookup["acl_rate_limit_copy"].push_back(
744+
{.sai_action = P4_ACTION_SET_QOS_QUEUE, .p4_param_name = "qos_queue"});
745+
746+
747+
722748
// "action/acl_trap" = [
723749
// {"action": "SAI_PACKET_ACTION_TRAP", "packet_color":
724750
// "SAI_PACKET_COLOR_GREEN"},
@@ -2958,6 +2984,124 @@ TEST_F(AclManagerTest, AclRuleWithColorPacketActionsButNoRateLimit)
29582984
acl_rule->action_fvs[SAI_ACL_ENTRY_ATTR_ACTION_SET_USER_TRAP_ID].aclaction.parameter.oid);
29592985
}
29602986

2987+
TEST_F(AclManagerTest, AclRuleWithColorPacketActionsButWithRateLimit) {
2988+
ASSERT_NO_FATAL_FAILURE(AddDefaultIngressTable());
2989+
2990+
// Create app_db_entry with color packet action, but no rate limit attributes
2991+
P4AclRuleAppDbEntry app_db_entry;
2992+
app_db_entry.acl_table_name = kAclIngressTableName;
2993+
app_db_entry.priority = 100;
2994+
// ACL rule match fields
2995+
app_db_entry.match_fvs["ether_type"] = "0x0800";
2996+
app_db_entry.match_fvs["ipv6_dst"] = "fdf8:f53b:82e4::53";
2997+
app_db_entry.match_fvs["ether_dst"] = "AA:BB:CC:DD:EE:FF";
2998+
app_db_entry.match_fvs["ether_src"] = "AA:BB:CC:DD:EE:FF";
2999+
app_db_entry.match_fvs["ipv6_next_header"] = "1";
3000+
app_db_entry.match_fvs["src_ipv6_64bit"] = "fdf8:f53b:82e4::";
3001+
app_db_entry.match_fvs["arp_tpa"] = "0xff112231";
3002+
app_db_entry.match_fvs["udf2"] = "0x9876 & 0xAAAA";
3003+
app_db_entry.db_key =
3004+
"ACL_PUNT_TABLE:{\"match/ether_type\": \"0x0800\",\"match/ipv6_dst\": "
3005+
"\"fdf8:f53b:82e4::53\",\"match/ether_dst\": \"AA:BB:CC:DD:EE:FF\", "
3006+
"\"match/ether_src\": \"AA:BB:CC:DD:EE:FF\", \"match/ipv6_next_header\": "
3007+
"\"1\", \"match/src_ipv6_64bit\": "
3008+
"\"fdf8:f53b:82e4::\",\"match/arp_tpa\": \"0xff112231\",\"match/udf2\": "
3009+
"\"0x9876 & 0xAAAA\",\"priority\":100}";
3010+
3011+
const auto& acl_rule_key =
3012+
KeyGenerator::generateAclRuleKey(app_db_entry.match_fvs, "100");
3013+
3014+
// Set user defined trap for QOS_QUEUE, and color packet actions in meter
3015+
int queue_num = 8;
3016+
app_db_entry.action = "acl_rate_limit_copy";
3017+
app_db_entry.action_param_fvs["qos_queue"] = std::to_string(queue_num);
3018+
// Install rule
3019+
EXPECT_CALL(mock_sai_acl_, create_acl_entry(_, _, _, _))
3020+
.WillOnce(DoAll(SetArgPointee<0>(kAclIngressRuleOid1),
3021+
Return(SAI_STATUS_SUCCESS)));
3022+
3023+
EXPECT_CALL(mock_sai_acl_, create_acl_counter(_, _, _, _))
3024+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3025+
EXPECT_CALL(
3026+
mock_sai_policer_,
3027+
create_policer(
3028+
_, Eq(gSwitchId), Eq(9),
3029+
Truly(std::bind(MatchSaiPolicerAttribute, 9, SAI_METER_TYPE_PACKETS,
3030+
SAI_PACKET_ACTION_FORWARD,
3031+
SAI_PACKET_ACTION_COPY_CANCEL,
3032+
SAI_PACKET_ACTION_COPY_CANCEL,
3033+
0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff,
3034+
std::placeholders::_1))))
3035+
.WillOnce(
3036+
DoAll(SetArgPointee<0>(kAclMeterOid1), Return(SAI_STATUS_SUCCESS)));
3037+
EXPECT_EQ(StatusCode::SWSS_RC_SUCCESS,
3038+
ProcessAddRuleRequest(acl_rule_key, app_db_entry));
3039+
auto acl_rule = GetAclRule(kAclIngressTableName, acl_rule_key);
3040+
ASSERT_NE(nullptr, acl_rule);
3041+
// Check action field value
3042+
EXPECT_EQ(gUserDefinedTrapStartOid + queue_num - P4_CPU_QUEUE_MIN_NUM + 1,
3043+
acl_rule->action_fvs[SAI_ACL_ENTRY_ATTR_ACTION_SET_USER_TRAP_ID]
3044+
.aclaction.parameter.oid);
3045+
}
3046+
3047+
TEST_F(AclManagerTest, AclRuleWithMockedPacketAction) {
3048+
ASSERT_NO_FATAL_FAILURE(AddDefaultIngressTable());
3049+
auto app_db_entry = getDefaultAclRuleAppDbEntryWithoutAction();
3050+
const auto& acl_rule_key =
3051+
KeyGenerator::generateAclRuleKey(app_db_entry.match_fvs, "100");
3052+
3053+
// set packet action
3054+
app_db_entry.action = "set_packet_action";
3055+
app_db_entry.action_param_fvs["packet_action"] =
3056+
"SAI_PACKET_ACTION_COPY_CANCEL";
3057+
3058+
// Install rule
3059+
EXPECT_CALL(mock_sai_acl_, create_acl_entry(_, _, _, _))
3060+
.WillOnce(DoAll(SetArgPointee<0>(kAclIngressRuleOid1),
3061+
Return(SAI_STATUS_SUCCESS)));
3062+
EXPECT_CALL(mock_sai_acl_, create_acl_counter(_, _, _, _))
3063+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3064+
EXPECT_CALL(mock_sai_policer_, create_policer(_, _, _, _))
3065+
.WillOnce(
3066+
DoAll(SetArgPointee<0>(kAclMeterOid1), Return(SAI_STATUS_SUCCESS)));
3067+
EXPECT_EQ(StatusCode::SWSS_RC_SUCCESS,
3068+
ProcessAddRuleRequest(acl_rule_key, app_db_entry));
3069+
auto* acl_rule = GetAclRule(kAclIngressTableName, acl_rule_key);
3070+
ASSERT_NE(nullptr, acl_rule);
3071+
3072+
// Check action field value
3073+
EXPECT_EQ(SAI_PACKET_ACTION_COPY_CANCEL,
3074+
acl_rule->action_fvs[SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION]
3075+
.aclaction.parameter.s32);
3076+
3077+
// update packet action
3078+
app_db_entry.action_param_fvs["packet_action"] = "SAI_PACKET_ACTION_DENY";
3079+
EXPECT_CALL(mock_sai_acl_,
3080+
set_acl_entry_attribute(Eq(kAclIngressRuleOid1), _))
3081+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3082+
EXPECT_EQ(StatusCode::SWSS_RC_SUCCESS,
3083+
ProcessUpdateRuleRequest(app_db_entry, *acl_rule));
3084+
acl_rule = GetAclRule(kAclIngressTableName, acl_rule_key);
3085+
ASSERT_NE(nullptr, acl_rule);
3086+
3087+
// Check action field value
3088+
EXPECT_EQ(SAI_PACKET_ACTION_DENY,
3089+
acl_rule->action_fvs[SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION]
3090+
.aclaction.parameter.s32);
3091+
3092+
// Remove rule
3093+
EXPECT_CALL(mock_sai_acl_, remove_acl_entry(Eq(kAclIngressRuleOid1)))
3094+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3095+
EXPECT_CALL(mock_sai_acl_, remove_acl_counter(_))
3096+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3097+
EXPECT_CALL(mock_sai_policer_, remove_policer(Eq(kAclMeterOid1)))
3098+
.WillOnce(Return(SAI_STATUS_SUCCESS));
3099+
EXPECT_EQ(StatusCode::SWSS_RC_SUCCESS,
3100+
ProcessDeleteRuleRequest(kAclIngressTableName, acl_rule_key));
3101+
EXPECT_EQ(nullptr, GetAclRule(kAclIngressTableName, acl_rule_key));
3102+
}
3103+
3104+
29613105
#pragma GCC diagnostic warning "-Wdisabled-optimization"
29623106

29633107
TEST_F(AclManagerTest, AclRuleWithValidAction)
@@ -4285,7 +4429,7 @@ TEST_F(AclManagerTest, CreateAclRuleWithInvalidActionFails)
42854429
app_db_entry.action_param_fvs.erase("target");
42864430
// Invalid cpu queue number
42874431
app_db_entry.action = "qos_queue";
4288-
app_db_entry.action_param_fvs["cpu_queue"] = "10";
4432+
app_db_entry.action_param_fvs["cpu_queue"] = "18";
42894433
EXPECT_EQ(StatusCode::SWSS_RC_INVALID_PARAM, ProcessAddRuleRequest(acl_rule_key, app_db_entry));
42904434
app_db_entry.action_param_fvs["cpu_queue"] = "invalid";
42914435
EXPECT_EQ(StatusCode::SWSS_RC_INVALID_PARAM, ProcessAddRuleRequest(acl_rule_key, app_db_entry));

‎tests/p4rt/acl.py‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ class P4RtAclTableDefinitionWrapper(util.DBInterface):
4242
ACTION_COPY_AND_SET_TC = "action/copy_and_set_tc"
4343
ACTION_PUNT_AND_SET_TC = "action/punt_and_set_tc"
4444
ACTION_SET_QOS_QUEUE = "action/qos_queue"
45+
ACTION_SET_ACL_RATE_LIMIT_COPY = "action/acl_rate_limit_copy"
4546
METER_UNIT = "meter/unit"
4647
COUNTER_UNIT = "counter/unit"
4748

‎tests/p4rt/test_p4rt_acl.py‎

Lines changed: 104 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -176,6 +176,8 @@ def test_AclRulesAddUpdateDelPass(self, dvs, testlog):
176176
punt_and_set_tc = '[{"action":"SAI_PACKET_ACTION_TRAP","packet_color":"SAI_PACKET_COLOR_RED"},{"action":"SAI_ACL_ENTRY_ATTR_ACTION_SET_TC","param":"traffic_class"}]'
177177
qos_queue = '[{"action":"SAI_PACKET_ACTION_TRAP"},{"action":"QOS_QUEUE","param":"cpu_queue"}]'
178178

179+
acl_rate_limit_copy = '[{"action":"SAI_PACKET_ACTION_FORWARD","packet_color":"SAI_PACKET_COLOR_GREEN"},{"action":"SAI_PACKET_ACTION_COPY_CANCEL","packet_color":"SAI_PACKET_COLOR_YELLOW"},{"action":"SAI_PACKET_ACTION_COPY_CANCEL","packet_color":"SAI_PACKET_COLOR_RED"},{"action":"QOS_QUEUE","param":"qos_queue"}]'
180+
179181
attr_list = [
180182
(self._p4rt_acl_table_definition_obj.STAGE_FIELD, stage),
181183
(self._p4rt_acl_table_definition_obj.PRIORITY_FIELD, priority),
@@ -201,6 +203,7 @@ def test_AclRulesAddUpdateDelPass(self, dvs, testlog):
201203
punt_and_set_tc,
202204
),
203205
(self._p4rt_acl_table_definition_obj.ACTION_SET_QOS_QUEUE, qos_queue),
206+
(self._p4rt_acl_table_definition_obj.ACTION_SET_ACL_RATE_LIMIT_COPY, acl_rate_limit_copy),
204207
(self._p4rt_acl_table_definition_obj.METER_UNIT, meter_unit),
205208
(self._p4rt_acl_table_definition_obj.COUNTER_UNIT, counter_unit),
206209
]
@@ -1021,6 +1024,107 @@ def test_AclRulesAddUpdateDelPass(self, dvs, testlog):
10211024
]
10221025
util.verify_attr(fvs, attr_list)
10231026

1027+
1028+
# update ACL rule 2 with acl_rate_limit_copy action
1029+
action = "acl_rate_limit_copy"
1030+
1031+
attr_list = [
1032+
(self._p4rt_acl_rule_obj.ACTION, action),
1033+
("param/qos_queue", "7"),
1034+
(self._p4rt_acl_rule_obj.METER_CIR, meter_cir),
1035+
(self._p4rt_acl_rule_obj.METER_CBURST, meter_cbs),
1036+
(self._p4rt_acl_rule_obj.METER_PIR, meter_pir),
1037+
(self._p4rt_acl_rule_obj.METER_PBURST, meter_pbs),
1038+
]
1039+
1040+
self._p4rt_acl_rule_obj.set_app_db_entry(
1041+
table_name_with_rule_key2, attr_list)
1042+
util.verify_response(
1043+
self.response_consumer,
1044+
table_name_with_rule_key2,
1045+
attr_list,
1046+
"SWSS_RC_SUCCESS",
1047+
)
1048+
1049+
# query application database for ACL rules
1050+
acl_rules = util.get_keys(
1051+
self._p4rt_acl_rule_obj.appl_db,
1052+
self._p4rt_acl_rule_obj.APP_DB_TBL_NAME + ":" + table_name,
1053+
)
1054+
assert len(acl_rules) == len(original_appl_acl_rules) + 3
1055+
1056+
# query application database for updated ACL rule
1057+
(status, fvs) = util.get_key(
1058+
self._p4rt_acl_rule_obj.appl_db,
1059+
self._p4rt_acl_table_definition_obj.APP_DB_TBL_NAME,
1060+
table_name_with_rule_key2,
1061+
)
1062+
assert status == True
1063+
util.verify_attr(fvs, attr_list)
1064+
1065+
# query ASIC database for updated ACL meter
1066+
(status, fvs) = util.get_key(
1067+
self._p4rt_acl_meter_obj.asic_db,
1068+
self._p4rt_acl_meter_obj.ASIC_DB_TBL_NAME,
1069+
meter_asic_db_key2,
1070+
)
1071+
assert status == True
1072+
attr_list = [
1073+
(
1074+
self._p4rt_acl_meter_obj.SAI_ATTR_GREEN_PACKET_ACTION,
1075+
"SAI_PACKET_ACTION_FORWARD",
1076+
),
1077+
(
1078+
self._p4rt_acl_meter_obj.SAI_ATTR_YELLOW_PACKET_ACTION,
1079+
"SAI_PACKET_ACTION_COPY_CANCEL",
1080+
),
1081+
(
1082+
self._p4rt_acl_meter_obj.SAI_ATTR_RED_PACKET_ACTION,
1083+
"SAI_PACKET_ACTION_COPY_CANCEL",
1084+
),
1085+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_TYPE, "SAI_METER_TYPE_PACKETS"),
1086+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_MODE, "SAI_POLICER_MODE_TR_TCM"),
1087+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_CIR, meter_cir),
1088+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_CBS, meter_cbs),
1089+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_PIR, meter_pir),
1090+
(self._p4rt_acl_meter_obj.SAI_ATTR_METER_PBS, meter_pbs),
1091+
]
1092+
util.verify_attr(fvs, attr_list)
1093+
1094+
# query ASIC database for updated ACL rule
1095+
(status, fvs) = util.get_key(
1096+
self._p4rt_acl_rule_obj.asic_db,
1097+
self._p4rt_acl_rule_obj.ASIC_DB_TBL_NAME,
1098+
rule_asic_db_key2,
1099+
)
1100+
assert status == True
1101+
attr_list = [
1102+
(
1103+
self._p4rt_acl_rule_obj.SAI_ATTR_ACTION_SET_USER_TRAP_ID,
1104+
user_trap_asic_db_key,
1105+
),
1106+
(
1107+
self._p4rt_acl_rule_obj.SAI_ATTR_ACTION_PACKET_ACTION,
1108+
"disabled",
1109+
),
1110+
(self._p4rt_acl_rule_obj.SAI_ATTR_MATCH_ETHER_TYPE, "2048&mask:0xffff"),
1111+
(
1112+
self._p4rt_acl_rule_obj.SAI_ATTR_MATCH_IP_TYPE,
1113+
"SAI_ACL_IP_TYPE_IP&mask:0xffffffffffffffff",
1114+
),
1115+
(
1116+
self._p4rt_acl_rule_obj.SAI_ATTR_MATCH_DST_MAC,
1117+
"AA:BB:CC:DD:EE:FF&mask:FF:FF:FF:FF:FF:FF",
1118+
),
1119+
(self._p4rt_acl_rule_obj.SAI_ATTR_TABLE_ID, table_asic_db_key),
1120+
(self._p4rt_acl_rule_obj.SAI_ATTR_SET_POLICER, meter_asic_db_key2),
1121+
(self._p4rt_acl_rule_obj.SAI_ATTR_COUNTER, counter_asic_db_key2),
1122+
(self._p4rt_acl_rule_obj.SAI_ATTR_ADMIN_STATE, "true"),
1123+
(self._p4rt_acl_rule_obj.SAI_ATTR_PRIORITY, "100"),
1124+
]
1125+
util.verify_attr(fvs, attr_list)
1126+
1127+
10241128
# remove ACL rule 3
10251129
self._p4rt_acl_rule_obj.remove_app_db_entry(table_name_with_rule_key3)
10261130
util.verify_response(

0 commit comments

Comments
 (0)