[P4Orch] Add ACL action list during ACL table creation if they are mandatory.

Signed-off-by: mint570 <[email protected]>

Author: mint570

orchagent/p4orch/acl_rule_manager.cpp

@@ -116,13 +116,16 @@ class AclRuleManager : public ObjectManagerInterface
                                        P4AclRule &acl_rule);
 
     // Validate and set a match attribute in an ACL rule.
-    ReturnCode setMatchValue(const acl_entry_attr_union_t attr_name, const std::string &attr_value,
-                             sai_attribute_value_t *value, P4AclRule *acl_rule,
-                             const std::string &ip_type_bit_type = EMPTY_STRING);
+    ReturnCode setMatchValue(
+        const sai_acl_entry_attr_t attr_name, const std::string& attr_value,
+        sai_attribute_value_t* value, P4AclRule* acl_rule,
+        const std::string& ip_type_bit_type = EMPTY_STRING);
 
     // Validate and set an action attribute in an ACL rule.
-    ReturnCode setActionValue(const acl_entry_attr_union_t attr_name, const std::string &attr_value,
-                              sai_attribute_value_t *value, P4AclRule *acl_rule);
+    ReturnCode setActionValue(const sai_acl_entry_attr_t attr_name,
+                              const std::string& attr_value,
+                              sai_attribute_value_t* value,
+                              P4AclRule* acl_rule);
 
     // Get port object id by name for redirect action.
     ReturnCode getRedirectActionPortOid(const std::string &target, sai_object_id_t *rediect_oid);

orchagent/p4orch/acl_rule_manager.h

@@ -103,10 +103,11 @@ class AclTableManager : public ObjectManagerInterface
                                  const P4AclTableDefinition *acl_table);
 
     // Verifies ASIC DB for an entry.
-    std::string verifyStateAsicDb(const P4AclTableDefinition *acl_table);
+    std::string verifyStateAsicDb(P4AclTableDefinition* acl_table);
 
     // Returns ACl table SAI attributes.
-    ReturnCodeOr<std::vector<sai_attribute_t>> getTableSaiAttrs(const P4AclTableDefinition &acl_table);
+    ReturnCodeOr<std::vector<sai_attribute_t>> getTableSaiAttrs(
+        P4AclTableDefinition& acl_table);
 
     // Returns UDF SAI attributes.
     ReturnCodeOr<std::vector<sai_attribute_t>> getUdfSaiAttrs(const P4UdfField &udf_field);
@@ -117,9 +118,6 @@ class AclTableManager : public ObjectManagerInterface
     std::deque<swss::KeyOpFieldsValuesTuple> m_entries;
     std::map<sai_acl_stage_t, std::vector<std::string>> m_aclTablesByStage;
 
-    // Always add counter action in ACL table action list during creation
-    int32_t m_acl_action_list[1];
-
     friend class p4orch::test::AclManagerTest;
 };
 

orchagent/p4orch/acl_table_manager.cpp

@@ -6,6 +6,7 @@
 #include <string>
 #include <vector>
 
+#include "acltable.h"
 #include "p4orch/p4orch_util.h"
 #include "return_code.h"
 extern "C"
@@ -17,11 +18,6 @@ extern "C"
 namespace p4orch
 {
 
-// sai_acl_entry_attr_t or sai_acl_entry_attr_extensions_t
-using acl_entry_attr_union_t = int32_t;
-// sai_acl_table_attr_t or sai_acl_table_attr_extensions_t
-using acl_table_attr_union_t = int32_t;
-
 // Describes the format of a value.
 enum Format
 {
@@ -138,19 +134,19 @@ struct P4AclRule
 
     sai_uint32_t priority;
     std::string p4_action;
-    std::map<acl_entry_attr_union_t, sai_attribute_value_t> match_fvs;
-    std::map<acl_entry_attr_union_t, sai_attribute_value_t> action_fvs;
+    std::map<sai_acl_entry_attr_t, sai_attribute_value_t> match_fvs;
+    std::map<sai_acl_entry_attr_t, sai_attribute_value_t> action_fvs;
     P4AclMeter meter;
     P4AclCounter counter;
 
     sai_uint32_t action_qos_queue_num;
     std::string action_redirect_nexthop_key;
     // SAI_ACL_ENTRY_ATTR_ACTION_MIRROR_INGRESS and
     // SAI_ACL_ENTRY_ATTR_ACTION_MIRROR_EGRESS are allowed as key
-    std::map<acl_entry_attr_union_t, P4AclMirrorSession> action_mirror_sessions;
+    std::map<sai_acl_entry_attr_t, P4AclMirrorSession> action_mirror_sessions;
     // Stores mapping from SAI_ACL_TABLE_ATTR_USER_DEFINED_FIELD_GROUP_{number} to
     // udf data and masks pairs in two uin8_t list
-    std::map<acl_entry_attr_union_t, P4UdfDataMask> udf_data_masks;
+    std::map<sai_acl_entry_attr_t, P4UdfDataMask> udf_data_masks;
     std::vector<std::string> in_ports;
     std::vector<std::string> out_ports;
     std::vector<sai_object_id_t> in_ports_oids;
@@ -159,14 +155,14 @@ struct P4AclRule
 
 struct SaiActionWithParam
 {
-    acl_entry_attr_union_t action;
-    std::string param_name;
-    std::string param_value;
+  sai_acl_entry_attr_t action;
+  std::string param_name;
+  std::string param_value;
 
-    bool operator==(const SaiActionWithParam &entry) const
-    {
-        return action == entry.action && param_name == entry.param_name && param_value == entry.param_value;
-    }
+  bool operator==(const SaiActionWithParam& entry) const {
+    return action == entry.action && param_name == entry.param_name &&
+           param_value == entry.param_value;
+  }
 
     bool operator!=(const SaiActionWithParam &entry) const
     {
@@ -176,16 +172,15 @@ struct SaiActionWithParam
 
 struct SaiMatchField
 {
-    acl_entry_attr_union_t entry_attr;
-    acl_table_attr_union_t table_attr;
-    uint32_t bitwidth;
-    Format format;
+  sai_acl_entry_attr_t entry_attr;
+  sai_acl_table_attr_t table_attr;
+  uint32_t bitwidth;
+  Format format;
 
-    bool operator==(const SaiMatchField &entry) const
-    {
-        return entry_attr == entry.entry_attr && table_attr == entry.table_attr && bitwidth == entry.bitwidth &&
-               format == entry.format;
-    }
+  bool operator==(const SaiMatchField& entry) const {
+    return entry_attr == entry.entry_attr && table_attr == entry.table_attr &&
+           bitwidth == entry.bitwidth && format == entry.format;
+  }
 
     bool operator!=(const SaiMatchField &entry) const
     {
@@ -238,6 +233,7 @@ struct P4AclTableDefinition
     std::map<std::string, std::string> ip_type_bit_type_lookup;
     std::map<std::string, std::vector<SaiActionWithParam>> rule_action_field_lookup;
     std::map<std::string, std::map<sai_policer_attr_t, sai_packet_action_t>> rule_packet_action_color_lookup;
+    std::vector<sai_acl_action_type_t> acl_action_type_list;
 
     P4AclTableDefinition() = default;
     P4AclTableDefinition(const std::string &acl_table_name, const sai_acl_stage_t stage, const uint32_t priority,
@@ -254,9 +250,9 @@ struct P4UserDefinedTrapHostifTableEntry
         : user_defined_trap(SAI_NULL_OBJECT_ID), hostif_table_entry(SAI_NULL_OBJECT_ID) {};
 };
 
-using acl_rule_attr_lookup_t = std::map<std::string, acl_entry_attr_union_t>;
-using acl_table_attr_lookup_t = std::map<std::string, acl_table_attr_union_t>;
-using acl_table_attr_format_lookup_t = std::map<acl_table_attr_union_t, Format>;
+using acl_rule_attr_lookup_t = std::map<std::string, sai_acl_entry_attr_t>;
+using acl_table_attr_lookup_t = std::map<std::string, sai_acl_table_attr_t>;
+using acl_table_attr_format_lookup_t = std::map<sai_acl_table_attr_t, Format>;
 using acl_packet_action_lookup_t = std::map<std::string, sai_packet_action_t>;
 using acl_packet_color_lookup_t = std::map<std::string, sai_packet_color_t>;
 using acl_packet_color_policer_attr_lookup_t = std::map<std::string, sai_policer_attr_t>;
@@ -728,6 +724,13 @@ static std::map<sai_stat_id_t, std::string> aclCounterStatsIdNameMap = {
     {SAI_POLICER_STAT_RED_BYTES, P4_COUNTER_STATS_RED_BYTES},
 };
 
+static const std::map<sai_acl_stage_t, acl_stage_type_t>
+    aclSaiStageAttrToEnumLookup = {
+        {SAI_ACL_STAGE_INGRESS, ACL_STAGE_INGRESS},
+        {SAI_ACL_STAGE_EGRESS, ACL_STAGE_EGRESS},
+        {SAI_ACL_STAGE_PRE_INGRESS, ACL_STAGE_PRE_INGRESS},
+};
+
 // Parse ACL table definition APP DB entry action field to P4ActionParamName
 // action_list and P4PacketActionWithColor action_color_list
 bool parseAclTableAppDbActionField(const std::string &aggr_actions_str, std::vector<P4ActionParamName> *action_list,
@@ -771,8 +774,11 @@ ReturnCode buildAclTableDefinitionMatchFieldValues(const std::map<std::string, s
 // Build SaiActionWithParam action map for ACL table definition
 // by P4ActionParamName action map
 ReturnCode buildAclTableDefinitionActionFieldValues(
-    const std::map<std::string, std::vector<P4ActionParamName>> &action_field_lookup,
-    std::map<std::string, std::vector<SaiActionWithParam>> *aggr_sai_actions_lookup);
+    const std::map<std::string, std::vector<P4ActionParamName>>&
+        action_field_lookup,
+    std::map<std::string, std::vector<SaiActionWithParam>>*
+        aggr_sai_actions_lookup,
+    std::set<sai_acl_action_type_t>* acl_action_type_set);
 
 bool isSetUserTrapActionInAclTableDefinition(
     const std::map<std::string, std::vector<SaiActionWithParam>> &aggr_sai_actions_lookup);
@@ -782,34 +788,43 @@ bool isSetUserTrapActionInAclTableDefinition(
 // P4PacketActionWithColor action map. If packet color is empty, then the
 // packet action should add as a SaiActionWithParam
 ReturnCode buildAclTableDefinitionActionColorFieldValues(
-    const std::map<std::string, std::vector<P4PacketActionWithColor>> &action_color_lookup,
-    std::map<std::string, std::vector<SaiActionWithParam>> *aggr_sai_actions_lookup,
-    std::map<std::string, std::map<sai_policer_attr_t, sai_packet_action_t>> *aggr_sai_action_color_lookup);
+    const std::map<std::string, std::vector<P4PacketActionWithColor>>&
+        action_color_lookup,
+    std::map<std::string, std::vector<SaiActionWithParam>>*
+        aggr_sai_actions_lookup,
+    std::map<std::string, std::map<sai_policer_attr_t, sai_packet_action_t>>*
+        aggr_sai_action_color_lookup,
+    std::set<sai_acl_action_type_t>* acl_action_type_set);
 
 // Set IP_TYPE in match field
 bool setMatchFieldIpType(const std::string &attr_value, sai_attribute_value_t *value,
                          const std::string &ip_type_bit_type);
 
 // Set composite match field with sai_field type. Currently only ACL entry
 // attributes listed in aclCompositeMatchTableAttrLookup are supported
-ReturnCode setCompositeSaiMatchValue(const acl_entry_attr_union_t attr_name, const std::string &attr_value,
-                                     sai_attribute_value_t *value);
+ReturnCode setCompositeSaiMatchValue(const sai_acl_entry_attr_t attr_name,
+                                     const std::string& attr_value,
+                                     sai_attribute_value_t* value);
 
 // Set composite match field with sai_field type.
 ReturnCode setUdfMatchValue(const P4UdfField &udf_field, const std::string &attr_value, sai_attribute_value_t *value,
                             P4UdfDataMask *udf_data_mask, uint16_t bytes_offset);
 
 // Compares the action value difference if the action field is present in
 // both new and old ACL rules. Returns true if action values are different.
-bool isDiffActionFieldValue(const acl_entry_attr_union_t attr_name, const sai_attribute_value_t &value,
-                            const sai_attribute_value_t &old_value, const P4AclRule &acl_rule,
-                            const P4AclRule &old_acl_rule);
+bool isDiffActionFieldValue(const sai_acl_entry_attr_t attr_name,
+                            const sai_attribute_value_t& value,
+                            const sai_attribute_value_t& old_value,
+                            const P4AclRule& acl_rule,
+                            const P4AclRule& old_acl_rule);
 
 // Compares the match value difference if the match field is present in
 // both new and old ACL rules. Returns true if match values are different.
 // This method is used in state verification only.
-bool isDiffMatchFieldValue(const acl_entry_attr_union_t attr_name, const sai_attribute_value_t &value,
-                           const sai_attribute_value_t &old_value, const P4AclRule &acl_rule,
-                           const P4AclRule &old_acl_rule);
+bool isDiffMatchFieldValue(const sai_acl_entry_attr_t attr_name,
+                           const sai_attribute_value_t& value,
+                           const sai_attribute_value_t& old_value,
+                           const P4AclRule& acl_rule,
+                           const P4AclRule& old_acl_rule);
 
 } // namespace p4orch

orchagent/p4orch/acl_table_manager.h

@@ -60,6 +60,7 @@ p4orch_tests_SOURCES = $(ORCHAGENT_DIR)/orch.cpp \
 		       fake_subscriberstatetable.cpp \
 		       fake_notificationconsumer.cpp \
 		       fake_table.cpp \
+		       fake_aclorch.cpp \
 		       p4oidmapper_test.cpp \
 		       p4orch_test.cpp \
 		       p4orch_util_test.cpp \