[code sync] Merge code from sonic-net/sonic-sairedis:202511 to 202603

meta/SaiSerialize.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 #include <climits>
 #include <algorithm>
+#include <cmath>
 #include <unordered_map>
 
 #include <arpa/inet.h>
@@ -1812,11 +1813,13 @@ std::string sai_serialize_port_snr_list(
         return j.dump();
     }
 
-    // Create dictionary format: {"0": 3712, "1": 3840, ...}
+    // Convert raw U16 SNR (in 1/256 dB units) to dB value per SAI definition
+    // e.g., raw value 5248 represents 5248/256 = 20.50 dB (Two decimal precision)
     for (uint32_t i = 0; i < snr_list.count; ++i)
     {
         std::string lane_key = std::to_string(snr_list.list[i].lane);
-        j[lane_key] = snr_list.list[i].snr;
+        double dB = static_cast<double>(snr_list.list[i].snr) / 256.0;
+        j[lane_key] = std::round(dB * 100.0) / 100.0;
     }
 
     return j.dump();
@@ -4616,14 +4619,15 @@ void sai_deserialize_port_snr_list(
         uint32_t idx = 0;
         for (auto it = j.begin(); it != j.end(); ++it, ++idx)
         {
-            if (!it.value().is_number_unsigned())
+            if (!it.value().is_number())
             {
                 SWSS_LOG_ERROR("Invalid SNR value type for lane %s", it.key().c_str());
                 continue;
             }
 
+            // Convert dB value back to raw U16 (in 1/256 dB units) per SAI definition
             snr_list.list[idx].lane = static_cast<uint32_t>(std::stoul(it.key()));
-            snr_list.list[idx].snr = it.value().get<sai_uint16_t>();
+            snr_list.list[idx].snr = static_cast<sai_uint16_t>(std::round(it.value().get<double>() * 256.0));
         }
     }
     catch (const json::parse_error& e)

unittest/meta/TestSaiSerialize.cpp

@@ -192,7 +192,7 @@ TEST(SaiSerialize, sai_serialize_port_snr_list)
 
             auto s = sai_serialize_attr_value(*meta, attr, false);
 
-            std::string expected = "{\"0\":3712,\"1\":3840,\"2\":4160}";
+            std::string expected = "{\"0\":14.5,\"1\":15.0,\"2\":16.25}";
             EXPECT_EQ(s, expected);
 
         }
@@ -201,7 +201,7 @@ TEST(SaiSerialize, sai_serialize_port_snr_list)
 
 TEST(SaiSerialize, sai_deserialize_port_snr_list)
 {
-    std::string json_str = R"({"0":3712,"1":4032})";
+    std::string json_str = R"({"0":14.5,"1":15.75})";
 
     sai_port_snr_list_t snr_list;
     memset(&snr_list, 0, sizeof(snr_list));

unittest/syncd/TestPortPhyAttr.cpp

@@ -18,6 +18,7 @@
 #include <string>
 #include <gtest/gtest.h>
 #include <memory>
+#include <cmath>
 
 using namespace saimeta;
 using namespace sairedis;
@@ -247,16 +248,17 @@ TEST_F(TestPortPhyAttr, CollectDataAndValidateCountersDB)
 
     std::cout << "Actual rx_snr value: " << rxSnrValue << std::endl;
 
-    // Lane key is string, SNR value is number (no quotes around value)
-    // Validate all lanes (0-7) with SNR values: 145, 150, 155, 160, 165, 170, 175, 180
+    // Lane key is string, SNR value is dB (raw_value / 256.0, rounded to 2 decimals)
+    // Validate all lanes (0-7) with raw SNR values: 145, 150, 155, 160, 165, 170, 175, 180
+    // Converted to dB: 0.57, 0.59, 0.61, 0.63, 0.64, 0.66, 0.68, 0.7
     for (uint32_t lane = 0; lane < MAX_LANES_PER_PORT; lane++) {
-        uint32_t expected_snr = 145 + (lane * 5);
+        uint32_t raw_snr = 145 + (lane * 5);
+        double dB = std::round(static_cast<double>(raw_snr) / 256.0 * 100.0) / 100.0;
         std::ostringstream expected_entry;
-        expected_entry << "\"" << lane << "\":" << expected_snr;
+        expected_entry << "\"" << lane << "\":" << dB;
 
         EXPECT_TRUE(rxSnrValue.find(expected_entry.str()) != std::string::npos)
-            << "Lane " << lane << " SNR should be " << expected_snr
-            << " in format \"" << lane << "\":" << expected_snr
+            << "Lane " << lane << " SNR should be " << dB << " dB (raw " << raw_snr << ")"
             << "\nActual full value: " << rxSnrValue
             << "\nLooking for: " << expected_entry.str();
     }

vslib/SwitchStateBase.cpp

@@ -4317,6 +4317,24 @@ sai_status_t SwitchStateBase::queryTamBindPointTypeCapability(
     return SAI_STATUS_SUCCESS;
 }
 
+sai_status_t SwitchStateBase::queryIcmpEchoSessionStatsCountModeCapability(
+                   _Inout_ sai_s32_list_t *enum_values_capability)
+{
+    SWSS_LOG_ENTER();
+
+    if (enum_values_capability->count < 2)
+    {
+        enum_values_capability->count = 2;
+        return SAI_STATUS_BUFFER_OVERFLOW;
+    }
+
+    enum_values_capability->count = 2;
+    enum_values_capability->list[0] = SAI_STATS_COUNT_MODE_PACKET_AND_BYTE;
+    enum_values_capability->list[1] = SAI_STATS_COUNT_MODE_PACKET;
+
+    return SAI_STATUS_SUCCESS;
+}
+
 sai_status_t SwitchStateBase::queryAttrEnumValuesCapability(
                               _In_ sai_object_id_t switch_id,
                               _In_ sai_object_type_t object_type,
@@ -4368,6 +4386,10 @@ sai_status_t SwitchStateBase::queryAttrEnumValuesCapability(
     {
         return queryTamBindPointTypeCapability(enum_values_capability);
     }
+    else if (object_type == SAI_OBJECT_TYPE_ICMP_ECHO_SESSION && attr_id == SAI_ICMP_ECHO_SESSION_ATTR_STATS_COUNT_MODE)
+    {
+        return queryIcmpEchoSessionStatsCountModeCapability(enum_values_capability);
+    }
 
     return SAI_STATUS_NOT_SUPPORTED;
 }

vslib/SwitchStateBase.h

@@ -785,6 +785,9 @@ namespace saivs
             virtual sai_status_t queryTamBindPointTypeCapability(
                                       _Inout_ sai_s32_list_t *enum_values_capability);
 
+            virtual sai_status_t queryIcmpEchoSessionStatsCountModeCapability(
+                                      _Inout_ sai_s32_list_t *enum_values_capability);
+
             virtual sai_status_t queryPortAutonegFecOverrideSupportCapability(
                                       _Out_ sai_attr_capability_t *attr_capability);
 

vslib/tests.cpp

@@ -809,6 +809,47 @@ void test_supported_obj_types()
 
 }
 
+void test_icmp_echo_session_stats_count_mode_capability()
+{
+    SWSS_LOG_ENTER();
+
+    sai_reinit();
+
+    sai_attribute_t attr;
+    sai_object_id_t switch_id;
+
+    attr.id = SAI_SWITCH_ATTR_INIT_SWITCH;
+    attr.value.booldata = true;
+
+    SUCCESS(sai_metadata_sai_switch_api->create_switch(&switch_id, 1, &attr));
+
+    int32_t small_list[1];
+    sai_s32_list_t enum_values_capability;
+    enum_values_capability.count = 1;
+    enum_values_capability.list = small_list;
+
+    ASSERT_TRUE(sai_query_attribute_enum_values_capability(
+            switch_id,
+            SAI_OBJECT_TYPE_ICMP_ECHO_SESSION,
+            SAI_ICMP_ECHO_SESSION_ATTR_STATS_COUNT_MODE,
+            &enum_values_capability) == SAI_STATUS_BUFFER_OVERFLOW);
+    ASSERT_TRUE(enum_values_capability.count == 2);
+
+    int32_t values[2];
+    enum_values_capability.count = 2;
+    enum_values_capability.list = values;
+
+    SUCCESS(sai_query_attribute_enum_values_capability(
+            switch_id,
+            SAI_OBJECT_TYPE_ICMP_ECHO_SESSION,
+            SAI_ICMP_ECHO_SESSION_ATTR_STATS_COUNT_MODE,
+            &enum_values_capability));
+
+    ASSERT_TRUE(enum_values_capability.count == 2);
+    ASSERT_TRUE(enum_values_capability.list[0] == SAI_STATS_COUNT_MODE_PACKET_AND_BYTE);
+    ASSERT_TRUE(enum_values_capability.list[1] == SAI_STATS_COUNT_MODE_PACKET);
+}
+
 int main()
 {
     swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG);
@@ -837,6 +878,8 @@ int main()
 
     test_set_stats_via_redis();
 
+    test_icmp_echo_session_stats_count_mode_capability();
+
     // make proper uninitialize to close unittest thread
     sai_api_uninitialize();