[code sync] Merge code from sonic-net/sonic-sairedis:202412 to 202503

.github/workflows/codeql-analysis.yml

@@ -16,7 +16,7 @@ on:
 jobs:
   analyze:
     name: Analyze
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     permissions:
       actions: read
       contents: read
@@ -55,11 +55,11 @@ jobs:
             libzmq3-dev \
             libzmq5 \
             swig4.0 \
-            libpython2.7-dev \
+            libpython3-dev \
             libgtest-dev \
             libgmock-dev \
-            libboost1.71-dev \
-            libboost-serialization1.71-dev \
+            libboost-dev \
+            libboost-serialization-dev \
             dh-exec \
             doxygen \
             cdbs \
@@ -69,8 +69,7 @@ jobs:
             autoconf-archive \
             uuid-dev \
             libjansson-dev \
-            nlohmann-json3-dev \
-            python
+            nlohmann-json3-dev
 
     - if: matrix.language == 'cpp'
       name: Build sonic-swss-common
@@ -79,7 +78,7 @@ jobs:
         git clone https://github.com/sonic-net/sonic-swss-common
         pushd sonic-swss-common
         ./autogen.sh
-        dpkg-buildpackage -rfakeroot -us -uc -b -j$(nproc)
+        dpkg-buildpackage -rfakeroot -us -uc -b -Pnoyangmod,nopython2 -j$(nproc)
         popd
         dpkg-deb -x libswsscommon_${SWSSCOMMON_VER}_amd64.deb $(dirname $GITHUB_WORKSPACE)
         dpkg-deb -x libswsscommon-dev_${SWSSCOMMON_VER}_amd64.deb $(dirname $GITHUB_WORKSPACE)

.gitmodules

@@ -2,4 +2,4 @@
 	path = SAI
 	url = https://github.com/opencomputeproject/SAI.git
 	ignore = dirty
-	branch = v1.3
+	branch = v1.16

configure.ac

@@ -267,11 +267,20 @@ AC_MSG_ERROR("SAI headers API version and library version mismatch")])],
 CXXFLAGS="$SAVED_FLAGS"
 ])])
 
-AM_COND_IF([SYNCD], [
-SAVED_FLAGS="$CXXFLAGS"
-CXXFLAGS="-Xlinker --no-as-needed -lsai -I$srcdir/SAI/inc -I$srcdir/SAI/experimental -I$srcdir/SAI/meta"
-AC_CHECK_FUNCS(sai_bulk_object_clear_stats sai_bulk_object_get_stats)
-CXXFLAGS="$SAVED_FLAGS"
+AM_COND_IF([SAIVS],
+[
+    AC_DEFINE([HAVE_SAI_BULK_OBJECT_CLEAR_STATS], [1], [])
+    AC_DEFINE([HAVE_SAI_BULK_OBJECT_GET_STATS], [1], [])
+    AC_DEFINE([HAVE_SAI_QUERY_STATS_ST_CAPABILITY], [1], [])
+    AC_DEFINE([HAVE_SAI_TAM_TELEMETRY_GET_DATA], [1], [])
+],
+[
+    AM_COND_IF([SYNCD], [
+    SAVED_FLAGS="$CXXFLAGS"
+    CXXFLAGS="-Xlinker --no-as-needed -lsai -I$srcdir/SAI/inc -I$srcdir/SAI/experimental -I$srcdir/SAI/meta"
+    AC_CHECK_FUNCS(sai_bulk_object_clear_stats sai_bulk_object_get_stats sai_query_stats_st_capability sai_tam_telemetry_get_data)
+    CXXFLAGS="$SAVED_FLAGS"
+    ])
 ])
 
 AC_DEFINE([SAIREDIS_GIT_REVISION],

lib/ClientSai.cpp

@@ -1060,6 +1060,58 @@ sai_status_t ClientSai::queryStatsCapability(
     return waitForQueryStatsCapabilityResponse(stats_capability);
 }
 
+sai_status_t ClientSai::waitForQueryStatsCapabilityResponse(
+        _Inout_ sai_stat_capability_list_t* stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    swss::KeyOpFieldsValuesTuple kco;
+
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_CAPABILITY_RESPONSE, kco);
+
+    if (status == SAI_STATUS_SUCCESS)
+    {
+        const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+        if (values.size() != 3)
+        {
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 3 value, received %zu", values.size());
+
+            return SAI_STATUS_FAILURE;
+        }
+
+        const std::string &stat_enum_str = fvValue(values[0]);
+        const std::string &stat_modes_str = fvValue(values[1]);
+        const uint32_t num_capabilities = std::stoi(fvValue(values[2]));
+
+        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', count = %d",
+                       stat_enum_str.c_str(), stat_modes_str.c_str(), num_capabilities);
+
+        stats_capability->count = num_capabilities;
+
+        sai_deserialize_stats_capability_list(stats_capability, stat_enum_str, stat_modes_str);
+    }
+    else if (status ==  SAI_STATUS_BUFFER_OVERFLOW)
+    {
+        const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+        if (values.size() != 1)
+        {
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 1 value, received %zu", values.size());
+
+            return SAI_STATUS_FAILURE;
+        }
+
+        const uint32_t num_capabilities = std::stoi(fvValue(values[0]));
+
+        SWSS_LOG_DEBUG("Received payload: count = %u", num_capabilities);
+
+        stats_capability->count = num_capabilities;
+    }
+
+    return status;
+}
+
 sai_status_t ClientSai::queryStatsStCapability(
     _In_ sai_object_id_t switchId,
     _In_ sai_object_type_t objectType,
@@ -1078,43 +1130,71 @@ sai_status_t ClientSai::queryStatsStCapability(
         return SAI_STATUS_INVALID_PARAMETER;
     }
 
-    // TODO: Fix me
+    if (stats_capability && stats_capability->list && (stats_capability->count))
+    {
+        // clear input list, since we use serialize to transfer values
+        for (uint32_t idx = 0; idx < stats_capability->count; idx++)
+        {
+            stats_capability->list[idx].capability.stat_enum = 0;
+            stats_capability->list[idx].capability.stat_modes = 0;
+            stats_capability->list[idx].minimal_polling_interval = 0;
+        }
+    }
 
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    const std::string listSize = std::to_string(stats_capability->count);
+
+    const std::vector<swss::FieldValueTuple> entry =
+        {
+            swss::FieldValueTuple("OBJECT_TYPE", objectTypeStr),
+            swss::FieldValueTuple("LIST_SIZE", listSize)};
+
+    SWSS_LOG_DEBUG(
+        "Query arguments: switch %s, object type: %s, count: %s",
+        switchIdStr.c_str(),
+        objectTypeStr.c_str(),
+        listSize.c_str());
+
+    // This query will not put any data into the ASIC view, just into the
+    // message queue
+
+    m_communicationChannel->set(switchIdStr, entry, REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_QUERY);
+
+    return waitForQueryStatsStCapabilityResponse(stats_capability);
 }
 
-sai_status_t ClientSai::waitForQueryStatsCapabilityResponse(
-        _Inout_ sai_stat_capability_list_t* stats_capability)
+sai_status_t ClientSai::waitForQueryStatsStCapabilityResponse(
+    _Inout_ sai_stat_st_capability_list_t *stats_capability)
 {
     SWSS_LOG_ENTER();
 
     swss::KeyOpFieldsValuesTuple kco;
 
-    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_CAPABILITY_RESPONSE, kco);
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_RESPONSE, kco);
 
     if (status == SAI_STATUS_SUCCESS)
     {
         const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
 
-        if (values.size() != 3)
+        if (values.size() != 4)
         {
-            SWSS_LOG_ERROR("Invalid response from syncd: expected 3 value, received %zu", values.size());
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 4 value, received %zu", values.size());
 
             return SAI_STATUS_FAILURE;
         }
 
         const std::string &stat_enum_str = fvValue(values[0]);
         const std::string &stat_modes_str = fvValue(values[1]);
-        const uint32_t num_capabilities = std::stoi(fvValue(values[2]));
+        const std::string &polling_interval_str = fvValue(values[2]);
+        const uint32_t num_capabilities = std::stoi(fvValue(values[3]));
 
-        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', count = %d",
-                       stat_enum_str.c_str(), stat_modes_str.c_str(), num_capabilities);
+        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', minimal_polling_intervals = '%s' count = %d",
+                       stat_enum_str.c_str(), stat_modes_str.c_str(), polling_interval_str.c_str(), num_capabilities);
 
         stats_capability->count = num_capabilities;
 
-        sai_deserialize_stats_capability_list(stats_capability, stat_enum_str, stat_modes_str);
+        sai_deserialize_stats_st_capability_list(stats_capability, stat_enum_str, stat_modes_str, polling_interval_str);
     }
-    else if (status ==  SAI_STATUS_BUFFER_OVERFLOW)
+    else if (status == SAI_STATUS_BUFFER_OVERFLOW)
     {
         const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
 

lib/ClientSai.h

@@ -305,7 +305,10 @@ namespace sairedis
             sai_status_t waitForQueryStatsCapabilityResponse(
                     _Inout_ sai_stat_capability_list_t* stats_capability);
 
-        private:
+            sai_status_t waitForQueryStatsStCapabilityResponse(
+                _Inout_ sai_stat_st_capability_list_t *stats_capability);
+
+    private:
 
             void handleNotification(
                     _In_ const std::string &name,

lib/Recorder.cpp

@@ -388,6 +388,24 @@ void Recorder::recordQueryStatsCapabilityResponse(
     recordLine("Q|stats_capability|" + sai_serialize_status(status) + "|" + arguments);
 }
 
+void Recorder::recordQueryStatsStCapability(
+    _In_ const std::string &key,
+    _In_ const std::vector<swss::FieldValueTuple> &arguments)
+{
+    SWSS_LOG_ENTER();
+
+    recordLine("q|stats_st_capability|" + key + "|" + Globals::joinFieldValues(arguments));
+}
+
+void Recorder::recordQueryStatsStCapabilityResponse(
+    _In_ sai_status_t status,
+    _In_ const std::string &arguments)
+{
+    SWSS_LOG_ENTER();
+
+    recordLine("Q|stats_st_capability|" + sai_serialize_status(status) + "|" + arguments);
+}
+
 void Recorder::recordNotifySyncd(
         _In_ const std::string& key)
 {
@@ -1217,6 +1235,66 @@ void Recorder::recordQueryStatsCapabilityResponse(
     recordQueryStatsCapabilityResponse(status, str_stats_list);
 }
 
+void Recorder::recordQueryStatsStCapability(
+    _In_ sai_object_id_t switch_id,
+    _In_ sai_object_type_t object_type,
+    _Inout_ sai_stat_st_capability_list_t *stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    auto key = sai_serialize_object_type(SAI_OBJECT_TYPE_SWITCH) + ":" + sai_serialize_object_id(switch_id);
+
+    auto object_type_str = sai_serialize_object_type(object_type);
+    const std::string list_size = std::to_string(stats_capability->count);
+    const std::vector<swss::FieldValueTuple> values =
+        {
+            swss::FieldValueTuple("OBJECT_TYPE", object_type_str),
+            swss::FieldValueTuple("LIST_SIZE", list_size)};
+
+    SWSS_LOG_DEBUG("Query arguments: switch %s, object_type: %s, count: %s",
+                   key.c_str(),
+                   object_type_str.c_str(),
+                   list_size.c_str());
+
+    recordQueryStatsStCapability(key, values);
+}
+
+void Recorder::recordQueryStatsStCapabilityResponse(
+    _In_ sai_status_t status,
+    _In_ sai_object_type_t objectType,
+    _In_ const sai_stat_st_capability_list_t *stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    std::string str_stats_list;
+
+    auto meta = sai_metadata_get_object_type_info(objectType);
+
+    if (meta == NULL)
+    {
+        SWSS_LOG_ERROR("Failed to find object metadata: object type %s",
+                       sai_serialize_object_type(objectType).c_str());
+
+        return;
+    }
+
+    if (meta->statenum == NULL)
+    {
+        SWSS_LOG_ERROR("%s does not support stats", meta->objecttypename);
+
+        return;
+    }
+
+    bool countOnly = (status == SAI_STATUS_BUFFER_OVERFLOW);
+
+    if (status == SAI_STATUS_SUCCESS || status == SAI_STATUS_BUFFER_OVERFLOW)
+    {
+        str_stats_list = sai_serialize_stats_st_capability_list(*stats_capability, meta->statenum, countOnly);
+    }
+
+    recordQueryStatsStCapabilityResponse(status, str_stats_list);
+}
+
 void Recorder::recordNotifySyncd(
         _In_ sai_object_id_t switchId,
         _In_ sai_redis_notify_syncd_t redisNotifySyncd)

lib/Recorder.h

@@ -316,6 +316,16 @@ namespace sairedis
                     _In_ sai_object_type_t objectType,
                     _In_ const sai_stat_capability_list_t *stats_capability);
 
+            void recordQueryStatsStCapability(
+                _In_ sai_object_id_t switch_id,
+                _In_ sai_object_type_t object_type,
+                _Inout_ sai_stat_st_capability_list_t *stats_capability);
+
+            void recordQueryStatsStCapabilityResponse(
+                _In_ sai_status_t status,
+                _In_ sai_object_type_t objectType,
+                _In_ const sai_stat_st_capability_list_t *stats_capability);
+
             // TODO move to private
             void recordQueryAttributeCapability(
                     _In_ const std::string& key,
@@ -349,7 +359,15 @@ namespace sairedis
                     _In_ sai_status_t status,
                     _In_ const std::string& arguments);
 
-        public: // SAI notifications
+            void recordQueryStatsStCapability(
+                    _In_ const std::string &key,
+                    _In_ const std::vector<swss::FieldValueTuple> &arguments);
+
+            void recordQueryStatsStCapabilityResponse(
+                    _In_ sai_status_t status,
+                    _In_ const std::string &arguments);
+
+    public: // SAI notifications
 
             void recordNotification(
                     _In_ const std::string &name,