[P4Orch] Add IPv6 src IP as new ternary key field for table ipv6_tunnel_termination_table

orchagent/p4orch/p4orch_util.cpp

@@ -259,10 +259,11 @@ std::string KeyGenerator::generateTunnelKey(const std::string &tunnel_id)
 }
 
 std::string KeyGenerator::generateIpv6TunnelTermKey(
-  const swss::IpAddress &dst_ipv6_ip,
-  const swss::IpAddress &dst_ipv6_mask,
-  const std::string& vrf_id) {
+    const swss::IpAddress& src_ipv6_ip, const swss::IpAddress& src_ipv6_mask,
+    const swss::IpAddress& dst_ipv6_ip, const swss::IpAddress& dst_ipv6_mask) {
   std::map<std::string, std::string> fv_map = {
+      {p4orch::kDecapSrcIpv6Ip, src_ipv6_ip.to_string()},
+      {p4orch::kDecapSrcIpv6Mask, src_ipv6_mask.to_string()},
       {p4orch::kDecapDstIpv6Ip, dst_ipv6_ip.to_string()},
       {p4orch::kDecapDstIpv6Mask, dst_ipv6_mask.to_string()}};
   return generateKey(fv_map);

orchagent/p4orch/p4orch_util.h

@@ -103,7 +103,10 @@ constexpr char* kDisableSrcMacRewrite = "disable_src_mac_rewrite";
 constexpr char* kDisableDstMacRewrite = "disable_dst_mac_rewrite";
 constexpr char* kDisableVlanRewrite = "disable_vlan_rewrite";
 constexpr char* kIpv6TunnelTermAction = "mark_for_tunnel_decap_and_set_vrf";
+constexpr char* kDecapSrcIpv6 = "src_ipv6";
 constexpr char* kDecapDstIpv6 = "dst_ipv6";
+constexpr char* kDecapSrcIpv6Ip = "src_ipv6_ip";
+constexpr char* kDecapSrcIpv6Mask = "src_ipv6_mask";
 constexpr char* kDecapDstIpv6Ip = "dst_ipv6_ip";
 constexpr char* kDecapDstIpv6Mask = "dst_ipv6_mask";
 
@@ -318,6 +321,8 @@ struct P4AclRuleAppDbEntry
 struct Ipv6TunnelTermAppDbEntry
 {
   // Match
+  swss::IpAddress src_ipv6_ip;
+  swss::IpAddress src_ipv6_mask;
   swss::IpAddress dst_ipv6_ip;
   swss::IpAddress dst_ipv6_mask;
   // Action
@@ -412,9 +417,10 @@ class KeyGenerator
 
     static std::string generateTunnelKey(const std::string &tunnel_id);
 
-    static std::string generateIpv6TunnelTermKey(const swss::IpAddress &dst_ipv6_ip,
-                                                 const swss::IpAddress &dst_ipv6_mask,
-                                                 const std::string& vrf_id);
+    static std::string generateIpv6TunnelTermKey(const swss::IpAddress& src_ipv6_ip,
+                                                 const swss::IpAddress& src_ipv6_mask,
+                                                 const swss::IpAddress& dst_ipv6_ip,
+                                                 const swss::IpAddress& dst_ipv6_mask);
 
     static std::string generateExtTableKey(const std::string &table_name, const std::string &table_key);
 

orchagent/p4orch/tests/p4orch_util_test.cpp

@@ -51,9 +51,11 @@ TEST(P4OrchUtilTest, KeyGeneratorTest)
 
     auto ipv6_tunnel_term_key =
         KeyGenerator::generateIpv6TunnelTermKey(
-          swss::IpAddress("::1"), swss::IpAddress("::1"), "vrf_id");
+        swss::IpAddress("::1"), swss::IpAddress("::1"), swss::IpAddress("::2"),
+        swss::IpAddress("::2"));
     EXPECT_EQ(
-      "dst_ipv6_ip=::1:dst_ipv6_mask=::1", ipv6_tunnel_term_key);
+        "dst_ipv6_ip=::2:dst_ipv6_mask=::2:src_ipv6_ip=::1:src_ipv6_mask=::1",
+        ipv6_tunnel_term_key);
 }
 
 TEST(P4OrchUtilTest, ParseP4RTKeyTest)

orchagent/p4orch/tunnel_decap_group_manager.cpp

@@ -70,6 +70,14 @@ std::vector<sai_attribute_t> prepareSaiAttrs(
   attr.value.s32 = SAI_TUNNEL_TERM_TABLE_ENTRY_TYPE_MP2MP;
   attrs.push_back(attr);
 
+  // Match on source IP.
+  attr.id = SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP;
+  swss::copy(attr.value.ipaddr, ipv6_tunnel_term_entry.src_ipv6_ip);
+  attrs.push_back(attr);
+  // Match on source MASK.
+  attr.id = SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP_MASK;
+  swss::copy(attr.value.ipaddr, ipv6_tunnel_term_entry.src_ipv6_mask);
+  attrs.push_back(attr);
   // Match on destination IP.
   attr.id = SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP;
   swss::copy(attr.value.ipaddr, ipv6_tunnel_term_entry.dst_ipv6_ip);
@@ -135,14 +143,24 @@ ReturnCode TunnelDecapGroupManager::validateIpv6TunnelTermAppDbEntry(
            << "Invalid action " << QuotedVar(app_db_entry.action_str)
            << " of Ipv6 tunnel termination table entry";
   }
+  if (app_db_entry.src_ipv6_ip.isV4()) {
+    return ReturnCode(StatusCode::SWSS_RC_INVALID_PARAM)
+           << QuotedVar(prependParamField("src_ipv6_ip"))
+           << " field is not IPv6";
+  }
+  if (app_db_entry.src_ipv6_mask.isV4()) {
+    return ReturnCode(StatusCode::SWSS_RC_INVALID_PARAM)
+           << QuotedVar(prependParamField("src_ipv6_mask"))
+           << " field is not IPv6";
+  }
   if (app_db_entry.dst_ipv6_ip.isV4()) {
     return ReturnCode(StatusCode::SWSS_RC_INVALID_PARAM)
            << QuotedVar(prependParamField("dst_ipv6_ip"))
            << " field is not IPv6";
   }
   if (app_db_entry.dst_ipv6_mask.isV4()) {
     return ReturnCode(StatusCode::SWSS_RC_INVALID_PARAM)
-           << QuotedVar(prependParamField("dst_ipv6_ip"))
+           << QuotedVar(prependParamField("dst_ipv6_mask"))
            << " field is not IPv6";
   }
   return ReturnCode();
@@ -153,10 +171,11 @@ ReturnCode TunnelDecapGroupManager::validateIpv6TunnelTermAppDbEntry(
     const std::string& operation) {
   SWSS_LOG_ENTER();
 
-  Ipv6TunnelTermTableEntry entry =
-      Ipv6TunnelTermTableEntry(app_db_entry.dst_ipv6_ip,
-                               app_db_entry.dst_ipv6_mask, app_db_entry.vrf_id);
-
+  Ipv6TunnelTermTableEntry entry = Ipv6TunnelTermTableEntry(
+      app_db_entry.src_ipv6_ip, app_db_entry.src_ipv6_mask,
+      app_db_entry.dst_ipv6_ip, app_db_entry.dst_ipv6_mask,
+      app_db_entry.vrf_id);
+
   if (operation == SET_COMMAND) {
     RETURN_IF_ERROR(validateIpv6TunnelTermAppDbEntry(app_db_entry));
     if (getIpv6TunnelTermEntry(entry.ipv6_tunnel_term_key) == nullptr) {
@@ -174,6 +193,8 @@ ReturnCode TunnelDecapGroupManager::validateIpv6TunnelTermAppDbEntry(
         return ReturnCode(StatusCode::SWSS_RC_NOT_FOUND)
                << "No VRF found with id " << QuotedVar(entry.vrf_id) << " for "
                << "Ipv6 tunnel termination table entry that matches on "
+               << QuotedVar(entry.src_ipv6_ip.to_string()) << "&"
+               << QuotedVar(entry.src_ipv6_mask.to_string()) << " and "
                << QuotedVar(entry.dst_ipv6_ip.to_string()) << "&"
                << QuotedVar(entry.dst_ipv6_mask.to_string());
       }
@@ -211,12 +232,17 @@ ReturnCode TunnelDecapGroupManager::validateIpv6TunnelTermAppDbEntry(
 }
 
 Ipv6TunnelTermTableEntry::Ipv6TunnelTermTableEntry(
+    const swss::IpAddress& src_ipv6_ip, const swss::IpAddress& src_ipv6_mask,
     const swss::IpAddress& dst_ipv6_ip, const swss::IpAddress& dst_ipv6_mask,
     const std::string& vrf_id)
-    : dst_ipv6_ip(dst_ipv6_ip), dst_ipv6_mask(dst_ipv6_mask), vrf_id(vrf_id) {
-  SWSS_LOG_ENTER();
-  ipv6_tunnel_term_key = KeyGenerator::generateIpv6TunnelTermKey(
-      dst_ipv6_ip, dst_ipv6_mask, vrf_id);
+    : src_ipv6_ip(src_ipv6_ip),
+      src_ipv6_mask(src_ipv6_mask),
+      dst_ipv6_ip(dst_ipv6_ip),
+      dst_ipv6_mask(dst_ipv6_mask),
+      vrf_id(vrf_id) {
+   SWSS_LOG_ENTER();
+   ipv6_tunnel_term_key = KeyGenerator::generateIpv6TunnelTermKey(
+       src_ipv6_ip, src_ipv6_mask, dst_ipv6_ip, dst_ipv6_mask);
 }
 
 ReturnCode TunnelDecapGroupManager::getSaiObject(const std::string& json_key,
@@ -269,10 +295,9 @@ ReturnCode TunnelDecapGroupManager::drain() {
     auto& app_db_entry = *app_db_entry_or;
 
     const std::string ipv6_tunnel_term_entry_key =
-        KeyGenerator::generateIpv6TunnelTermKey(app_db_entry.dst_ipv6_ip,
-                                                app_db_entry.dst_ipv6_mask,
-                                                app_db_entry.vrf_id);
-
+         KeyGenerator::generateIpv6TunnelTermKey(
+            app_db_entry.src_ipv6_ip, app_db_entry.src_ipv6_mask,
+            app_db_entry.dst_ipv6_ip, app_db_entry.dst_ipv6_mask);
     bool update =
         (getIpv6TunnelTermEntry(ipv6_tunnel_term_entry_key) != nullptr);
 
@@ -334,11 +359,25 @@ TunnelDecapGroupManager::deserializeIpv6TunnelTermAppDbEntry(
   Ipv6TunnelTermAppDbEntry app_db_entry = {};
 
   // Default IP and mask.
+  app_db_entry.src_ipv6_ip = swss::IpAddress("0:0:0:0:0:0:0:0");
+  app_db_entry.src_ipv6_mask = swss::IpAddress("0:0:0:0:0:0:0:0");
   app_db_entry.dst_ipv6_ip = swss::IpAddress("0:0:0:0:0:0:0:0");
   app_db_entry.dst_ipv6_mask = swss::IpAddress("0:0:0:0:0:0:0:0");
 
   try {
     nlohmann::json j = nlohmann::json::parse(key);
+    if (j.find(prependMatchField(p4orch::kDecapSrcIpv6)) != j.end()) {
+      std::string src_ipv6 = j[prependMatchField(p4orch::kDecapSrcIpv6)];
+      const auto& src_ip_and_mask =
+          swss::tokenize(src_ipv6, p4orch::kDataMaskDelimiter);
+      if (src_ip_and_mask.size() != 2) {
+        return ReturnCode(StatusCode::SWSS_RC_INVALID_PARAM)
+               << "Invalid Ipv6 tunnel termination table entry: "
+               << "should be in the format of <value> & <mask>.";
+      }
+      app_db_entry.src_ipv6_ip = swss::IpAddress(trim(src_ip_and_mask[0]));
+      app_db_entry.src_ipv6_mask = swss::IpAddress(trim(src_ip_and_mask[1]));
+    }
     if (j.find(prependMatchField(p4orch::kDecapDstIpv6)) != j.end()) {
       std::string ipv6 = j[prependMatchField(p4orch::kDecapDstIpv6)];
       const auto& ip_and_mask =
@@ -389,7 +428,9 @@ std::vector<ReturnCode> TunnelDecapGroupManager::createIpv6TunnelTermEntries(
   for (size_t i = 0; i < ipv6_tunnel_term_entries.size(); ++i) {
     statuses[i] = StatusCode::SWSS_RC_NOT_EXECUTED;
     entries.push_back(
-        Ipv6TunnelTermTableEntry(ipv6_tunnel_term_entries[i].dst_ipv6_ip,
+        Ipv6TunnelTermTableEntry(ipv6_tunnel_term_entries[i].src_ipv6_ip,
+                                 ipv6_tunnel_term_entries[i].src_ipv6_mask,
+                                 ipv6_tunnel_term_entries[i].dst_ipv6_ip,
                                  ipv6_tunnel_term_entries[i].dst_ipv6_mask,
                                  ipv6_tunnel_term_entries[i].vrf_id));
 
@@ -451,10 +492,11 @@ std::vector<ReturnCode> TunnelDecapGroupManager::removeIpv6TunnelTermEntries(
 
     const std::string ipv6_tunnel_term_entry_key =
         KeyGenerator::generateIpv6TunnelTermKey(
+            ipv6_tunnel_term_entries[i].src_ipv6_ip,
+            ipv6_tunnel_term_entries[i].src_ipv6_mask,
             ipv6_tunnel_term_entries[i].dst_ipv6_ip,
-            ipv6_tunnel_term_entries[i].dst_ipv6_mask,
-            ipv6_tunnel_term_entries[i].vrf_id);
-
+            ipv6_tunnel_term_entries[i].dst_ipv6_mask);
+
     // getIpv6TunnelTermEntry() may return a nullptr.
     // For entry deletion operations validateIpv6TunnelTermAppDbEntry() checks
     // if the getIpv6TunnelTermEntry() function returns nullptr.
@@ -563,9 +605,9 @@ std::string TunnelDecapGroupManager::verifyState(
   auto& app_db_entry = *app_db_entry_or;
 
   const std::string ipv6_tunnel_term_entry_key =
-      KeyGenerator::generateIpv6TunnelTermKey(app_db_entry.dst_ipv6_ip,
-                                              app_db_entry.dst_ipv6_mask,
-                                              app_db_entry.vrf_id);
+           KeyGenerator::generateIpv6TunnelTermKey(
+          app_db_entry.src_ipv6_ip, app_db_entry.src_ipv6_mask,
+          app_db_entry.dst_ipv6_ip, app_db_entry.dst_ipv6_mask);
   auto* ipv6_tunnel_term_entry =
       getIpv6TunnelTermEntry(ipv6_tunnel_term_entry_key);
   if (ipv6_tunnel_term_entry == nullptr) {
@@ -591,9 +633,10 @@ std::string TunnelDecapGroupManager::verifyStateCache(
     const Ipv6TunnelTermAppDbEntry& app_db_entry,
     const Ipv6TunnelTermTableEntry* ipv6_tunnel_term_entry) {
   const std::string ipv6_tunnel_term_entry_key =
-      KeyGenerator::generateIpv6TunnelTermKey(app_db_entry.dst_ipv6_ip,
-                                              app_db_entry.dst_ipv6_mask,
-                                              app_db_entry.vrf_id);
+          KeyGenerator::generateIpv6TunnelTermKey(
+            app_db_entry.src_ipv6_ip, app_db_entry.src_ipv6_mask,
+            app_db_entry.dst_ipv6_ip, app_db_entry.dst_ipv6_mask);
+
   ReturnCode status =
       validateIpv6TunnelTermAppDbEntry(app_db_entry, SET_COMMAND);
   if (!status.ok()) {
@@ -621,6 +664,24 @@ std::string TunnelDecapGroupManager::verifyStateCache(
         << " in Tunnel Decap Group manager.";
     return msg.str();
   }
+  if (app_db_entry.src_ipv6_ip != ipv6_tunnel_term_entry->src_ipv6_ip) {
+    std::stringstream msg;
+    msg << "Ipv6 tunnel termination table entry with src_ipv6_ip "
+        << QuotedVar(app_db_entry.src_ipv6_ip.to_string())
+        << " does not match internal cache "
+        << QuotedVar(ipv6_tunnel_term_entry->src_ipv6_ip.to_string())
+        << " in Tunnel Decap Group manager.";
+    return msg.str();
+  }
+  if (app_db_entry.src_ipv6_mask != ipv6_tunnel_term_entry->src_ipv6_mask) {
+    std::stringstream msg;
+    msg << "Ipv6 tunnel termination table entry with src_ipv6_mask "
+        << QuotedVar(app_db_entry.src_ipv6_mask.to_string())
+        << " does not match internal cache "
+        << QuotedVar(ipv6_tunnel_term_entry->src_ipv6_mask.to_string())
+        << " in Tunnel Decap Group manager.";
+    return msg.str();
+  }
   if (app_db_entry.dst_ipv6_ip != ipv6_tunnel_term_entry->dst_ipv6_ip) {
     std::stringstream msg;
     msg << "Ipv6 tunnel termination table entry with dst_ipv6_ip "

orchagent/p4orch/tunnel_decap_group_manager.h

@@ -18,7 +18,8 @@ extern "C" {
 // Ipv6TunnelTermTableEntry holds TunnelDecapGroupManager's internal cache of
 // tunnel termination table entry. Example:
 // P4RT:FIXED_IPV6_TUNNEL_TERMINATION_TABLE:{"match/dst_ipv6_64bit":
-//   "2607:f8b0:c145:9300:: & ffff:ffff:ffff:ff00::"}
+//   "2607:f8b0:c145:9300:: & ffff:ffff:ffff:ff00::",
+//   "match/src_ipv6_64bit":"2607:f8b0:c145:9300:: & ffff:ffff:ffff:ff00::"}
 //   "action" = "mark_for_tunnel_decap_and_set_vrf",
 //   "param/vrf_id" = "b4-traffic",
 //   "controller_metadata" = "..."
@@ -29,6 +30,8 @@ struct Ipv6TunnelTermTableEntry {
 
   // Fields from P4 table.
   // Match
+  swss::IpAddress src_ipv6_ip;
+  swss::IpAddress src_ipv6_mask;
   swss::IpAddress dst_ipv6_ip;
   swss::IpAddress dst_ipv6_mask;
   // Action
@@ -39,7 +42,9 @@ struct Ipv6TunnelTermTableEntry {
   // SAI OID of the vrf_id for SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID
   sai_object_id_t vrf_oid = SAI_NULL_OBJECT_ID;
 
-  Ipv6TunnelTermTableEntry(const swss::IpAddress& dst_ipv6_ip,
+  Ipv6TunnelTermTableEntry(const swss::IpAddress& src_ipv6_ip,
+                           const swss::IpAddress& src_ipv6_mask,
+                           const swss::IpAddress& dst_ipv6_ip,
                            const swss::IpAddress& dst_ipv6_mask,
                            const std::string& vrf_id);
 };

tests/p4rt/test_p4rt_tunnel_decap.py

@@ -16,15 +16,19 @@ class P4RtTunnelDecapWrapper(util.DBInterface):
 
     ASIC_DB_TBL_NAME = "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TUNNEL_TYPE = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TUNNEL_TYPE"
+    SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP"
+    SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP_MASK = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP_MASK"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TYPE = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TYPE"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP_MASK = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP_MASK"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID"
     SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_ACTION_TUNNEL_ID = "SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_ACTION_TUNNEL_ID"
 
-    def generate_app_db_key(self, ipv6):
+    def generate_app_db_key(self, src_ipv6, dst_ipv6):
         d = {}
-        d[util.prepend_match_field("dst_ipv6")] = ipv6
+        d[util.prepend_match_field("src_ipv6")] = src_ipv6
+        d[util.prepend_match_field("dst_ipv6")] = dst_ipv6
+
         key = json.dumps(d, separators=(",", ":"))
         return self.TBL_NAME + ":" + key
 
@@ -61,19 +65,19 @@ def test_TunnelDecapGroupAddModifyAndDelete(self, dvs, testlog):
             self._p4rt_tunnel_decap_wrapper.asic_db, self._p4rt_tunnel_decap_wrapper.ASIC_DB_TBL_NAME)
 
         # 1. Create tunnel decap group
-        ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
+        src_ipv6 = "4001:db8:3c4d:17::&ffff:ffff:ffff:ffff::"
+        dst_ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
         action = "mark_for_tunnel_decap_and_set_vrf"
         vrf_id = "b4-traffic"
 
         attr_list_in_app_db = [(self._p4rt_tunnel_decap_wrapper.ACTION, action),
                                (util.prepend_param_field(
                                    self._p4rt_tunnel_decap_wrapper.VRF_ID), vrf_id)]
-        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(ipv6)
+        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(src_ipv6, dst_ipv6)
         self._p4rt_tunnel_decap_wrapper.set_app_db_entry(
             tunnel_decap_group_key, attr_list_in_app_db)
         util.verify_response(
             self._response_consumer, tunnel_decap_group_key, attr_list_in_app_db, "SWSS_RC_SUCCESS")
-
         # Query application database for tunnel decap group entries
         appl_tunnel_decap_group_entries = util.get_keys(
             self._p4rt_tunnel_decap_wrapper.appl_db,
@@ -108,12 +112,14 @@ def test_TunnelDecapGroupAddModifyAndDelete(self, dvs, testlog):
         assert status == True
 
         # Get oid of dummy tunnel
-        dummy_tunnel_oid = fvs[5][1]
+        dummy_tunnel_oid = fvs[7][1]
         assert dummy_tunnel_oid != None
 
         expected_attr_list_in_asic_db = [
             (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TUNNEL_TYPE, "SAI_TUNNEL_TYPE_IPINIP"),
             (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TYPE, "SAI_TUNNEL_TERM_TABLE_ENTRY_TYPE_MP2MP"),
+            (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP, "4001:db8:3c4d:17::"),
+            (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_SRC_IP_MASK, "ffff:ffff:ffff:ffff::"),
             (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP, "2001:db8:3c4d:15::"),
             (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP_MASK, "ffff:ffff:ffff:ffff::"),
             (self._p4rt_tunnel_decap_wrapper.SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID, self.vrf_state['entry_id']),
@@ -155,14 +161,15 @@ def test_TunnelDecapGroupModifyNotImplemented(self, dvs, testlog):
         self._set_up(dvs)
 
         # Create tunnel decap group
-        ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
+        src_ipv6 = "5001:db8:3c4d:7::&ffff:ffff:ffff:ffff::"
+        dst_ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
         action = "mark_for_tunnel_decap_and_set_vrf"
         vrf_id = "b4-traffic"
 
         attr_list_in_app_db = [(self._p4rt_tunnel_decap_wrapper.ACTION, action),
                                (util.prepend_param_field(
                                    self._p4rt_tunnel_decap_wrapper.VRF_ID), vrf_id)]
-        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(ipv6)
+        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(src_ipv6, dst_ipv6)
         self._p4rt_tunnel_decap_wrapper.set_app_db_entry(
             tunnel_decap_group_key, attr_list_in_app_db)
         util.verify_response(
@@ -185,15 +192,17 @@ def test_TunnelDecapGroupDeleteBeforeAddFails(self, dvs, testlog):
         # Initialize database connectors
         self._set_up(dvs)
 
-        ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
-
-        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(ipv6)
+        src_ipv6 = "3001:db8:3c4d:11::&ffff:ffff:ffff:ffff::"
+        dst_ipv6 = "2001:db8:3c4d:15::&ffff:ffff:ffff:ffff::"
+        tunnel_decap_group_key = self._p4rt_tunnel_decap_wrapper.generate_app_db_key(
+            src_ipv6, dst_ipv6)
 
         # Remove tunnel decap group fails
         self._p4rt_tunnel_decap_wrapper.remove_app_db_entry(
             tunnel_decap_group_key)
         util.verify_response(
             self._response_consumer, tunnel_decap_group_key, [], "SWSS_RC_NOT_FOUND",
             "[OrchAgent] Ipv6 tunnel termination table entry with key "
-            "'dst_ipv6_ip=2001:db8:3c4d:15:::dst_ipv6_mask=ffff:ffff:ffff:ffff::' "
+            "'dst_ipv6_ip=2001:db8:3c4d:15:::dst_ipv6_mask=ffff:ffff:ffff:ffff:::"
+            "src_ipv6_ip=3001:db8:3c4d:11:::src_ipv6_mask=ffff:ffff:ffff:ffff::' "
             "does not exist in tunnel decap group manager")