SwitchStateBase.cpp

#include "SwitchStateBase.h"

#include "swss/logger.h"
#include "meta/sai_serialize.h"
#include "meta/NotificationTamTelTypeConfigChange.h"
#include "meta/NotificationSwitchMacsecPostStatus.h"
#include "meta/NotificationMacsecPostStatus.h"
#include "EventPayloadNotification.h"

#include <net/if.h>
#include <unistd.h>

#include <algorithm>
#include <random>

#define SAI_VS_MAX_PORTS 1024

using namespace saivs;

SwitchStateBase::SwitchStateBase(
        _In_ sai_object_id_t switch_id,
        _In_ std::shared_ptr<RealObjectIdManager> manager,
        _In_ std::shared_ptr<SwitchConfig> config):
    SwitchState(switch_id, config),
    m_realObjectIdManager(manager)
{
    SWSS_LOG_ENTER();

    m_macsecManager.cleanup_macsec_device();
}

SwitchStateBase::SwitchStateBase(
        _In_ sai_object_id_t switch_id,
        _In_ std::shared_ptr<RealObjectIdManager> manager,
        _In_ std::shared_ptr<SwitchConfig> config,
        _In_ std::shared_ptr<WarmBootState> warmBootState):
    SwitchState(switch_id, config),
    m_realObjectIdManager(manager)
{
    SWSS_LOG_ENTER();

    m_macsecManager.cleanup_macsec_device();

    if (warmBootState)
    {
        for (auto& kvp: warmBootState->m_objectHash)
        {
            // we write only existing ones, since base constructor
            // created empty entries for non existing object types
            m_objectHash[kvp.first] = kvp.second;
        }

        if (m_switchConfig->m_useTapDevice)
        {
            m_fdb_info_set = warmBootState->m_fdbInfoSet;

            // TODO populate m_hostif_info_map - need to be able to remove port after warm boot
            // should be auto populated vs_recreate_hostif_tap_interfaces on create_switch
        }
    }
}

SwitchStateBase::~SwitchStateBase()
{
    SWSS_LOG_ENTER();

    m_macsecManager.cleanup_macsec_device();
}

sai_status_t SwitchStateBase::create(
        _In_ sai_object_type_t object_type,
        _Out_ sai_object_id_t *object_id,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    if (object_type == SAI_OBJECT_TYPE_SWITCH)
    {
        SWSS_LOG_THROW("this method can't be used to create switch");
    }

    *object_id = m_realObjectIdManager->allocateNewObjectId(object_type, switch_id);

    auto sid = sai_serialize_object_id(*object_id);

    return create_internal(object_type, sid, switch_id, attr_count, attr_list);
}

uint32_t SwitchStateBase::getNewDebugCounterIndex()
{
    SWSS_LOG_ENTER();

    for (uint32_t i = 0; i < maxDebugCounters; i++)
    {
        if (m_indices.find(i) == m_indices.end())
        {
            m_indices.insert(i);
            return i;
        }
    }

    return UINT32_MAX;
}

sai_status_t SwitchStateBase::createDebugCounter(
        _In_ sai_object_id_t object_id,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    auto index = getNewDebugCounterIndex();

    if (index > maxDebugCounters)
    {
        SWSS_LOG_ERROR("Cannot create more than %d debug counters", maxDebugCounters);

        return SAI_STATUS_FAILURE;
    }

    auto sid = sai_serialize_object_id(object_id);

    CHECK_STATUS(create_internal(SAI_OBJECT_TYPE_DEBUG_COUNTER, sid, switch_id, attr_count, attr_list));

    sai_attribute_t attr;

    attr.id = SAI_DEBUG_COUNTER_ATTR_INDEX;
    attr.value.u32 = index;

    return set(SAI_OBJECT_TYPE_DEBUG_COUNTER, sid, &attr);
}

sai_status_t SwitchStateBase::create(
        _In_ sai_object_type_t object_type,
        _In_ const std::string &serializedObjectId,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    if (object_type == SAI_OBJECT_TYPE_DEBUG_COUNTER)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createDebugCounter(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_PORT)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createPort(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_HOSTIF)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createHostif(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_MACSEC_PORT)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createMACsecPort(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_MACSEC_SC)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createMACsecSC(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_MACSEC_SA)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createMACsecSA(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_NEIGHBOR_ENTRY && m_system_port_list.size())
    {
        // Neighbor entry programming for VOQ systems
        return createVoqSystemNeighborEntry(serializedObjectId, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_TAM)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createTam(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_TAM_TELEMETRY)
    {
        sai_object_id_t object_id;
        sai_deserialize_object_id(serializedObjectId, object_id);
        return createTamTelemetry(object_id, switch_id, attr_count, attr_list);
    }

    if (object_type == SAI_OBJECT_TYPE_MACSEC)
    {
        bool enable_post = false;
        std::string direction = "unknown";
        for (uint32_t idx = 0; idx < attr_count; ++idx)
        {
            sai_attribute_t attr = attr_list[idx];
            if (attr.id == SAI_MACSEC_ATTR_ENABLE_POST && attr.value.booldata)
            {
                enable_post = true;
            }
            else if(attr.id == SAI_MACSEC_ATTR_DIRECTION &&
                    attr.value.s32 == SAI_MACSEC_DIRECTION_EGRESS)
            {
                direction = "egress";
            }
            else if(attr.id == SAI_MACSEC_ATTR_DIRECTION &&
                    attr.value.s32 == SAI_MACSEC_DIRECTION_INGRESS)
            {
                direction = "ingress";
            }
        }

        if (enable_post && direction != "unknown")
        {
            sai_object_id_t macsec_id;
            sai_deserialize_object_id(serializedObjectId, macsec_id);
            std::string config = (direction == "ingress") ? VS_SAI_FIPS_INGRESS_MACSEC_POST_STATUS_NOTIFY :
                VS_SAI_FIPS_EGRESS_MACSEC_POST_STATUS_NOTIFY;
            process_fips_post_config(config, macsec_id);
        }
    }

    return create_internal(object_type, serializedObjectId, switch_id, attr_count, attr_list);
}

sai_status_t SwitchStateBase::create_internal(
        _In_ sai_object_type_t object_type,
        _In_ const std::string &serializedObjectId,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    auto &objectHash = m_objectHash.at(object_type);

    if (m_switchConfig->m_resourceLimiter)
    {
        size_t limit = m_switchConfig->m_resourceLimiter->getObjectTypeLimit(object_type);

        if (objectHash.size() >= limit)
        {
            SWSS_LOG_ERROR("too many %s, created %zu is resource limit",
                    sai_serialize_object_type(object_type).c_str(),
                    limit);

            return SAI_STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    auto it = objectHash.find(serializedObjectId);

    if (object_type != SAI_OBJECT_TYPE_SWITCH)
    {
        /*
         * Switch is special, and object is already created by init.
         *
         * XXX revisit this.
         */

        if (it != objectHash.end())
        {
            SWSS_LOG_ERROR("create failed, object already exists, object type: %s: id: %s",
                    sai_serialize_object_type(object_type).c_str(),
                    serializedObjectId.c_str());

            return SAI_STATUS_ITEM_ALREADY_EXISTS;
        }
    }

    if (objectHash.find(serializedObjectId) == objectHash.end())
    {
        /*
         * Number of attributes may be zero, so see if actual entry was created
         * with empty hash.
         */

        objectHash[serializedObjectId] = {};
    }

    for (uint32_t i = 0; i < attr_count; ++i)
    {
        auto a = std::make_shared<SaiAttrWrap>(object_type, &attr_list[i]);

        objectHash[serializedObjectId][a->getAttrMetadata()->attridname] = a;
    }

    if (object_type == SAI_OBJECT_TYPE_SWITCH)
    {
        // Set POST state.
        CHECK_STATUS(process_fips_post_config(VS_SAI_FIPS_SWITCH_MACSEC_POST_STATUS_QUERY));
    }

    return SAI_STATUS_SUCCESS;
}

void SwitchStateBase::releaseDebugCounterIndex(
        _In_ uint32_t index)
{
    SWSS_LOG_ENTER();

    m_indices.erase(index);
}

sai_status_t SwitchStateBase::remove(
        _In_ sai_object_type_t object_type,
        _In_ sai_object_id_t objectId)
{
    SWSS_LOG_ENTER();

    auto sid = sai_serialize_object_id(objectId);

    return remove(object_type, sid);
}

sai_status_t SwitchStateBase::removeDebugCounter(
        _In_ sai_object_id_t objectId)
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    attr.id = SAI_DEBUG_COUNTER_ATTR_INDEX;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_DEBUG_COUNTER, objectId, 1, &attr));

    auto sid = sai_serialize_object_id(objectId);

    CHECK_STATUS(remove_internal(SAI_OBJECT_TYPE_DEBUG_COUNTER, sid));

    releaseDebugCounterIndex(attr.value.u32);

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::createPort(
        _In_ sai_object_id_t object_id,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    auto sid = sai_serialize_object_id(object_id);

    CHECK_STATUS(create_internal(SAI_OBJECT_TYPE_PORT, sid, switch_id, attr_count, attr_list));

    return create_port_dependencies(object_id);
}

sai_status_t SwitchStateBase::removePort(
        _In_ sai_object_id_t objectId)
{
    SWSS_LOG_ENTER();

    if (!isPortReadyToBeRemove(objectId))
    {
        SWSS_LOG_ERROR("port %s still have some active dependencies, can't remove",
                sai_serialize_object_id(objectId).c_str());

        return SAI_STATUS_OBJECT_IN_USE;
    }

    auto dep = getPortDependencies(objectId);

    auto sid = sai_serialize_object_id(objectId);

    CHECK_STATUS(remove_internal(SAI_OBJECT_TYPE_PORT, sid));

    SWSS_LOG_NOTICE("port %s was successfully removed, removing depending objects now",
            sai_serialize_object_id(objectId).c_str());

    for (auto oid: dep)
    {
        // meta_sai_remove_oid automatically removed related oids internally
        // so we just need to execute remove for virtual switch db

        auto status = remove(objectTypeQuery(oid), oid);

        if (status != SAI_STATUS_SUCCESS)
        {
            // we can't continue, there is a bug somewhere if we can't remove
            // port related objects: queues, ipgs, sg

            SWSS_LOG_THROW("FATAL: failed to removed port related oid: %s: %s, bug!",
                    sai_serialize_object_type(objectTypeQuery(oid)).c_str(),
                    sai_serialize_object_id(oid).c_str());
        }
    }

    SWSS_LOG_NOTICE("successfully removed all %zu port related objects", dep.size());

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::remove(
        _In_ sai_object_type_t object_type,
        _In_ const std::string &serializedObjectId)
{
    SWSS_LOG_ENTER();

    if (object_type == SAI_OBJECT_TYPE_DEBUG_COUNTER)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removeDebugCounter(objectId);
    }

    if (object_type == SAI_OBJECT_TYPE_PORT)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removePort(objectId);
    }

    if (object_type == SAI_OBJECT_TYPE_HOSTIF)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removeHostif(objectId);
    }

    if (object_type == SAI_OBJECT_TYPE_MACSEC_PORT)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removeMACsecPort(objectId);
    }
    else if (object_type == SAI_OBJECT_TYPE_MACSEC_SC)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removeMACsecSC(objectId);
    }
    else if (object_type == SAI_OBJECT_TYPE_MACSEC_SA)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return removeMACsecSA(objectId);
    }

    return remove_internal(object_type, serializedObjectId);
}

sai_status_t SwitchStateBase::remove_internal(
        _In_ sai_object_type_t object_type,
        _In_ const std::string &serializedObjectId)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("removing object: %s", serializedObjectId.c_str());

    auto &objectHash = m_objectHash.at(object_type);

    auto it = objectHash.find(serializedObjectId);

    if (it == objectHash.end())
    {
        SWSS_LOG_ERROR("not found %s:%s",
                sai_serialize_object_type(object_type).c_str(),
                serializedObjectId.c_str());

        return SAI_STATUS_ITEM_NOT_FOUND;
    }

    objectHash.erase(it);

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::setPort(
        _In_ sai_object_id_t portId,
        _In_ const sai_attribute_t* attr)
{
    SWSS_LOG_ENTER();

    if (attr && attr->id == SAI_PORT_ATTR_ADMIN_STATE && m_switchConfig->m_useTapDevice)
    {
        bool up = attr->value.booldata;

        // find corresponding host if interface and bring it down !
        for (auto& kvp: m_hostif_info_map)
        {
            auto tapname = kvp.first;

            if (kvp.second->m_portId == portId)
            {
                std::string vethname = vs_get_veth_name(tapname, portId);

                if (ifup(vethname.c_str(), portId, up, false))
                {
                    SWSS_LOG_ERROR("if admin %s failed on %s failed: %s", (up ? "UP" : "DOWN"), vethname.c_str(),  strerror(errno));

                    return SAI_STATUS_FAILURE;
                }

                SWSS_LOG_NOTICE("if admin %s success on %s", (up ? "UP" : "DOWN"), vethname.c_str());

                break;
            }
        }
    }
    else if (attr && attr->id == SAI_PORT_ATTR_MTU && m_switchConfig->m_useTapDevice)
    {
        uint32_t mtu = attr->value.u32;

        std::string name;

        if (getTapNameFromPortId(portId, name))
        {
            SWSS_LOG_INFO("setting new MTU: %d on %s", mtu, name.c_str());

            std::string vname = vs_get_veth_name(name, portId);

            if (vs_set_dev_mtu(vname.c_str(), mtu) < 0)
            {
                SWSS_LOG_ERROR("failed to set MTU on portId %s",
                        sai_serialize_object_id(portId).c_str());
                return SAI_STATUS_FAILURE;
            }
        }
    }

    auto sid = sai_serialize_object_id(portId);

    return set_internal(SAI_OBJECT_TYPE_PORT, sid, attr);
}

sai_status_t SwitchStateBase::setAclEntry(
        _In_ sai_object_id_t entry_id,
        _In_ const sai_attribute_t* attr)
{
    SWSS_LOG_ENTER();

    if (attr && attr->id == SAI_ACL_ENTRY_ATTR_ACTION_MACSEC_FLOW)
    {
        return setAclEntryMACsecFlowActive(entry_id, attr);
    }

    auto sid = sai_serialize_object_id(entry_id);

    return set_internal(SAI_OBJECT_TYPE_ACL_ENTRY, sid, attr);
}

sai_status_t SwitchStateBase::setTamTelType(
    _In_ sai_object_id_t tam_tel_type_id,
    _In_ const sai_attribute_t *attr)
{
    SWSS_LOG_ENTER();

    if (attr->id == SAI_TAM_TEL_TYPE_ATTR_STATE && attr->value.s32 == SAI_TAM_TEL_TYPE_STATE_CREATE_CONFIG)
    {
        send_tam_tel_type_config_change(tam_tel_type_id);
    }

    auto sid = sai_serialize_object_id(tam_tel_type_id);

    return set_internal(SAI_OBJECT_TYPE_TAM_TEL_TYPE, sid, attr);
}

sai_status_t SwitchStateBase::set(
        _In_ sai_object_type_t objectType,
        _In_ const std::string &serializedObjectId,
        _In_ const sai_attribute_t* attr)
{
    SWSS_LOG_ENTER();

    if (objectType == SAI_OBJECT_TYPE_PORT)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return setPort(objectId, attr);
    }

    if (objectType == SAI_OBJECT_TYPE_ACL_ENTRY)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return setAclEntry(objectId, attr);
    }

    if (objectType == SAI_OBJECT_TYPE_MACSEC_SA)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return setMACsecSA(objectId, attr);
    }

    if (objectType == SAI_OBJECT_TYPE_TAM_TEL_TYPE)
    {
        sai_object_id_t objectId;
        sai_deserialize_object_id(serializedObjectId, objectId);
        return setTamTelType(objectId, attr);
    }

    return set_internal(objectType, serializedObjectId, attr);
}

sai_status_t SwitchStateBase::set_internal(
        _In_ sai_object_type_t objectType,
        _In_ const std::string &serializedObjectId,
        _In_ const sai_attribute_t* attr)
{
    SWSS_LOG_ENTER();

    auto it = m_objectHash.at(objectType).find(serializedObjectId);

    if (it == m_objectHash.at(objectType).end())
    {
        SWSS_LOG_ERROR("not found %s:%s",
                sai_serialize_object_type(objectType).c_str(),
                serializedObjectId.c_str());

        return SAI_STATUS_ITEM_NOT_FOUND;
    }

    auto &attrHash = it->second;

    auto a = std::make_shared<SaiAttrWrap>(objectType, attr);

    // set have only one attribute
    attrHash[a->getAttrMetadata()->attridname] = a;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set(
        _In_ sai_object_type_t objectType,
        _In_ sai_object_id_t objectId,
        _In_ const sai_attribute_t* attr)
{
    SWSS_LOG_ENTER();

    auto sid = sai_serialize_object_id(objectId);

    return set(objectType, sid, attr);
}

sai_status_t SwitchStateBase::get(
        _In_ sai_object_type_t object_type,
        _In_ sai_object_id_t object_id,
        _In_ uint32_t attr_count,
        _Out_ sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    auto sid = sai_serialize_object_id(object_id);

    return get(object_type, sid, attr_count, attr_list);
}

sai_status_t SwitchStateBase::get(
        _In_ sai_object_type_t objectType,
        _In_ const std::string &serializedObjectId,
        _In_ uint32_t attr_count,
        _Out_ sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    if (objectType == SAI_OBJECT_TYPE_SWITCH)
    {
        for (uint32_t idx = 0; idx < attr_count; ++idx)
        {
            sai_attr_id_t id = attr_list[idx].id;
            auto meta = sai_metadata_get_attr_metadata(objectType, id);
            SWSS_LOG_NOTICE("get switch attr: %s", meta->attridname);
        }
    }

    const auto &objectHash = m_objectHash.at(objectType);

    auto it = objectHash.find(serializedObjectId);

    if (it == objectHash.end())
    {
        SWSS_LOG_ERROR("not found %s:%s",
                sai_serialize_object_type(objectType).c_str(),
                serializedObjectId.c_str());

        return SAI_STATUS_ITEM_NOT_FOUND;
    }

    /*
     * We need reference here since we can potentially update attr hash for RO
     * object.
     */

    auto& attrHash = it->second;

    /*
     * Some of the list query maybe for length, so we can't do
     * normal serialize, maybe with count only.
     */

    sai_status_t final_status = SAI_STATUS_SUCCESS;

    for (uint32_t idx = 0; idx < attr_count; ++idx)
    {
        sai_attr_id_t id = attr_list[idx].id;

        auto meta = sai_metadata_get_attr_metadata(objectType, id);

        if (meta == NULL)
        {
            SWSS_LOG_ERROR("failed to find attribute %d for %s:%s", id,
                    sai_serialize_object_type(objectType).c_str(),
                    serializedObjectId.c_str());

            return SAI_STATUS_FAILURE;
        }

        sai_status_t status;

        if (SAI_HAS_FLAG_READ_ONLY(meta->flags))
        {
            /*
             * Read only attributes may require recalculation.
             * Metadata makes sure that non object id's can't have
             * read only attributes. So here is definitely OID.
             */

            sai_object_id_t oid;
            sai_deserialize_object_id(serializedObjectId, oid);

            status = refresh_read_only(meta, oid);

            if (status != SAI_STATUS_SUCCESS)
            {
                SWSS_LOG_INFO("%s read only not implemented on %s",
                        meta->attridname,
                        serializedObjectId.c_str());

                return status;
            }
        }

        auto ait = attrHash.find(meta->attridname);

        if (ait == attrHash.end())
        {
            SWSS_LOG_WARN("%s not implemented on %s",
                    meta->attridname,
                    serializedObjectId.c_str());

            return SAI_STATUS_NOT_IMPLEMENTED;
        }

        auto attr = ait->second->getAttr();

        status = transfer_attributes(objectType, 1, attr, &attr_list[idx], false);

        if (status == SAI_STATUS_BUFFER_OVERFLOW)
        {
            /*
             * This is considered partial success, since we get correct list
             * length.  Note that other items ARE processes on the list.
             */

            SWSS_LOG_NOTICE("BUFFER_OVERFLOW %s: %s",
                    serializedObjectId.c_str(),
                    meta->attridname);

            /*
             * We still continue processing other attributes for get as long as
             * we only will be getting buffer overflow error.
             */

            final_status = status;
            continue;
        }

        if (status != SAI_STATUS_SUCCESS)
        {
            // all other errors

            SWSS_LOG_ERROR("get failed %s: %s: %s",
                    serializedObjectId.c_str(),
                    meta->attridname,
                    sai_serialize_status(status).c_str());

            return status;
        }

        if (objectType == SAI_OBJECT_TYPE_SWITCH &&
            id == SAI_SWITCH_ATTR_MACSEC_POST_STATUS && attr_list[idx].value.booldata)
        {
            // Orchagent is retrieving POST status now. Send switch POST status notification.
            process_fips_post_config(VS_SAI_FIPS_SWITCH_MACSEC_POST_STATUS_NOTIFY);
        }

    }

    return final_status;
}

sai_status_t SwitchStateBase::bulkCreate(
        _In_ sai_object_id_t switch_id,
        _In_ sai_object_type_t object_type,
        _In_ const std::vector<std::string> &serialized_object_ids,
        _In_ const uint32_t *attr_count,
        _In_ const sai_attribute_t **attr_list,
        _In_ sai_bulk_op_error_mode_t mode,
        _Out_ sai_status_t *object_statuses)
{
    SWSS_LOG_ENTER();

    uint32_t object_count = (uint32_t) serialized_object_ids.size();

    if (!object_count || !attr_count || !attr_list || !object_statuses)
    {
        SWSS_LOG_ERROR("Invalid arguments");
        return SAI_STATUS_FAILURE;
    }

    sai_status_t status = SAI_STATUS_SUCCESS;
    uint32_t it;

    for (it = 0; it < object_count; it++)
    {
        object_statuses[it] = create(object_type, serialized_object_ids[it], switch_id, attr_count[it], attr_list[it]);

        if (object_statuses[it] != SAI_STATUS_SUCCESS)
        {
            SWSS_LOG_ERROR("Failed to create object with type = %u", object_type);

            status = SAI_STATUS_FAILURE;

            if (mode == SAI_BULK_OP_ERROR_MODE_STOP_ON_ERROR)
            {
                break;
            }
        }
    }

    while (++it < object_count)
    {
        object_statuses[it] = SAI_STATUS_NOT_EXECUTED;
    }

    return status;
}

sai_status_t SwitchStateBase::bulkRemove(
        _In_ sai_object_type_t object_type,
        _In_ const std::vector<std::string> &serialized_object_ids,
        _In_ sai_bulk_op_error_mode_t mode,
        _Out_ sai_status_t *object_statuses)
{
    SWSS_LOG_ENTER();

    uint32_t object_count = (uint32_t) serialized_object_ids.size();

    if (!object_count || !object_statuses)
    {
        SWSS_LOG_ERROR("Invalid arguments");
        return SAI_STATUS_FAILURE;
    }

    sai_status_t status = SAI_STATUS_SUCCESS;
    uint32_t it;

    for (it = 0; it < object_count; it++)
    {
        object_statuses[it] = remove(object_type, serialized_object_ids[it]);

        if (object_statuses[it] != SAI_STATUS_SUCCESS)
        {
            SWSS_LOG_ERROR("Failed to remove object with type = %u", object_type);

            status = SAI_STATUS_FAILURE;

            if (mode == SAI_BULK_OP_ERROR_MODE_STOP_ON_ERROR)
            {
                break;
            }
        }
    }

    while (++it < object_count)
    {
        object_statuses[it] = SAI_STATUS_NOT_EXECUTED;
    }

    return status;
}

sai_status_t SwitchStateBase::bulkSet(
        _In_ sai_object_type_t object_type,
        _In_ const std::vector<std::string> &serialized_object_ids,
        _In_ const sai_attribute_t *attr_list,
        _In_ sai_bulk_op_error_mode_t mode,
        _Out_ sai_status_t *object_statuses)
{
    SWSS_LOG_ENTER();

    uint32_t object_count = (uint32_t) serialized_object_ids.size();

    if (!object_count || !attr_list || !object_statuses)
    {
        SWSS_LOG_ERROR("Invalid arguments");
        return SAI_STATUS_FAILURE;
    }

    sai_status_t status = SAI_STATUS_SUCCESS;
    uint32_t it;

    for (it = 0; it < object_count; it++)
    {
        object_statuses[it] = set_internal(object_type, serialized_object_ids[it], &attr_list[it]);

        if (object_statuses[it] != SAI_STATUS_SUCCESS)
        {
            SWSS_LOG_ERROR("Failed to set attribute for object with type = %u", object_type);

            status = SAI_STATUS_FAILURE;

            if (mode == SAI_BULK_OP_ERROR_MODE_STOP_ON_ERROR)
            {
                break;
            }
        }
    }

    while (++it < object_count)
    {
        object_statuses[it] = SAI_STATUS_NOT_EXECUTED;
    }

    return status;
}

sai_status_t SwitchStateBase::bulkGet(
        _In_ sai_object_type_t object_type,
        _In_ const std::vector<std::string> &serialized_object_ids,
        _In_ const uint32_t *attr_count,
        _Inout_ sai_attribute_t **attr_list,
        _In_ sai_bulk_op_error_mode_t mode,
        _Out_ sai_status_t *object_statuses)
{
    SWSS_LOG_ENTER();

    uint32_t it;
    uint32_t object_count = (uint32_t) serialized_object_ids.size();
    sai_status_t status = SAI_STATUS_SUCCESS;

    if (!object_count || !attr_list || !attr_count || !object_statuses)
    {
        SWSS_LOG_ERROR("Invalid arguments");
        return SAI_STATUS_FAILURE;
    }

    for (it = 0; it < object_count; it++)
    {
        if (!attr_list[it] || !attr_count[it])
        {
            SWSS_LOG_ERROR("Invalid arguments");
            return SAI_STATUS_FAILURE;
        }
    }

    for (it = 0; it < object_count; it++)
    {
        object_statuses[it] = get(object_type, serialized_object_ids[it], attr_count[it], attr_list[it]);

        if (object_statuses[it] != SAI_STATUS_SUCCESS)
        {
            SWSS_LOG_ERROR("Failed to get attribute for object with type = %u", object_type);

            status = SAI_STATUS_FAILURE;

            if (mode == SAI_BULK_OP_ERROR_MODE_STOP_ON_ERROR)
            {
                break;
            }
        }
    }

    while (++it < object_count)
    {
        object_statuses[it] = SAI_STATUS_NOT_EXECUTED;
    }

    return status;
}

int SwitchStateBase::get_default_gw_mac_address(
        _Out_ sai_mac_t& mac)
{
    SWSS_LOG_ENTER();

    auto file = std::ifstream("/proc/net/route");

    if (!file)
    {
        return -1;
    }

    std::string buf;

    while (std::getline(file, buf))
    {
        char iface[IF_NAMESIZE];

        long destination, gateway;

        if (std::sscanf(buf.c_str(), "%s %lx %lx", iface, &destination, &gateway) == 3)
        {
            if (destination == 0)
            {
                file = std::ifstream("/sys/class/net/" + std::string(iface) + "/address");

                if ( !file )
                {
                    return -1;
                }

                file >> buf;

                return std::sscanf(buf.c_str(), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]) == 6 ? 0 : -1;
            }
        }
    }

    return -1;
}

sai_status_t SwitchStateBase::set_switch_mac_address()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create switch src mac address");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_SRC_MAC_ADDRESS;

    if (get_default_gw_mac_address(attr.value.mac) < 0)
    {
        attr.value.mac[0] = 0x22;
        attr.value.mac[1] = 0x33;
        attr.value.mac[2] = 0x44;
        attr.value.mac[3] = 0x55;
        attr.value.mac[4] = 0x66;
        attr.value.mac[5] = 0x77;
    }

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_vxlan_default_router_mac()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create switch vxlan default router mac address");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_VXLAN_DEFAULT_ROUTER_MAC;

    // NOTE if there is default vxlan mac present like in case of get_default_gw_mac_address
    // then that mac should be used
    {
        attr.value.mac[0] = 0x12;
        attr.value.mac[1] = 0x23;
        attr.value.mac[2] = 0x34;
        attr.value.mac[3] = 0x45;
        attr.value.mac[4] = 0x56;
        attr.value.mac[5] = 0x67;
    }

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_switch_supported_object_types()
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    // Fill this with supported SAI_OBJECT_TYPEs
    sai_object_type_t supported_obj_list[] = {
        SAI_OBJECT_TYPE_PORT,
        SAI_OBJECT_TYPE_LAG,
        SAI_OBJECT_TYPE_TAM,
        SAI_OBJECT_TYPE_TAM_COLLECTOR,
        SAI_OBJECT_TYPE_TAM_REPORT,
        SAI_OBJECT_TYPE_TAM_TRANSPORT,
        SAI_OBJECT_TYPE_TAM_TELEMETRY,
        SAI_OBJECT_TYPE_TAM_EVENT_THRESHOLD
    };

    attr.id = SAI_SWITCH_ATTR_SUPPORTED_OBJECT_TYPE_LIST;
    attr.value.s32list.count = sizeof(supported_obj_list)/sizeof(sai_object_type_t);
    attr.value.s32list.list = (int32_t *) supported_obj_list;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_switch_default_attributes()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create switch default attributes");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_PORT_STATE_CHANGE_NOTIFY;
    attr.value.ptr = NULL;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_FDB_EVENT_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_BFD_SESSION_STATE_CHANGE_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_ICMP_ECHO_SESSION_STATE_CHANGE_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_HA_SET_EVENT_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_HA_SCOPE_EVENT_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_TAM_TEL_TYPE_CONFIG_CHANGE_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_SWITCH_MACSEC_POST_STATUS_NOTIFY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_FDB_AGING_TIME;
    attr.value.u32 = 0;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_RESTART_WARM;
    attr.value.booldata = false;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_TYPE;
    attr.value.s32 = SAI_SWITCH_TYPE_NPU;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_WARM_RECOVER;
    attr.value.booldata = false;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_SUPPORTED_IPV4_BFD_SESSION_OFFLOAD_TYPE;
    uint32_t list[1] = { SAI_BFD_SESSION_OFFLOAD_TYPE_FULL };

    if(!m_switchConfig->m_bfdOffload) {
        list[0] = SAI_BFD_SESSION_OFFLOAD_TYPE_NONE;
    }

    attr.value.u32list.count = 1;
    attr.value.u32list.list = list;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_SUPPORTED_IPV6_BFD_SESSION_OFFLOAD_TYPE;
    attr.value.u32list.count = 1;
    attr.value.u32list.list = list;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    return set_switch_supported_object_types();
}

sai_status_t SwitchStateBase::create_default_hash()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default hash");

    // Hash defaults according to SAI headers
    std::vector<sai_native_hash_field_t> hfList = {
        SAI_NATIVE_HASH_FIELD_DST_MAC,
        SAI_NATIVE_HASH_FIELD_SRC_MAC,
        SAI_NATIVE_HASH_FIELD_ETHERTYPE,
        SAI_NATIVE_HASH_FIELD_IN_PORT
    };

    // create and populate default ecmp hash object
    sai_attribute_t attr;
    attr.id = SAI_HASH_ATTR_NATIVE_HASH_FIELD_LIST;
    attr.value.s32list.list = reinterpret_cast<sai_int32_t*>(hfList.data());
    attr.value.s32list.count = static_cast<sai_uint32_t>(hfList.size());

    CHECK_STATUS(create(SAI_OBJECT_TYPE_HASH, &m_ecmp_hash_id, m_switch_id, 1, &attr));

    // set default ecmp hash on switch
    attr.id = SAI_SWITCH_ATTR_ECMP_HASH;
    attr.value.oid = m_ecmp_hash_id;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    // create and populate default lag hash object
    attr.id = SAI_HASH_ATTR_NATIVE_HASH_FIELD_LIST;
    attr.value.s32list.list = reinterpret_cast<sai_int32_t*>(hfList.data());
    attr.value.s32list.count = static_cast<sai_uint32_t>(hfList.size());

    CHECK_STATUS(create(SAI_OBJECT_TYPE_HASH, &m_lag_hash_id, m_switch_id, 1, &attr));

    // set default lag hash on switch
    attr.id = SAI_SWITCH_ATTR_LAG_HASH;
    attr.value.oid = m_lag_hash_id;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_static_crm_values()
{
    SWSS_LOG_ENTER();

    std::map<sai_switch_attr_t, int> crm_resource_lookup = {
        { SAI_SWITCH_ATTR_AVAILABLE_IPV4_ROUTE_ENTRY, m_maxIPv4RouteEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPV6_ROUTE_ENTRY, m_maxIPv6RouteEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPV4_NEXTHOP_ENTRY, m_maxIPv4NextHopEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPV6_NEXTHOP_ENTRY, m_maxIPv6NextHopEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPV4_NEIGHBOR_ENTRY, m_maxIPv4NeighborEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPV6_NEIGHBOR_ENTRY, m_maxIPv6NeighborEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_NEXT_HOP_GROUP_MEMBER_ENTRY, m_maxNextHopGroupMemberEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_NEXT_HOP_GROUP_ENTRY, m_maxNextHopGroupEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_FDB_ENTRY, m_maxFdbEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_SNAT_ENTRY, m_maxSNATEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_DNAT_ENTRY, m_maxDNATEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_IPMC_ENTRY, m_maxIPMCEntries },
        { SAI_SWITCH_ATTR_AVAILABLE_DOUBLE_NAT_ENTRY, m_maxDoubleNATEntries }
    };

    for (auto const &resource: crm_resource_lookup)
    {
        sai_attribute_t attr;
        attr.id = resource.first;
        attr.value.u32 = resource.second;
        CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));
    }

    CHECK_STATUS(set_static_acl_resource_list(SAI_SWITCH_ATTR_AVAILABLE_ACL_TABLE, m_maxAclTables));

    return set_static_acl_resource_list(SAI_SWITCH_ATTR_AVAILABLE_ACL_TABLE_GROUP, m_maxAclTableGroups);
}

sai_status_t SwitchStateBase::set_initial_tam_objects()
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;
    attr.id = SAI_SWITCH_ATTR_TAM_OBJECT_ID;
    attr.value.objlist.count = 0;
    attr.value.objlist.list = nullptr;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_static_acl_resource_list(
        _In_ sai_switch_attr_t acl_resource,
        _In_ int max_count)
{
    SWSS_LOG_ENTER();

    auto acl_stages = {SAI_ACL_STAGE_INGRESS, SAI_ACL_STAGE_EGRESS};
    auto acl_bind_points = {
        SAI_ACL_BIND_POINT_TYPE_PORT,
        SAI_ACL_BIND_POINT_TYPE_LAG,
        SAI_ACL_BIND_POINT_TYPE_VLAN,
        SAI_ACL_BIND_POINT_TYPE_ROUTER_INTERFACE,
        SAI_ACL_BIND_POINT_TYPE_SWITCH
    };

    std::vector<sai_acl_resource_t> acl_resource_list;
    for (auto stage: acl_stages)
    {
        for (auto bp: acl_bind_points)
        {
            sai_acl_resource_t acl_resource_count;
            acl_resource_count.stage = stage;
            acl_resource_count.bind_point = bp;
            acl_resource_count.avail_num = max_count;

            acl_resource_list.push_back(acl_resource_count);
        }
    }

    sai_acl_resource_list_t available_acl_resources;
    available_acl_resources.count = static_cast<uint32_t>(acl_resource_list.size());
    available_acl_resources.list = acl_resource_list.data();

    sai_attribute_t attr;
    attr.id = acl_resource;
    attr.value.aclresource = available_acl_resources;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_default_vlan()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default vlan");

    sai_attribute_t attr;

    attr.id = SAI_VLAN_ATTR_VLAN_ID;
    attr.value.u16 = DEFAULT_VLAN_NUMBER;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_VLAN, &m_default_vlan_id, m_switch_id, 1, &attr));

    /* set default vlan on switch */

    attr.id = SAI_SWITCH_ATTR_DEFAULT_VLAN_ID;
    attr.value.oid = m_default_vlan_id;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_cpu_port()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create cpu port");

    sai_attribute_t attr;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_PORT, &m_cpu_port_id, m_switch_id, 0, &attr));

    // populate cpu port object on switch
    attr.id = SAI_SWITCH_ATTR_CPU_PORT;
    attr.value.oid = m_cpu_port_id;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    // set type on cpu
    attr.id = SAI_PORT_ATTR_TYPE;
    attr.value.s32 = SAI_PORT_TYPE_CPU;

    return set(SAI_OBJECT_TYPE_PORT, m_cpu_port_id, &attr);
}

sai_status_t SwitchStateBase::create_default_1q_bridge()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default 1q bridge");

    sai_attribute_t attr;

    attr.id = SAI_BRIDGE_ATTR_TYPE;
    attr.value.s32 = SAI_BRIDGE_TYPE_1Q;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_BRIDGE, &m_default_1q_bridge, m_switch_id, 1, &attr));

    attr.id = SAI_SWITCH_ATTR_DEFAULT_1Q_BRIDGE_ID;
    attr.value.oid = m_default_1q_bridge;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_ports()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create ports");

    auto map = m_switchConfig->m_laneMap;

    if (!map)
    {
        SWSS_LOG_ERROR("lane map for switch %s is NULL",
                sai_serialize_object_id(m_switch_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    auto lanesVector = map->getLaneVector();

    if (m_switchConfig->m_useTapDevice)
    {
        SWSS_LOG_DEBUG("Check available lane");

        CHECK_STATUS(filter_available_lanes(lanesVector));
    }

    uint32_t port_count = (uint32_t)lanesVector.size();

    m_port_list.clear();

    for (uint32_t i = 0; i < port_count; i++)
    {
        SWSS_LOG_DEBUG("create port index %u", i);

        sai_object_id_t port_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_PORT, &port_id, m_switch_id, 0, NULL));
        m_port_list.push_back(port_id);

        sai_attribute_t attr;

        attr.id = SAI_PORT_ATTR_ADMIN_STATE;
        attr.value.booldata = false;     /* default admin state is down as defined in SAI */

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_MTU;
        attr.value.u32 = 1514;     /* default MTU is 1514 as defined in SAI */

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_SPEED;
        attr.value.u32 = 40 * 1000;     // TODO from config

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        std::vector<uint32_t> lanes = lanesVector.at(i);

        attr.id = SAI_PORT_ATTR_HW_LANE_LIST;
        attr.value.u32list.count = (uint32_t)lanes.size();
        attr.value.u32list.list = lanes.data();

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_TYPE;
        attr.value.s32 = SAI_PORT_TYPE_LOGICAL;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_OPER_STATUS;
        attr.value.s32 = SAI_PORT_OPER_STATUS_DOWN;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_PORT_VLAN_ID;
        attr.value.u32 = DEFAULT_VLAN_NUMBER;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_HOST_TX_READY_STATUS;
        attr.value.u32 = SAI_PORT_HOST_TX_READY_STATUS_READY;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

        attr.id = SAI_PORT_ATTR_AUTO_NEG_MODE;
        attr.value.booldata = true;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set_port_list()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set port list");

    // NOTE: this is static, but will be refreshed on read only get

    sai_attribute_t attr;

    uint32_t port_count = (uint32_t)m_port_list.size();

    attr.id = SAI_SWITCH_ATTR_PORT_LIST;
    attr.value.objlist.count = port_count;
    attr.value.objlist.list = m_port_list.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_PORT_NUMBER;
    attr.value.u32 = port_count;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_port_capabilities()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_NOTICE("set port capabilities");

    sai_attribute_t attr;

    for (auto &port_id: m_port_list)
    {
        attr.id = SAI_PORT_ATTR_SUPPORTED_AUTO_NEG_MODE;
        attr.value.booldata = true;
        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));
    }
    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_default_virtual_router()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default virtual router");

    sai_object_id_t virtual_router_id;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_VIRTUAL_ROUTER, &virtual_router_id, m_switch_id, 0, NULL));

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_DEFAULT_VIRTUAL_ROUTER_ID;
    attr.value.oid = virtual_router_id;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_default_stp_instance()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default stp instance");

    sai_object_id_t stp_instance_id;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_STP, &stp_instance_id, m_switch_id, 0, NULL));

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_DEFAULT_STP_INST_ID;
    attr.value.oid = stp_instance_id;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_default_trap_group()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create default trap group");

    sai_object_id_t trap_group_id;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_HOSTIF_TRAP_GROUP, &trap_group_id, m_switch_id, 0, NULL));

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_DEFAULT_TRAP_GROUP;
    attr.value.oid = trap_group_id;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_ingress_priority_groups_per_port(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    const uint32_t port_pgs_count = 8; // NOTE: must be per switch (mlnx and brcm is 8)

    std::vector<sai_object_id_t> pgs;

    for (uint32_t i = 0; i < port_pgs_count; ++i)
    {
        sai_object_id_t pg_id;

        sai_attribute_t attr[3];

        // NOTE: on brcm this attribute is not added

        attr[0].id = SAI_INGRESS_PRIORITY_GROUP_ATTR_BUFFER_PROFILE;
        attr[0].value.oid = SAI_NULL_OBJECT_ID;

        attr[1].id = SAI_INGRESS_PRIORITY_GROUP_ATTR_PORT;
        attr[1].value.oid = port_id;

        attr[2].id = SAI_INGRESS_PRIORITY_GROUP_ATTR_INDEX;
        attr[2].value.oid = i;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, &pg_id, m_switch_id, 3, attr));

        pgs.push_back(pg_id);
    }

    sai_attribute_t attr;

    attr.id = SAI_PORT_ATTR_NUMBER_OF_INGRESS_PRIORITY_GROUPS;
    attr.value.u32 = port_pgs_count;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    attr.id = SAI_PORT_ATTR_INGRESS_PRIORITY_GROUP_LIST;
    attr.value.objlist.count = port_pgs_count;
    attr.value.objlist.list = pgs.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_ingress_priority_groups()
{
    SWSS_LOG_ENTER();

    // XXX priority groups size may change when we will modify pg or ports

    SWSS_LOG_INFO("create ingress priority groups");

    for (auto &port_id: m_port_list)
    {
        create_ingress_priority_groups_per_port(port_id);
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_vlan_members()
{
    SWSS_LOG_ENTER();

    // Crete vlan members for bridge ports.

    for (auto bridge_port_id: m_bridge_port_list_port_based)
    {
        SWSS_LOG_DEBUG("create vlan member for bridge port %s",
                sai_serialize_object_id(bridge_port_id).c_str());

        sai_attribute_t attrs[3];

        attrs[0].id = SAI_VLAN_MEMBER_ATTR_BRIDGE_PORT_ID;
        attrs[0].value.oid = bridge_port_id;

        attrs[1].id = SAI_VLAN_MEMBER_ATTR_VLAN_ID;
        attrs[1].value.oid = m_default_vlan_id;

        attrs[2].id = SAI_VLAN_MEMBER_ATTR_VLAN_TAGGING_MODE;
        attrs[2].value.s32 = SAI_VLAN_TAGGING_MODE_UNTAGGED;

        sai_object_id_t vlan_member_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_VLAN_MEMBER, &vlan_member_id, m_switch_id, 3, attrs));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_bridge_ports()
{
    SWSS_LOG_ENTER();

    // Create bridge port for 1q router.

    sai_attribute_t attr;

    attr.id = SAI_BRIDGE_PORT_ATTR_TYPE;
    attr.value.s32 = SAI_BRIDGE_PORT_TYPE_1Q_ROUTER;

    CHECK_STATUS(create(SAI_OBJECT_TYPE_BRIDGE_PORT, &m_default_bridge_port_1q_router, m_switch_id, 1, &attr));

    attr.id = SAI_BRIDGE_PORT_ATTR_PORT_ID;
    attr.value.oid = SAI_NULL_OBJECT_ID;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_BRIDGE_PORT, m_default_bridge_port_1q_router, &attr));

    // Create bridge ports for regular ports.

    m_bridge_port_list_port_based.clear();

    for (const auto &port_id: m_port_list)
    {
        SWSS_LOG_DEBUG("create bridge port for port %s", sai_serialize_object_id(port_id).c_str());

        sai_attribute_t attrs[4];

        attrs[0].id = SAI_BRIDGE_PORT_ATTR_BRIDGE_ID;
        attrs[0].value.oid = m_default_1q_bridge;

        attrs[1].id = SAI_BRIDGE_PORT_ATTR_FDB_LEARNING_MODE;
        attrs[1].value.s32 = SAI_BRIDGE_PORT_FDB_LEARNING_MODE_HW;

        attrs[2].id = SAI_BRIDGE_PORT_ATTR_PORT_ID;
        attrs[2].value.oid = port_id;

        attrs[3].id = SAI_BRIDGE_PORT_ATTR_TYPE;
        attrs[3].value.s32 = SAI_BRIDGE_PORT_TYPE_PORT;

        sai_object_id_t bridge_port_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_BRIDGE_PORT, &bridge_port_id, m_switch_id, 4, attrs));

        m_bridge_port_list_port_based.push_back(bridge_port_id);
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set_acl_entry_min_prio()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set acl entry min prio");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_ACL_ENTRY_MINIMUM_PRIORITY;
    attr.value.u32 = 1;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_ACL_ENTRY_MAXIMUM_PRIORITY;
    attr.value.u32 = 16000;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_acl_capabilities()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set acl capabilities");

    sai_attribute_t attr;

    m_ingress_acl_action_list.clear();
    m_egress_acl_action_list.clear();

    for (int action_type = SAI_ACL_ENTRY_ATTR_ACTION_START; action_type <= SAI_ACL_ENTRY_ATTR_ACTION_END; action_type++)
    {
        m_ingress_acl_action_list.push_back(static_cast<sai_acl_action_type_t>(action_type - SAI_ACL_ENTRY_ATTR_ACTION_START));
        m_egress_acl_action_list.push_back(static_cast<sai_acl_action_type_t>(action_type - SAI_ACL_ENTRY_ATTR_ACTION_START));
    }

    attr.id = SAI_SWITCH_ATTR_MAX_ACL_ACTION_COUNT;
    attr.value.u32 = static_cast<uint32_t>(std::max(m_ingress_acl_action_list.size(), m_egress_acl_action_list.size()));

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_ACL_STAGE_INGRESS;
    attr.value.aclcapability.is_action_list_mandatory = false;
    attr.value.aclcapability.action_list.list = reinterpret_cast<int32_t*>(m_ingress_acl_action_list.data());
    attr.value.aclcapability.action_list.count = static_cast<uint32_t>(m_ingress_acl_action_list.size());

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_ACL_STAGE_EGRESS;
    attr.value.aclcapability.is_action_list_mandatory = false;
    attr.value.aclcapability.action_list.list = reinterpret_cast<int32_t*>(m_egress_acl_action_list.data());
    attr.value.aclcapability.action_list.count = static_cast<uint32_t>(m_egress_acl_action_list.size());

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_cpu_qos_queues(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_qos_queues_per_port(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_qos_queues()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::set_number_of_queues()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_scheduler_group_tree(
        _In_ const std::vector<sai_object_id_t>& sgs,
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_scheduler_groups_per_port(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_scheduler_groups()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create scheduler groups");

    // XXX scheduler groups size may change when we will modify sg or ports

    for (auto &port_id: m_port_list)
    {
        CHECK_STATUS(create_scheduler_groups_per_port(port_id));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set_maximum_number_of_traffic_classes()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set number of traffic classes");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_QOS_MAX_NUMBER_OF_TRAFFIC_CLASSES;
    attr.value.u8 = 16;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::set_maximum_number_of_childs_per_scheduler_group()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::set_number_of_ecmp_groups()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set number of ecmp groups");

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_NUMBER_OF_ECMP_GROUPS;
    attr.value.u32 = 512;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::create_port_serdes()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::create_port_serdes_per_port(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}


sai_status_t SwitchStateBase::process_fips_post_config(
        _In_ std::string config, _In_ sai_object_id_t macsec_id)
{
    SWSS_LOG_ENTER();

    std::ifstream ifs;
    ifs.open(VS_SAI_FIPS_POST_CONFIG_FILE);
    if (!ifs.is_open())
    {
        SWSS_LOG_NOTICE("No VS FIPS POST config file found");
        return SAI_STATUS_SUCCESS;
    }

    sai_status_t status = SAI_STATUS_SUCCESS;
    std::string line;
    while (std::getline(ifs, line))
    {
        // line format: key value
        std::istringstream iss(line);
        std::string key;
        std::string value;
        iss >> key >> value;

        sai_attribute_t attr;

        if (key != config)
        {
            continue;
        }

        SWSS_LOG_NOTICE("VS FIPS POST config: %s", line.c_str());

        if (config == VS_SAI_FIPS_SWITCH_MACSEC_POST_STATUS_QUERY)
        {
            sai_switch_macsec_post_status_t switch_macsec_post_status;
            sai_deserialize_switch_macsec_post_status(value, switch_macsec_post_status);

            attr.id = SAI_SWITCH_ATTR_MACSEC_POST_STATUS;
            attr.value.s32 = switch_macsec_post_status;
            status = set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
            if (status != SAI_STATUS_SUCCESS)
            {
                SWSS_LOG_ERROR("Failed to Set SAI_SWITCH_ATTR_MACSEC_POST_STATUS to %s (attr value: %d)",
                               value.c_str(), attr.value.u8);
                break;
            }
            SWSS_LOG_NOTICE("Set SAI_SWITCH_ATTR_MACSEC_POST_STATUS to %s", value.c_str());
        }
        else if (config == VS_SAI_FIPS_SWITCH_MACSEC_POST_STATUS_NOTIFY)
        {
            sai_switch_macsec_post_status_t switch_macsec_post_status;
            sai_deserialize_switch_macsec_post_status(value, switch_macsec_post_status);

            auto str = sai_serialize_switch_macsec_post_status_ntf(m_switch_id, switch_macsec_post_status);
            auto ntf = std::make_shared<sairedis::NotificationSwitchMacsecPostStatus>(str);

            attr.id = SAI_SWITCH_ATTR_SWITCH_MACSEC_POST_STATUS_NOTIFY;
            status = get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr);
            if (status != SAI_STATUS_SUCCESS)
            {
                 SWSS_LOG_ERROR("Unable to get SAI_SWITCH_ATTR_SWITCH_MACSEC_POST_STATUS_NOTIFY attribute");
                 break;
            }
            sai_switch_notifications_t sn = { };
            sn.on_switch_macsec_post_status = (sai_switch_macsec_post_status_notification_fn)attr.value.ptr;
            auto payload = std::make_shared<EventPayloadNotification>(ntf, sn);
            m_switchConfig->m_eventQueue->enqueue(std::make_shared<Event>(EVENT_TYPE_NOTIFICATION, payload));
            SWSS_LOG_NOTICE("Enqueued switch MACSec POST notification: status %s", value.c_str());
        }
        else if (config == VS_SAI_FIPS_INGRESS_MACSEC_POST_STATUS_NOTIFY ||
                 config == VS_SAI_FIPS_EGRESS_MACSEC_POST_STATUS_NOTIFY)
        {
            sai_macsec_post_status_t macsec_post_status;
            sai_deserialize_macsec_post_status(value, macsec_post_status);

            auto str = sai_serialize_macsec_post_status_ntf(macsec_id, macsec_post_status);
            auto ntf = std::make_shared<sairedis::NotificationMacsecPostStatus>(str);

            attr.id = SAI_SWITCH_ATTR_MACSEC_POST_STATUS_NOTIFY;
            status = get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr);
            if (status != SAI_STATUS_SUCCESS)
            {
                 SWSS_LOG_ERROR("Unable to get SAI_SWITCH_ATTR_MACSEC_POST_STATUS_NOTIFY attribute for %s",
                                sai_serialize_object_id(m_switch_id).c_str());
                 break;
            }
            sai_switch_notifications_t sn = { };
            sn.on_macsec_post_status = (sai_macsec_post_status_notification_fn)attr.value.ptr;
            auto payload = std::make_shared<EventPayloadNotification>(ntf, sn);
            m_switchConfig->m_eventQueue->enqueue(std::make_shared<Event>(EVENT_TYPE_NOTIFICATION, payload));
            std::string direction = (config == VS_SAI_FIPS_INGRESS_MACSEC_POST_STATUS_NOTIFY) ? "ingress" :
                "egress";
            SWSS_LOG_NOTICE("Enqueued %s MACSec POST notification: status %s", direction.c_str(),value.c_str());
        }
    }

    ifs.close();
    return status;
}

sai_status_t SwitchStateBase::initialize_default_objects(
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    CHECK_STATUS(set_switch_mac_address());
    CHECK_STATUS(set_vxlan_default_router_mac());
    CHECK_STATUS(create_cpu_port());
    CHECK_STATUS(create_default_hash());
    CHECK_STATUS(create_default_vlan());
    CHECK_STATUS(create_default_virtual_router());
    CHECK_STATUS(create_default_stp_instance());
    CHECK_STATUS(create_default_1q_bridge());
    CHECK_STATUS(create_default_trap_group());
    CHECK_STATUS(create_ports());
    CHECK_STATUS(create_port_serdes());
    CHECK_STATUS(set_port_list());
    CHECK_STATUS(set_port_capabilities());
    CHECK_STATUS(create_bridge_ports());
    CHECK_STATUS(create_vlan_members());
    CHECK_STATUS(set_acl_entry_min_prio());
    CHECK_STATUS(set_acl_capabilities());
    CHECK_STATUS(create_ingress_priority_groups());
    CHECK_STATUS(create_qos_queues());
    CHECK_STATUS(set_number_of_queues());
    CHECK_STATUS(set_maximum_number_of_traffic_classes());
    CHECK_STATUS(set_maximum_number_of_childs_per_scheduler_group());
    CHECK_STATUS(set_number_of_ecmp_groups());
    CHECK_STATUS(set_switch_default_attributes());
    CHECK_STATUS(create_scheduler_groups());
    CHECK_STATUS(set_static_crm_values());
    CHECK_STATUS(set_initial_tam_objects());

    // Initialize switch for VOQ attributes

    CHECK_STATUS(initialize_voq_switch_objects(attr_count, attr_list));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_port_dependencies(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    // params are not needed since they were already set

    SWSS_LOG_WARN("check attributes and set, FIXME");

    // this method is post create action on generic create object

    sai_attribute_t attr;

    // default admin state is down as defined in SAI

    attr.id = SAI_PORT_ATTR_ADMIN_STATE;
    attr.value.booldata = false;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    attr.id = SAI_PORT_ATTR_HOST_TX_READY_STATUS;
    attr.value.u32 = SAI_PORT_HOST_TX_READY_STATUS_READY;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    attr.id = SAI_PORT_ATTR_AUTO_NEG_MODE;
    attr.value.booldata = true;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    // attributes are not required since they will be set outside this function

    CHECK_STATUS(create_ingress_priority_groups_per_port(port_id));
    CHECK_STATUS(create_qos_queues_per_port(port_id));
    CHECK_STATUS(create_scheduler_groups_per_port(port_id));
    CHECK_STATUS(create_port_serdes_per_port(port_id));

    // XXX should bridge ports should also be created when new port is created?
    // this needs to be checked on real ASIC and updated here

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_ingress_priority_group(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    /*
     * TODO Currently we don't have index in groups, so we don't know how to
     * sort.  Returning success, since assuming that we will not create more
     * ingress priority groups.
     */

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_qos_queues(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    /*
     * TODO Currently we don't have index in groups, so we don't know how to
     * sort.  Returning success, since assuming that we will not create more
     * ingress priority groups.
     */

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_scheduler_groups(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    /*
     * TODO Currently we don't have index in groups, so we don't know how to
     * sort.  Returning success, since assuming that we will not create more
     * ingress priority groups.
     */

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::warm_boot_initialize_objects()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("warm boot init objects");

    /*
     * We need to bring back previous state in case user will get some read
     * only attributes and recalculation will need to be done.
     *
     * We need to refresh:
     * - ports
     * - default bridge port 1q router
     */

    m_port_list.resize(SAI_VS_MAX_PORTS);

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_PORT_LIST;

    attr.value.objlist.count = SAI_VS_MAX_PORTS;
    attr.value.objlist.list = m_port_list.data();

    CHECK_STATUS(get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr));

    m_port_list.resize(attr.value.objlist.count);

    SWSS_LOG_NOTICE("port list size: %zu", m_port_list.size());

    attr.id = SAI_SWITCH_ATTR_DEFAULT_1Q_BRIDGE_ID;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr));

    m_default_bridge_port_1q_router = attr.value.oid;

    SWSS_LOG_NOTICE("default bridge port 1q router: %s",
            sai_serialize_object_id(m_default_bridge_port_1q_router).c_str());

    attr.id = SAI_SWITCH_ATTR_CPU_PORT;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr));

    m_cpu_port_id = attr.value.oid;

    SWSS_LOG_NOTICE("cpu port id: %s",
            sai_serialize_object_id(m_cpu_port_id).c_str());

    // TODO refresh
    //
    // m_bridge_port_list_port_based;
    // m_default_1q_bridge;
    // m_default_vlan_id;
    //
    // other objects/numbers if added (per switch also)

    // TODO update
    // std::unordered_set<uint32_t> m_indices;

    // When booting from older virtual switch (eg. 201811) some attributes
    // could not be populated at that time, but they can be populated on master
    // (mostly default values of those attributes) so they will require manual
    // update after warm boot, for example: SAI_OBJECT_TYPE_QUEUE has no
    // attributes on 201811 branch but on master there are 3 attributes
    // populated SAI_QUEUE_ATTR_INDEX, PORT and TYPE. This could be per asic,
    // so those functions are virtual and could be overridden in child class.

    CHECK_STATUS(warm_update_queues());
    CHECK_STATUS(warm_update_scheduler_groups());
    CHECK_STATUS(warm_update_ingress_priority_groups());
    CHECK_STATUS(warm_update_switch());
    CHECK_STATUS(warm_update_cpu_queues());

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::warm_update_queues()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::warm_update_scheduler_groups()
{
    SWSS_LOG_ENTER();

    for (auto port: m_port_list)
    {
        sai_attribute_t attr;

        std::vector<sai_object_id_t> list(MAX_OBJLIST_LEN);

        // get all scheduler list on current port

        attr.id = SAI_PORT_ATTR_QOS_SCHEDULER_GROUP_LIST;

        attr.value.objlist.count = MAX_OBJLIST_LEN;
        attr.value.objlist.list = list.data();

        CHECK_STATUS(get(SAI_OBJECT_TYPE_PORT, port , 1, &attr));

        list.resize(attr.value.objlist.count);

        for (auto sg: list)
        {
            attr.id = SAI_SCHEDULER_GROUP_ATTR_PORT_ID;

            if (get(SAI_OBJECT_TYPE_SCHEDULER_GROUP, sg, 1, &attr) != SAI_STATUS_SUCCESS)
            {
                attr.value.oid = port;

                CHECK_STATUS(set(SAI_OBJECT_TYPE_SCHEDULER_GROUP, sg, &attr));
            }
        }
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::warm_update_ingress_priority_groups()
{
    SWSS_LOG_ENTER();

    for (auto port: m_port_list)
    {
        sai_attribute_t attr;

        std::vector<sai_object_id_t> list(MAX_OBJLIST_LEN);

        // get all ingress priority groups list on current port

        attr.id = SAI_PORT_ATTR_INGRESS_PRIORITY_GROUP_LIST;

        attr.value.objlist.count = MAX_OBJLIST_LEN;
        attr.value.objlist.list = list.data();

        CHECK_STATUS(get(SAI_OBJECT_TYPE_PORT, port , 1, &attr));

        list.resize(attr.value.objlist.count);

        uint8_t index = 0;

        for (auto ipg: list)
        {
            attr.id = SAI_INGRESS_PRIORITY_GROUP_ATTR_PORT;

            if (get(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, 1, &attr) != SAI_STATUS_SUCCESS)
            {
                attr.value.oid = port;

                CHECK_STATUS(set(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, &attr));
            }

            attr.id = SAI_INGRESS_PRIORITY_GROUP_ATTR_BUFFER_PROFILE;

            if (get(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, 1, &attr) != SAI_STATUS_SUCCESS)
            {
                attr.value.oid = SAI_NULL_OBJECT_ID;

                CHECK_STATUS(set(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, &attr));
            }

            attr.id = SAI_INGRESS_PRIORITY_GROUP_ATTR_INDEX;

            if (get(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, 1, &attr) != SAI_STATUS_SUCCESS)
            {
                attr.value.u8 = index; // warn, we are guessing index here if it was not defined

                CHECK_STATUS(set(SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, ipg, &attr));
            }

            index++;
        }
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::warm_update_switch()
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    // check for default available attributes

    attr.id = SAI_SWITCH_ATTR_AVAILABLE_IPV4_ROUTE_ENTRY;

    if (get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        CHECK_STATUS(set_static_crm_values())
    }

    // check for default switch type

    attr.id = SAI_SWITCH_ATTR_TYPE;

    if (get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        attr.value.s32 = SAI_SWITCH_TYPE_NPU;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));
    }

    // check for default acl stages

    attr.id = SAI_SWITCH_ATTR_MAX_ACL_ACTION_COUNT;

    if (get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        CHECK_STATUS(set_acl_capabilities());
    }

    attr.id = SAI_SWITCH_ATTR_TAM_OBJECT_ID;

    std::vector<sai_object_id_t> objlist;
    objlist.resize(MAX_OBJLIST_LEN);

    attr.value.objlist.count = MAX_OBJLIST_LEN;
    attr.value.objlist.list = objlist.data();

    if (get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        CHECK_STATUS(set_initial_tam_objects());
    }

    // check for default supported object types

    attr.id = SAI_SWITCH_ATTR_SUPPORTED_OBJECT_TYPE_LIST;

    std::vector<sai_object_type_t> objs(MAX_OBJLIST_LEN);

    attr.value.s32list.count = MAX_OBJLIST_LEN;
    attr.value.s32list.list = (int32_t*)objs.data();

    if (get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        CHECK_STATUS(set_switch_supported_object_types());
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::warm_update_cpu_queues()
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    // check for queues

    attr.id = SAI_PORT_ATTR_QOS_NUMBER_OF_QUEUES;

    if (get(SAI_OBJECT_TYPE_PORT, m_cpu_port_id, 1, &attr) != SAI_STATUS_SUCCESS)
    {
        SWSS_LOG_WARN("creating cpu queues");

        CHECK_STATUS(create_cpu_qos_queues(m_cpu_port_id));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_bridge_port_list(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t bridge_id)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_ERROR("implement in child class");

    return SAI_STATUS_NOT_IMPLEMENTED;
}

sai_status_t SwitchStateBase::refresh_vlan_member_list(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t vlan_id)
{
    SWSS_LOG_ENTER();

    auto &all_vlan_members = m_objectHash.at(SAI_OBJECT_TYPE_VLAN_MEMBER);

    auto m_member_list = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_VLAN, SAI_VLAN_ATTR_MEMBER_LIST);
    auto md_vlan_id = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_VLAN_MEMBER, SAI_VLAN_MEMBER_ATTR_VLAN_ID);
    //auto md_brportid = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_VLAN_MEMBER, SAI_VLAN_MEMBER_ATTR_BRIDGE_PORT_ID);

    std::vector<sai_object_id_t> vlan_member_list;

    /*
     * We want order as bridge port order (so port order)
     */

    sai_attribute_t attr;

    auto me = m_objectHash.at(SAI_OBJECT_TYPE_VLAN).at(sai_serialize_object_id(vlan_id));

    for (auto vm: all_vlan_members)
    {
        if (vm.second.at(md_vlan_id->attridname)->getAttr()->value.oid != vlan_id)
        {
            /*
             * Only interested in our vlan
             */

            continue;
        }

        // TODO we need order as bridge ports, but we need bridge id!

        {
            sai_object_id_t vlan_member_id;

            sai_deserialize_object_id(vm.first, vlan_member_id);

            vlan_member_list.push_back(vlan_member_id);
        }
    }

    uint32_t vlan_member_list_count = (uint32_t)vlan_member_list.size();

    SWSS_LOG_NOTICE("recalculated %s: %u", m_member_list->attridname, vlan_member_list_count);

    attr.id = SAI_VLAN_ATTR_MEMBER_LIST;
    attr.value.objlist.count = vlan_member_list_count;
    attr.value.objlist.list = vlan_member_list.data();

    return set(SAI_OBJECT_TYPE_VLAN, vlan_id, &attr);
}

sai_status_t SwitchStateBase::refresh_port_list(
        _In_ const sai_attr_metadata_t *meta)
{
    SWSS_LOG_ENTER();

    // since now port can be added or removed, we need to update port list
    // dynamically

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_CPU_PORT;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr));

    const sai_object_id_t cpu_port_id = attr.value.oid;

    std::unordered_set<sai_object_id_t> fabric_port_set(m_fabric_port_list.begin(),
            m_fabric_port_list.end());

    m_port_list.clear();

    // iterate via ASIC state to find all the ports

    for (const auto& it: m_objectHash.at(SAI_OBJECT_TYPE_PORT))
    {
        sai_object_id_t port_id;
        sai_deserialize_object_id(it.first, port_id);

        // don't put CPU port id on the list

        if (port_id == cpu_port_id)
            continue;

        // don't put fabric ports on the list
        if (fabric_port_set.find(port_id) != fabric_port_set.end())
            continue;

        m_port_list.push_back(port_id);
    }

    /*
     * XXX Currently we don't know what's happen on brcm SAI implementation
     * when port is removed and then added, will new port could get the same
     * vendor OID or always different, and what is order of those new oids on
     * the PORT_LIST attribute.
     *
     * This needs to be investigated, and to reflect exact behaviour here.
     * Currently we just sort all the port oids.
     */

    std::sort(m_port_list.begin(), m_port_list.end());

    uint32_t port_count = (uint32_t)m_port_list.size();

    attr.id = SAI_SWITCH_ATTR_PORT_LIST;
    attr.value.objlist.count = port_count;
    attr.value.objlist.list = m_port_list.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_PORT_NUMBER;
    attr.value.u32 = port_count;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    SWSS_LOG_NOTICE("refreshed port list, current port number: %zu, not counting cpu port", m_port_list.size());

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_macsec_sci_in_ingress_macsec_acl(
        _In_ sai_object_id_t object_id)
{
    SWSS_LOG_ENTER();

    /*
     * SAI_MACSEC_ATTR_SCI_IN_INGRESS_MACSEC_ACL indicates the MACsec ASIC capability
     * of whether SCI can only be used as ACL field.
     * To set SAI_MACSEC_ATTR_SCI_IN_INGRESS_MACSEC_ACL is always true,
     * which indicates that here is emulating a kind of MACsec ASIC that use SCI as ACL field.
     */
    sai_attribute_t attr;
    attr.id = SAI_MACSEC_ATTR_SCI_IN_INGRESS_MACSEC_ACL;
    attr.value.booldata = true;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_MACSEC, object_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_queue_pause_status(
        _In_ sai_object_id_t object_id)
{
    SWSS_LOG_ENTER();

    // To trigger fake PFC storm on fake Broadcom platform, PFC storm detection
    // lua requires SAI_QUEUE_ATTR_PAUSE_STATUS field to be present in COUNTERS_DB.
    // However, the actual value of the attribute does not matter in this regard,
    // so a dummy one is assigned here.
    sai_attribute_t attr;
    attr.id = SAI_QUEUE_ATTR_PAUSE_STATUS;
    attr.value.booldata = false;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_QUEUE, object_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_macsec_sa_stat(
        _In_ sai_object_id_t object_id)
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    attr.id = SAI_MACSEC_SA_ATTR_CURRENT_XPN;
    CHECK_STATUS(getMACsecSAPacketNumber(object_id, attr));
    CHECK_STATUS(set(SAI_OBJECT_TYPE_MACSEC_SA, object_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_port_serdes_id(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    // port serdes could be removed by user explicitly, so try to find port
    // serdes object with this specific port

    sai_attribute_t attr;

    attr.id = SAI_PORT_ATTR_PORT_SERDES_ID;
    attr.value.oid = SAI_NULL_OBJECT_ID;

    auto* meta = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_PORT_SERDES, SAI_PORT_SERDES_ATTR_PORT_ID);

    // loop via all port serdes objects

    auto &serdeses = m_objectHash.at(SAI_OBJECT_TYPE_PORT_SERDES);

    auto strPortId = sai_serialize_object_id(port_id);

    for (auto& kvp: serdeses)
    {
        if (kvp.second.find(meta->attridname) != kvp.second.end())
        {
            if (kvp.second.at(meta->attridname)->getAttrStrValue() != strPortId)
            {
                // this is not the port we are looking for
                continue;
            }

            SWSS_LOG_INFO("found corresponding port serdes %s for port %s",
                    kvp.first.c_str(),
                    sai_serialize_object_id(port_id).c_str());

            sai_deserialize_object_id(kvp.first, attr.value.oid);
            break;
        }
    }

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_port_oper_speed(
                    _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    attr.id = SAI_PORT_ATTR_OPER_STATUS;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_PORT, port_id, 1, &attr));

    if (attr.value.s32 == SAI_PORT_OPER_STATUS_DOWN)
    {
        attr.value.u32 = 0;
    }
    else
    {
        if (m_switchConfig->m_useConfiguredSpeedAsOperSpeed)
        {
            attr.id = SAI_PORT_ATTR_SPEED;
            CHECK_STATUS(get(SAI_OBJECT_TYPE_PORT, port_id, 1, &attr));
        }
        else if (!vs_get_oper_speed(port_id, attr.value.u32))
        {
            return SAI_STATUS_FAILURE;
        }
    }

    attr.id = SAI_PORT_ATTR_OPER_SPEED;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, port_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_acl_table_entries(
                    _In_ sai_object_id_t acl_table_id)
{
    SWSS_LOG_ENTER();

    std::vector<sai_object_id_t> acl_entries;

    sai_attribute_t attr;
    attr.id = SAI_ACL_ENTRY_ATTR_TABLE_ID;
    attr.value.oid = acl_table_id;
    findObjects(SAI_OBJECT_TYPE_ACL_ENTRY, attr, acl_entries);

    attr.id = SAI_ACL_TABLE_ATTR_AVAILABLE_ACL_ENTRY;
    attr.value.u32 = m_maxAclTableEntries - (uint32_t) acl_entries.size();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_ACL_TABLE, acl_table_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::refresh_acl_table_counters(
                    _In_ sai_object_id_t acl_table_id)
{
    SWSS_LOG_ENTER();

    std::vector<sai_object_id_t> acl_counters;

    sai_attribute_t attr;
    attr.id = SAI_ACL_COUNTER_ATTR_TABLE_ID;
    attr.value.oid = acl_table_id;
    findObjects(SAI_OBJECT_TYPE_ACL_COUNTER, attr, acl_counters);

    attr.id = SAI_ACL_TABLE_ATTR_AVAILABLE_ACL_COUNTER;
    attr.value.u32 = m_maxAclTableCounters - (uint32_t) acl_counters.size();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_ACL_TABLE, acl_table_id, &attr));

    return SAI_STATUS_SUCCESS;
}


// XXX extra work may be needed on GET api if N on list will be > then actual

/*
 * We can use local variable here for initialization (init should be in class
 * constructor anyway, we can move it there later) because each switch init is
 * done under global lock.
 */

/*
 * NOTE For recalculation we can add flag on create/remove specific object type
 * so we can deduce whether actually need to perform recalculation, as
 * optimization.
 */

sai_status_t SwitchStateBase::refresh_read_only(
        _In_ const sai_attr_metadata_t *meta,
        _In_ sai_object_id_t object_id)
{
    SWSS_LOG_ENTER();

    if (meta->objecttype == SAI_OBJECT_TYPE_SWITCH)
    {
        switch (meta->attrid)
        {
            case SAI_SWITCH_ATTR_CPU_PORT:
            case SAI_SWITCH_ATTR_DEFAULT_VIRTUAL_ROUTER_ID:
            case SAI_SWITCH_ATTR_DEFAULT_TRAP_GROUP:
            case SAI_SWITCH_ATTR_DEFAULT_VLAN_ID:
            case SAI_SWITCH_ATTR_DEFAULT_STP_INST_ID:
            case SAI_SWITCH_ATTR_DEFAULT_1Q_BRIDGE_ID:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_ECMP_HASH:
            case SAI_SWITCH_ATTR_LAG_HASH:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_ACL_ENTRY_MINIMUM_PRIORITY:
            case SAI_SWITCH_ATTR_ACL_ENTRY_MAXIMUM_PRIORITY:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_MAX_ACL_ACTION_COUNT:
            case SAI_SWITCH_ATTR_ACL_STAGE_INGRESS:
            case SAI_SWITCH_ATTR_ACL_STAGE_EGRESS:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_NUMBER_OF_ECMP_GROUPS:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_NUMBER_OF_UNICAST_QUEUES:
            case SAI_SWITCH_ATTR_NUMBER_OF_MULTICAST_QUEUES:
            case SAI_SWITCH_ATTR_NUMBER_OF_QUEUES:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_PORT_NUMBER:
            case SAI_SWITCH_ATTR_PORT_LIST:
                return refresh_port_list(meta);

            case SAI_SWITCH_ATTR_QOS_MAX_NUMBER_OF_TRAFFIC_CLASSES:
            case SAI_SWITCH_ATTR_QOS_MAX_NUMBER_OF_CHILDS_PER_SCHEDULER_GROUP:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_AVAILABLE_IPV4_ROUTE_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPV6_ROUTE_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPV4_NEXTHOP_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPV6_NEXTHOP_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPV4_NEIGHBOR_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPV6_NEIGHBOR_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_NEXT_HOP_GROUP_MEMBER_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_NEXT_HOP_GROUP_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_FDB_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_ACL_TABLE:
            case SAI_SWITCH_ATTR_AVAILABLE_ACL_TABLE_GROUP:
            case SAI_SWITCH_ATTR_AVAILABLE_SNAT_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_DNAT_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_IPMC_ENTRY:
            case SAI_SWITCH_ATTR_AVAILABLE_DOUBLE_NAT_ENTRY:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_SUPPORTED_IPV4_BFD_SESSION_OFFLOAD_TYPE:
            case SAI_SWITCH_ATTR_SUPPORTED_IPV6_BFD_SESSION_OFFLOAD_TYPE:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_NUMBER_OF_SYSTEM_PORTS:
            case SAI_SWITCH_ATTR_SYSTEM_PORT_LIST:
                return refresh_system_port_list(meta);

            case SAI_SWITCH_ATTR_NUMBER_OF_FABRIC_PORTS:
            case SAI_SWITCH_ATTR_FABRIC_PORT_LIST:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_SUPPORTED_OBJECT_TYPE_LIST:
                return SAI_STATUS_SUCCESS;

            case SAI_SWITCH_ATTR_MACSEC_POST_STATUS:
                return SAI_STATUS_SUCCESS;
        }
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_PORT)
    {
        switch (meta->attrid)
        {
            case SAI_PORT_ATTR_QOS_NUMBER_OF_QUEUES:
            case SAI_PORT_ATTR_QOS_QUEUE_LIST:
                return refresh_qos_queues(meta, object_id);

            case SAI_PORT_ATTR_NUMBER_OF_INGRESS_PRIORITY_GROUPS:
            case SAI_PORT_ATTR_INGRESS_PRIORITY_GROUP_LIST:
                return refresh_ingress_priority_group(meta, object_id);

            case SAI_PORT_ATTR_QOS_NUMBER_OF_SCHEDULER_GROUPS:
            case SAI_PORT_ATTR_QOS_SCHEDULER_GROUP_LIST:
                return refresh_scheduler_groups(meta, object_id);

                /*
                 * This status is based on hostif vEthernetX status.
                 */

            case SAI_PORT_ATTR_OPER_STATUS:
            case SAI_PORT_ATTR_HOST_TX_READY_STATUS:
                return SAI_STATUS_SUCCESS;

            case SAI_PORT_ATTR_FABRIC_ATTACHED:
            case SAI_PORT_ATTR_FABRIC_ATTACHED_SWITCH_ID:
            case SAI_PORT_ATTR_FABRIC_ATTACHED_PORT_INDEX:
            case SAI_PORT_ATTR_HW_LANE_LIST:
                return SAI_STATUS_SUCCESS;

            case SAI_PORT_ATTR_PORT_SERDES_ID:
                return refresh_port_serdes_id(object_id);

            case SAI_PORT_ATTR_SUPPORTED_AUTO_NEG_MODE:
                return SAI_STATUS_SUCCESS;

            case SAI_PORT_ATTR_OPER_SPEED:
                return refresh_port_oper_speed(object_id);
        }
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_SYSTEM_PORT)
    {
        switch (meta->attrid)
        {
            case SAI_SYSTEM_PORT_ATTR_TYPE:
            case SAI_SYSTEM_PORT_ATTR_PORT:
            case SAI_SYSTEM_PORT_ATTR_QOS_NUMBER_OF_VOQS:
            case SAI_SYSTEM_PORT_ATTR_QOS_VOQ_LIST:
                return SAI_STATUS_SUCCESS;
        }
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_SCHEDULER_GROUP)
    {
        switch (meta->attrid)
        {
            case SAI_SCHEDULER_GROUP_ATTR_CHILD_COUNT:
            case SAI_SCHEDULER_GROUP_ATTR_CHILD_LIST:
                return refresh_scheduler_groups(meta, object_id);
        }
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_BRIDGE && meta->attrid == SAI_BRIDGE_ATTR_PORT_LIST)
    {
        return refresh_bridge_port_list(meta, object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_VLAN && meta->attrid == SAI_VLAN_ATTR_MEMBER_LIST)
    {
        return refresh_vlan_member_list(meta, object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_DEBUG_COUNTER && meta->attrid == SAI_DEBUG_COUNTER_ATTR_INDEX)
    {
        return SAI_STATUS_SUCCESS;
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_MACSEC && meta->attrid == SAI_MACSEC_ATTR_SCI_IN_INGRESS_MACSEC_ACL)
    {
        return refresh_macsec_sci_in_ingress_macsec_acl(object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_QUEUE && meta->attrid == SAI_QUEUE_ATTR_PAUSE_STATUS)
    {
        return refresh_queue_pause_status(object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_MACSEC_SA)
    {
        return refresh_macsec_sa_stat(object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_ACL_TABLE && meta->attrid == SAI_ACL_TABLE_ATTR_AVAILABLE_ACL_ENTRY)
    {
        return refresh_acl_table_entries(object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_ACL_TABLE && meta->attrid == SAI_ACL_TABLE_ATTR_AVAILABLE_ACL_COUNTER)
    {
        return refresh_acl_table_counters(object_id);
    }

    if (meta->objecttype == SAI_OBJECT_TYPE_TAM_TEL_TYPE && meta->attrid == SAI_TAM_TEL_TYPE_ATTR_IPFIX_TEMPLATES)
    {
        return refresh_tam_tel_ipfix_templates(object_id);
    }

    auto mmeta = m_meta.lock();

    if (mmeta)
    {
        if (mmeta->meta_unittests_enabled())
        {
            SWSS_LOG_NOTICE("unittests enabled, SET could be performed on %s, not recalculating", meta->attridname);

            return SAI_STATUS_SUCCESS;
        }
    }
    else
    {
        SWSS_LOG_WARN("meta pointer expired");
    }

    SWSS_LOG_WARN("need to recalculate RO: %s", meta->attridname);

    return SAI_STATUS_NOT_IMPLEMENTED;
}

void SwitchStateBase::processFdbEntriesForAging()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_DEBUG("fdb infos to process: %zu", m_fdb_info_set.size());

    uint32_t current = (uint32_t)time(NULL);

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_FDB_AGING_TIME;

    sai_status_t status = get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr);

    if (status != SAI_STATUS_SUCCESS)
    {
        SWSS_LOG_WARN("failed to get FDB aging time for switch %s",
                sai_serialize_object_id(m_switch_id).c_str());

        return;
    }

    uint32_t aging_time = attr.value.u32;

    if (aging_time == 0)
    {
        SWSS_LOG_DEBUG("aging is disabled");
        return;
    }

    // find aged fdb entries

    for (auto it = m_fdb_info_set.begin(); it != m_fdb_info_set.end();)
    {
        if ((current - it->getTimestamp()) >= aging_time)
        {
            FdbInfo fi = *it;

            processFdbInfo(fi, SAI_FDB_EVENT_AGED);

            it = m_fdb_info_set.erase(it);
        }
        else
        {
            ++it;
        }
    }
}

bool SwitchStateBase::isPortReadyToBeRemove(
        _In_ sai_object_id_t portId)
{
    SWSS_LOG_ENTER();

    std::vector<sai_object_id_t> dep;

    auto status = check_port_dependencies(portId, dep);

    return status == SAI_STATUS_SUCCESS;
}

std::vector<sai_object_id_t> SwitchStateBase::getPortDependencies(
        _In_ sai_object_id_t portId)
{
    SWSS_LOG_ENTER();

    std::vector<sai_object_id_t> dep;

    check_port_dependencies(portId, dep);

    return dep;
}

bool SwitchStateBase::check_port_reference_count(
        _In_ sai_object_id_t port_id)
{
    SWSS_LOG_ENTER();

    // TODO make generic

    // TODO currently when switch is initialized, there is no metadata yet
    // and objects are created without reference count, this needs to be
    // addressed in refactoring metadata and meta_create_oid to correct
    // count references, but now we need to check if port is used in any
    // bridge port (and bridge port in any vlan member), after metadata
    // refactor this function can be removed.

    // check if port is used on any bridge port object (only switch init one
    // matters, user created bridge ports will have correct reference count

    auto& bridgePorts = m_objectHash.at(SAI_OBJECT_TYPE_BRIDGE_PORT);

    auto* meta = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_BRIDGE_PORT, SAI_BRIDGE_PORT_ATTR_PORT_ID);

    for (auto& bp: bridgePorts)
    {
        for (auto&attr: bp.second)
        {
            if (attr.first != meta->attridname)
                continue; // not this attribute

            if (attr.second->getAttr()->value.oid == port_id)
            {
                SWSS_LOG_ERROR("port id %s is in use on bridge port %s",
                        sai_serialize_object_id(port_id).c_str(),
                        bp.first.c_str());

                return false;
            }
        }
    }

    auto& serdeses = m_objectHash.at(SAI_OBJECT_TYPE_PORT_SERDES);

    meta = sai_metadata_get_attr_metadata(SAI_OBJECT_TYPE_PORT_SERDES, SAI_PORT_SERDES_ATTR_PORT_ID);

    for (auto& ps: serdeses)
    {
        for (auto&attr: ps.second)
        {
            if (attr.first != meta->attridname)
                continue; // not this attribute

            if (attr.second->getAttr()->value.oid == port_id)
            {
                SWSS_LOG_ERROR("port id %s is in use on port serdes %s",
                        sai_serialize_object_id(port_id).c_str(),
                        ps.first.c_str());

                return false;
            }
        }
    }

    return true;
}

sai_status_t SwitchStateBase::check_port_dependencies(
        _In_ sai_object_id_t port_id,
        _Out_ std::vector<sai_object_id_t>& dep)
{
    SWSS_LOG_ENTER();

    // check if port exists's

    sai_object_id_t switch_id = switchIdQuery(port_id);

    if (switch_id == SAI_NULL_OBJECT_ID)
    {
        SWSS_LOG_ERROR("failed to obtain switch_id from object %s",
                sai_serialize_object_id(port_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    sai_object_type_t ot = objectTypeQuery(port_id);

    if (ot != SAI_OBJECT_TYPE_PORT)
    {
        SWSS_LOG_ERROR("expected object type PORT but object %s has type %s",
                sai_serialize_object_id(port_id).c_str(),
                sai_serialize_object_type(ot).c_str());

        return SAI_STATUS_FAILURE;
    }

    std::string str_port_id = sai_serialize_object_id(port_id);

    auto &objectHash = m_objectHash.at(ot);

    auto it = objectHash.find(str_port_id);

    if (it == objectHash.end())
    {
        SWSS_LOG_ERROR("port not found %s:%s",
                sai_serialize_object_type(ot).c_str(),
                str_port_id.c_str());

        return SAI_STATUS_ITEM_NOT_FOUND;
    }

    // port was found
    SWSS_LOG_NOTICE("port %s found, for removal",
            sai_serialize_object_id(port_id).c_str());

    // check port reference count on bridge port

    if (!check_port_reference_count(port_id))
    {
        SWSS_LOG_ERROR("port %s reference count IS NOT ZERO, can't remove, remove dependencies first",
                sai_serialize_object_id(port_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    // obtain objects to examine

    std::vector<sai_object_id_t> queues;
    std::vector<sai_object_id_t> ipgs;
    std::vector<sai_object_id_t> sg;

    bool result = true;

    result &= get_port_queues(port_id, queues);
    result &= get_port_ipgs(port_id, ipgs);
    result &= get_port_sg(port_id, sg);

    if (!result)
    {
        SWSS_LOG_ERROR("failed to obtain required objects on port %s",
                sai_serialize_object_id(port_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    // check if all objects are in default state

    result &= check_object_default_state(port_id);
    result &= check_object_list_default_state(queues);
    result &= check_object_list_default_state(ipgs);
    result &= check_object_list_default_state(sg);

    if (!result)
    {
        SWSS_LOG_ERROR("one of objects is not in default state, can't remove port %s",
                sai_serialize_object_id(port_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    SWSS_LOG_NOTICE("all depending objects on port %s are in default state",
            sai_serialize_object_id(port_id).c_str());

    dep.insert(dep.end(), queues.begin(), queues.end());
    dep.insert(dep.end(), ipgs.begin(), ipgs.end());
    dep.insert(dep.end(), sg.begin(), sg.end());

    // BRIDGE PORT (and also VLAN MEMBER using that bridge port) must be
    // removed before removing port itself, since bridge port holds reference
    // to port being removed.

    // bridge ports and vlan members must be removed before port can be removed

    return SAI_STATUS_SUCCESS;
}


bool SwitchStateBase::get_object_list(
        _In_ sai_object_id_t object_id,
        _In_ sai_attr_id_t attr_id,
        _Out_ std::vector<sai_object_id_t>& objlist)
{
    SWSS_LOG_ENTER();

    objlist.clear();

    sai_object_type_t object_type = objectTypeQuery(object_id);

    auto* meta = sai_metadata_get_attr_metadata(object_type, attr_id);

    if (meta == nullptr)
    {
        SWSS_LOG_THROW("failed to get metadata for OID %s and attrid: %d",
                sai_serialize_object_id(object_id).c_str(),
                attr_id);
    }

    if (meta->attrvaluetype != SAI_ATTR_VALUE_TYPE_OBJECT_LIST)
    {
        SWSS_LOG_THROW("attr %s is not objlist attribute", meta->attridname);
    }

    sai_status_t status;

    sai_attribute_t attr;

    objlist.resize(MAX_OBJLIST_LEN);

    attr.id = attr_id;

    attr.value.objlist.count = MAX_OBJLIST_LEN;
    attr.value.objlist.list = objlist.data();

    status = get(object_type, object_id, 1, &attr);

    if (status != SAI_STATUS_SUCCESS)
    {
        SWSS_LOG_ERROR("failed to obtain %s for %s queues: %s",
                meta->attridname,
                sai_serialize_object_id(object_id).c_str(),
                sai_serialize_status(status).c_str());

        objlist.clear();
        return false;
    }

    objlist.resize(attr.value.objlist.count);

    SWSS_LOG_NOTICE("%s returned %zu objects for %s",
            meta->attridname,
            objlist.size(),
            sai_serialize_object_id(object_id).c_str());

    return true;
}

bool SwitchStateBase::get_port_queues(
        _In_ sai_object_id_t port_id,
        _Out_ std::vector<sai_object_id_t>& queues)
{
    SWSS_LOG_ENTER();

    return get_object_list(port_id, SAI_PORT_ATTR_QOS_QUEUE_LIST, queues);
}

bool SwitchStateBase::get_port_ipgs(
        _In_ sai_object_id_t port_id,
        _Out_ std::vector<sai_object_id_t>& ipgs)
{
    SWSS_LOG_ENTER();

    return get_object_list(port_id, SAI_PORT_ATTR_INGRESS_PRIORITY_GROUP_LIST, ipgs);
}

bool SwitchStateBase::get_port_sg(
        _In_ sai_object_id_t port_id,
        _Out_ std::vector<sai_object_id_t>& sg)
{
    SWSS_LOG_ENTER();

    // scheduler groups are organized in tree, but
    // SAI_PORT_ATTR_INGRESS_PRIORITY_GROUP_LIST should return all scheduler groups in that tree

    return get_object_list(port_id, SAI_PORT_ATTR_QOS_SCHEDULER_GROUP_LIST, sg);
}

bool SwitchStateBase::check_object_default_state(
        _In_ sai_object_id_t object_id)
{
    SWSS_LOG_ENTER();

    sai_object_type_t object_type = objectTypeQuery(object_id);

    if (object_type == SAI_OBJECT_TYPE_NULL)
    {
        SWSS_LOG_ERROR("failed to get object type for oid: %s",
                sai_serialize_object_id(object_id).c_str());

        return false;
    }

    auto* oti = sai_metadata_get_object_type_info(object_type);

    if (oti == nullptr)
    {
        SWSS_LOG_THROW("failed to get object type info for object type: %s",
                sai_serialize_object_type(object_type).c_str());
    }

    // iterate over all attributes

    for (size_t i = 0; i < oti->attrmetadatalength; i++)
    {
        auto* meta = oti->attrmetadata[i];

        // skip readonly, mandatory on create and non oid attributes

        if (meta->isreadonly)
            continue;

        if (!meta->isoidattribute)
            continue;

        if (meta->ismandatoryoncreate && meta->iscreateonly)
            continue;

        // those attributes must be skipped since those dependencies will be automatically broken
        if (meta->objecttype == SAI_OBJECT_TYPE_SCHEDULER_GROUP && meta->attrid == SAI_SCHEDULER_GROUP_ATTR_PORT_ID)
            continue;

        if (meta->objecttype == SAI_OBJECT_TYPE_SCHEDULER_GROUP && meta->attrid == SAI_SCHEDULER_GROUP_ATTR_PARENT_NODE)
            continue;

        if (meta->objecttype == SAI_OBJECT_TYPE_QUEUE && meta->attrid == SAI_QUEUE_ATTR_PORT)
            continue;

        if (meta->objecttype == SAI_OBJECT_TYPE_QUEUE && meta->attrid == SAI_QUEUE_ATTR_PARENT_SCHEDULER_NODE)
            continue;

        if (meta->objecttype == SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP && meta->attrid == SAI_INGRESS_PRIORITY_GROUP_ATTR_PORT)
            continue;

        // here we have only oid/object list attrs and we expect each of this
        // attribute will be in default state which for oid is usually NULL,
        // and for object list is empty

        sai_attribute_t attr;

        attr.id = meta->attrid;

        sai_status_t status;

        std::vector<sai_object_id_t> objlist;

        if (meta->attrvaluetype == SAI_ATTR_VALUE_TYPE_OBJECT_ID)
        {
            // ok
        }
        else if (meta->attrvaluetype == SAI_ATTR_VALUE_TYPE_OBJECT_LIST)
        {
            objlist.resize(MAX_OBJLIST_LEN);

            attr.value.objlist.count = MAX_OBJLIST_LEN;
            attr.value.objlist.list = objlist.data();
        }
        else
        {
            // unable to check whether object is in default state, need fix

            SWSS_LOG_ERROR("unsupported oid attribute: %s, FIX ME!", meta->attridname);
            return false;
        }

        status = get(object_type, object_id, 1, &attr);

        switch (status)
        {
            case SAI_STATUS_NOT_IMPLEMENTED:
            case SAI_STATUS_NOT_SUPPORTED:
                continue;

            case SAI_STATUS_SUCCESS:
                break;

            default:

                SWSS_LOG_ERROR("unexpected status %s on %s obj %s",
                        sai_serialize_status(status).c_str(),
                        meta->attridname,
                        sai_serialize_object_id(object_id).c_str());
                return false;

        }


        if (meta->attrvaluetype == SAI_ATTR_VALUE_TYPE_OBJECT_ID)
        {
            if (attr.value.oid != SAI_NULL_OBJECT_ID)
            {
                SWSS_LOG_ERROR("expected null object id on %s on %s, but got: %s",
                        meta->attridname,
                        sai_serialize_object_id(object_id).c_str(),
                        sai_serialize_object_id(attr.value.oid).c_str());

                return false;
            }

        }
        else if (meta->attrvaluetype == SAI_ATTR_VALUE_TYPE_OBJECT_LIST)
        {
            if (objlist.size())
            {
                SWSS_LOG_ERROR("expected empty list on %s on %s, contents:",
                        meta->attridname,
                        sai_serialize_object_id(object_id).c_str());

                for (auto oid: objlist)
                {
                    SWSS_LOG_ERROR(" - oid: %s", sai_serialize_object_id(oid).c_str());
                }

                return false;
            }
        }
        else
        {
            // unable to check whether object is in default state, need fix

            SWSS_LOG_ERROR("unsupported oid attribute: %s, FIX ME!", meta->attridname);
            return false;
        }
    }

    // XXX later there can be issue when we for example add extra queues to
    // the port those new queues should be removed by user first before
    // removing port, and currently we don't have a way to differentiate those

    // object is in default state
    return true;
}

bool SwitchStateBase::check_object_list_default_state(
        _Out_ const std::vector<sai_object_id_t>& objlist)
{
    SWSS_LOG_ENTER();

    return std::all_of(objlist.begin(), objlist.end(),
            [&](sai_object_id_t oid) { return check_object_default_state(oid); });
}

std::string SwitchStateBase::dump_switch_database_for_warm_restart() const
{
    SWSS_LOG_ENTER();

    std::stringstream ss;

    const auto& objectHash = m_objectHash;

    // dump all objects and attributes to file

    size_t count = 0;

    for (auto kvp: objectHash)
    {
        auto singleTypeObjectMap = kvp.second;

        count += singleTypeObjectMap.size();

        for (auto o: singleTypeObjectMap)
        {
            // if object don't have attributes, size can be zero
            if (o.second.size() == 0)
            {
                ss << sai_serialize_object_type(kvp.first) << " " << o.first << " NULL NULL" << std::endl;
                continue;
            }

            for (auto a: o.second)
            {
                ss << sai_serialize_object_type(kvp.first) << " ";
                ss << o.first.c_str();
                ss << " ";
                ss << a.first.c_str();
                ss << " ";
                ss << a.second->getAttrStrValue();
                ss << std::endl;
            }
        }
    }

    if (m_switchConfig->m_useTapDevice)
    {
        /*
         * If user is using tap devices we also need to dump local fdb info
         * data and restore it on warm start.
         */

        for (auto fi: m_fdb_info_set)
        {
            ss << SAI_VS_FDB_INFO << " " << fi.serialize() << std::endl;
        }

        SWSS_LOG_NOTICE("dumped %zu fdb infos for switch %s",
                m_fdb_info_set.size(),
                sai_serialize_object_id(m_switch_id).c_str());
    }

    SWSS_LOG_NOTICE("dumped %zu objects from switch %s",
            count,
            sai_serialize_object_id(m_switch_id).c_str());

    return ss.str();
}

sai_object_type_t SwitchStateBase::objectTypeQuery(
        _In_ sai_object_id_t objectId)
{
    SWSS_LOG_ENTER();

    return RealObjectIdManager::objectTypeQuery(objectId);
}

sai_object_id_t SwitchStateBase::switchIdQuery(
        _In_ sai_object_id_t objectId)
{
    SWSS_LOG_ENTER();

    return RealObjectIdManager::switchIdQuery(objectId);
}

void SwitchStateBase::debugSetStats(
        _In_ sai_object_id_t oid,
        _In_ const std::map<sai_stat_id_t, uint64_t>& stats)
{
    SWSS_LOG_ENTER();

    auto key = sai_serialize_object_id(oid);

    for (auto& kvp: stats)
    {
        m_countersMap[key][kvp.first] = kvp.second;
    }
}

sai_status_t SwitchStateBase::initialize_voq_switch_objects(
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    bool voq_switch = false;
    int32_t voq_switch_id = -1;
    uint32_t voq_max_cores = 0;
    uint32_t sys_port_count = 0;
    sai_system_port_config_t *sys_port_cfg_list = NULL;

    for (uint32_t i = 0; i < attr_count; i++)
    {
        switch (attr_list[i].id)
        {
            case SAI_SWITCH_ATTR_TYPE:

                if (attr_list[i].value.u32 != SAI_SWITCH_TYPE_VOQ)
                {
                    // Switch is not being set as VOQ type.
                    SWSS_LOG_NOTICE("initialize_voq_switch_objects the value is %d", attr_list[i].value.u32);
                    if (attr_list[i].value.u32 == SAI_SWITCH_TYPE_FABRIC)
                    {
                       SWSS_LOG_NOTICE("about to config fabric ports");
                       if (m_switchConfig->m_fabricLaneMap)
                       {
                          CHECK_STATUS(create_fabric_ports());
                          CHECK_STATUS(set_fabric_port_list());
                       }
                    }
                    return SAI_STATUS_SUCCESS;
                }
                else
                {
                    voq_switch = true;
                }

                break;

            case SAI_SWITCH_ATTR_SWITCH_ID:

                voq_switch_id = (int32_t) attr_list[i].value.u32;

                if (voq_switch_id < 0)
                {
                    SWSS_LOG_ERROR("Invalid VOQ switch id %d", voq_switch_id);

                    return (int32_t)SAI_STATUS_INVALID_ATTR_VALUE_0 + (int32_t)i;
                }

                break;

            case SAI_SWITCH_ATTR_MAX_SYSTEM_CORES:

                voq_max_cores = attr_list[i].value.u32;

                if (voq_max_cores < 1)
                {
                    SWSS_LOG_ERROR("Invalid VOQ max system cores %d", voq_max_cores);

                    return (int32_t)SAI_STATUS_INVALID_ATTR_VALUE_0 + (int32_t)i;
                }

                break;

            case SAI_SWITCH_ATTR_SYSTEM_PORT_CONFIG_LIST:

                sys_port_count = attr_list[i].value.sysportconfiglist.count;
                sys_port_cfg_list = attr_list[i].value.sysportconfiglist.list;

                if (sys_port_count < 1 || !sys_port_cfg_list)
                {
                    SWSS_LOG_ERROR("Invalid voq system port config info! sys port count %d, sys port list %p", sys_port_count, sys_port_cfg_list);

                    return (int32_t)SAI_STATUS_INVALID_ATTR_VALUE_0 + (int32_t)i;
                }

                break;

            default:
                // Ignore other attributes. They are processed elsewhere.
                break;
        }
    }

    if (!voq_switch)
    {
        // No switch type attribute in the attribute list.
        return SAI_STATUS_SUCCESS;
    }

    CHECK_STATUS(create_system_ports(voq_switch_id, sys_port_count, sys_port_cfg_list));
    CHECK_STATUS(create_voqs());

    CHECK_STATUS(set_system_port_list());

    if (m_switchConfig->m_fabricLaneMap)
    {
        CHECK_STATUS(create_fabric_ports());

        CHECK_STATUS(set_fabric_port_list());
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::filter_available_lanes(
                    _Inout_ std::vector<std::vector<uint32_t>> &lanes_vector)
{
    SWSS_LOG_ENTER();

    auto lanes = lanes_vector.begin();

    while (lanes != lanes_vector.end())
    {
        bool available_lane = false;

        for (auto lane: *lanes)
        {
            std::string ifname = m_switchConfig->m_laneMap->getInterfaceFromLaneNumber(lane);
            std::string path = std::string("/sys/class/net/") + ifname + "/operstate";

            if (access(path.c_str(), F_OK) != 0)
            {
                SWSS_LOG_WARN("Port %s isn't available", ifname.c_str());

                available_lane &= false;

                break;
            }
            else
            {
                available_lane = true;
            }
        }

        if (!available_lane)
        {
            lanes = lanes_vector.erase(lanes);
        }
        else
        {
            lanes++;
        }
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_voq_per_sysport(
        _In_ sai_object_id_t sys_port_id)
{
    SWSS_LOG_ENTER();

    sai_attribute_t attr;

    const uint32_t voq_count = 8;

    std::vector<sai_object_id_t> voqs;

    for (uint32_t i = 0; i < voq_count; ++i)
    {
        sai_object_id_t voq_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_QUEUE, &voq_id, m_switch_id, 0, NULL));
        voqs.push_back(voq_id);

        attr.id = SAI_QUEUE_ATTR_TYPE;
        attr.value.s32 = SAI_QUEUE_TYPE_UNICAST_VOQ;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_QUEUE, voq_id, &attr));

        attr.id = SAI_QUEUE_ATTR_INDEX;
        attr.value.u8 = (uint8_t)i;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_QUEUE, voq_id, &attr));
    }

    attr.id = SAI_SYSTEM_PORT_ATTR_QOS_NUMBER_OF_VOQS;
    attr.value.u32 = voq_count;

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SYSTEM_PORT, sys_port_id, &attr));

    attr.id = SAI_SYSTEM_PORT_ATTR_QOS_VOQ_LIST;
    attr.value.objlist.count = voq_count;
    attr.value.objlist.list = voqs.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SYSTEM_PORT, sys_port_id, &attr));

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_voqs()
{
    SWSS_LOG_ENTER();

    for (auto &sys_port_id: m_system_port_list)
    {
        CHECK_STATUS(create_voq_per_sysport(sys_port_id));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_system_ports(
        _In_ int32_t voq_switch_id,
        _In_ uint32_t sys_port_count,
        _In_ const sai_system_port_config_t *sys_port_cfg_list)
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create system ports");

    if (!sys_port_cfg_list)
    {
        return SAI_STATUS_FAILURE;
    }

    m_system_port_list.clear();

    for (uint32_t i = 0; i < sys_port_count; i++)
    {
        SWSS_LOG_DEBUG("create system port index %u", i);

        sai_object_id_t system_port_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_SYSTEM_PORT, &system_port_id, m_switch_id, 0, NULL));

        m_system_port_list.push_back(system_port_id);

        sai_attribute_t attr;

        attr.id = SAI_SYSTEM_PORT_ATTR_CONFIG_INFO;
        attr.value.sysportconfig = sys_port_cfg_list[i];

        CHECK_STATUS(set(SAI_OBJECT_TYPE_SYSTEM_PORT, system_port_id, &attr));

        attr.id = SAI_SYSTEM_PORT_ATTR_TYPE;
        attr.value.s32 = SAI_SYSTEM_PORT_TYPE_REMOTE;

        if ((int32_t)sys_port_cfg_list[i].attached_switch_id == voq_switch_id)
        {
            attr.value.s32 = SAI_SYSTEM_PORT_TYPE_LOCAL;

            // This is system port of local port. Set the oid of the local port corresponding to this system port

            auto map = m_switchConfig->m_corePortIndexMap;

            if (map)
            {
                auto& corePortIndexVector = map->getCorePortIndexVector();
                size_t n_map = corePortIndexVector.size();
                size_t idx;

                for (idx = 0; idx < n_map; idx++)
                {
                    if (corePortIndexVector[idx][0] == sys_port_cfg_list[i].attached_core_index &&
                            corePortIndexVector[idx][1] == sys_port_cfg_list[i].attached_core_port_index &&
                            idx < m_port_list.size())
                    {
                        // m_port_list entries are in the same order as lane maps. The core port index maps are in the
                        // same order as the lane maps. So m_port_list at the index corresponding to the core port index map
                        // will be the port corresponding to the system port with core port index matching core port index map

                        sai_attribute_t lp_attr;

                        lp_attr.id = SAI_SYSTEM_PORT_ATTR_PORT;
                        lp_attr.value.oid = m_port_list.at(idx);

                        CHECK_STATUS(set(SAI_OBJECT_TYPE_SYSTEM_PORT, system_port_id, &lp_attr));

                        break;
                    }
                }

                if (idx >= n_map)
                {
                    SWSS_LOG_ERROR("Core port index not found for system port %d for switch %s. Local port oid is not set!",
                            sys_port_cfg_list[i].port_id,
                            sai_serialize_object_id(m_switch_id).c_str());
                }
            }
            else
            {
                SWSS_LOG_ERROR("Core port index map for switch %s is NULL. Local port oid is not set for system port %d!",
                        sai_serialize_object_id(m_switch_id).c_str(),
                        sys_port_cfg_list[i].port_id);
            }
        }

        CHECK_STATUS(set(SAI_OBJECT_TYPE_SYSTEM_PORT, system_port_id, &attr));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set_system_port_list()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set system port list");

    // NOTE: this is static, but will be refreshed on read only get

    sai_attribute_t attr;

    uint32_t sys_port_count = (uint32_t)m_system_port_list.size();

    attr.id = SAI_SWITCH_ATTR_SYSTEM_PORT_LIST;
    attr.value.objlist.count = sys_port_count;
    attr.value.objlist.list = m_system_port_list.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_NUMBER_OF_SYSTEM_PORTS;
    attr.value.u32 = sys_port_count;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::refresh_system_port_list(
        _In_ const sai_attr_metadata_t *meta)
{
    SWSS_LOG_ENTER();

    // Currently, system ports info are not changing. So no refresh is done

    // TODO In the future, when dynamic system port config (add/delete) is implemented, re-visit

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::create_fabric_ports()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("create fabric ports");

    auto map = m_switchConfig->m_fabricLaneMap;

    if (!map)
    {
        SWSS_LOG_ERROR("fabric lane map for switch %s is NULL",
                sai_serialize_object_id(m_switch_id).c_str());

        return SAI_STATUS_FAILURE;
    }

    auto& lanesVector = map->getLaneVector();

    uint32_t fabric_port_count = (uint32_t)lanesVector.size();

    m_fabric_port_list.clear();

    for (uint32_t i = 0; i < fabric_port_count; i++)
    {
        SWSS_LOG_DEBUG("create fabric port index %u", i);

        sai_object_id_t fabric_port_id;

        CHECK_STATUS(create(SAI_OBJECT_TYPE_PORT, &fabric_port_id, m_switch_id, 0, NULL));
        m_fabric_port_list.push_back(fabric_port_id);

        sai_attribute_t attr;

        attr.id = SAI_PORT_ATTR_FABRIC_ATTACHED;
        attr.value.booldata = true;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, fabric_port_id, &attr));

        std::vector<uint32_t> lanes = lanesVector.at(i);

        attr.id = SAI_PORT_ATTR_HW_LANE_LIST;
        attr.value.u32list.count = (uint32_t)lanes.size();
        attr.value.u32list.list = lanes.data();

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, fabric_port_id, &attr));

        attr.id = SAI_PORT_ATTR_TYPE;
        attr.value.s32 = SAI_PORT_TYPE_FABRIC;

        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, fabric_port_id, &attr));

        attr.id = SAI_PORT_ATTR_FABRIC_ATTACHED_SWITCH_ID;
        attr.value.s32 = i;
        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, fabric_port_id, &attr));

        attr.id = SAI_PORT_ATTR_FABRIC_ATTACHED_PORT_INDEX;
        attr.value.s32 = i;
        CHECK_STATUS(set(SAI_OBJECT_TYPE_PORT, fabric_port_id, &attr));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::set_fabric_port_list()
{
    SWSS_LOG_ENTER();

    SWSS_LOG_INFO("set fabric port list");

    sai_attribute_t attr;

    uint32_t fabric_port_count = (uint32_t)m_fabric_port_list.size();

    attr.id = SAI_SWITCH_ATTR_FABRIC_PORT_LIST;
    attr.value.objlist.count = fabric_port_count;
    attr.value.objlist.list = m_fabric_port_list.data();

    CHECK_STATUS(set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr));

    attr.id = SAI_SWITCH_ATTR_NUMBER_OF_FABRIC_PORTS;
    attr.value.u32 = fabric_port_count;

    return set(SAI_OBJECT_TYPE_SWITCH, m_switch_id, &attr);
}

sai_status_t SwitchStateBase::createVoqSystemNeighborEntry(
        _In_ const std::string &serializedObjectId,
        _In_ sai_object_id_t switch_id,
        _In_ uint32_t attr_count,
        _In_ const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    // For VOQ switch, encap index attribute should be set for local neighbors. For
    // remote neighbors check for presence of encap index supplied from upper layer.
    // And also validate isLocal and impose encap index flags in the attribute list

    // Determine whether this neighbor is local neighbor or remote neighbor by checking the
    // RIF id provided. If the port of the RIF is system port, the neighbor is remote neighbor

    bool is_system_neigh = false;
    sai_attribute_t attr;
    sai_neighbor_entry_t nbr_entry;

    sai_deserialize_neighbor_entry(serializedObjectId, nbr_entry);

    attr.id = SAI_ROUTER_INTERFACE_ATTR_PORT_ID;

    CHECK_STATUS(get(SAI_OBJECT_TYPE_ROUTER_INTERFACE, nbr_entry.rif_id, 1, &attr));

    if (objectTypeQuery(attr.value.oid) == SAI_OBJECT_TYPE_SYSTEM_PORT)
    {
        is_system_neigh = true;
    }

    uint32_t encap_index = 0;
    bool impose_encap_index = false;
    bool is_local = true;

    for (uint32_t i = 0; i < attr_count; i++)
    {
        switch (attr_list[i].id)
        {
            case SAI_NEIGHBOR_ENTRY_ATTR_ENCAP_INDEX:

                encap_index = attr_list[i].value.u32;

                break;

            case SAI_NEIGHBOR_ENTRY_ATTR_ENCAP_IMPOSE_INDEX:

                impose_encap_index = attr_list[i].value.booldata;

                break;

            case SAI_NEIGHBOR_ENTRY_ATTR_IS_LOCAL:

                is_local = attr_list[i].value.booldata;

                break;

            default:
                break;
        }
    }

    if (impose_encap_index && encap_index == 0)
    {
        SWSS_LOG_ERROR("Impose invalid encap index %d for %s neigh %s",
                encap_index,
                (is_system_neigh ? "VOQ" : "local"),
                serializedObjectId.c_str());

        return SAI_STATUS_FAILURE;
    }

    if (is_system_neigh && is_local)
    {
        SWSS_LOG_ERROR("VOQ neigh info mismatch for %s. RIF is remote. attr is_local is true", serializedObjectId.c_str());

        return SAI_STATUS_FAILURE;
    }

    if (!is_local && encap_index == 0)
    {
        SWSS_LOG_ERROR("VOQ neigh info mismatch for %s. attr is_local is false. encap_index is 0", serializedObjectId.c_str());

        return SAI_STATUS_FAILURE;
    }

    CHECK_STATUS(create_internal(SAI_OBJECT_TYPE_NEIGHBOR_ENTRY, serializedObjectId, switch_id, attr_count, attr_list));

    if (impose_encap_index == false)
    {
        // Encap index is not imposed. Assign encap index.
        // The only requirement for the encap index is it must be locally
        // unique in asic. Lower 32 bits of the ip address is used as encap index

        encap_index = nbr_entry.ip_address.addr.ip4;

        attr.id = SAI_NEIGHBOR_ENTRY_ATTR_ENCAP_INDEX;
        attr.value.u32 = encap_index;

        CHECK_STATUS(set_internal(SAI_OBJECT_TYPE_NEIGHBOR_ENTRY, serializedObjectId, &attr));
    }

    return SAI_STATUS_SUCCESS;
}

void SwitchStateBase::findObjects(
        _In_ sai_object_type_t object_type,
        _In_ const sai_attribute_t &expect,
        _Out_ std::vector<sai_object_id_t> &objects)
{
    SWSS_LOG_ENTER();

    objects.clear();

    SaiAttrWrap expect_wrap(object_type, &expect);

    for (auto &obj : m_objectHash.at(object_type))
    {
        auto attr_itr = obj.second.find(expect_wrap.getAttrMetadata()->attridname);

        if (attr_itr != obj.second.end()
                && attr_itr->second->getAttrStrValue() == expect_wrap.getAttrStrValue())
        {
            sai_object_id_t object_id;
            sai_deserialize_object_id(obj.first, object_id);
            objects.push_back(object_id);
        }
    }
}

bool SwitchStateBase::dumpObject(
        _In_ const sai_object_id_t object_id,
        _Out_ std::vector<sai_attribute_t> &attrs)
{
    SWSS_LOG_ENTER();

    attrs.clear();

    auto &objs = m_objectHash.at(objectTypeQuery(object_id));
    auto obj = objs.find(sai_serialize_object_id(object_id));

    if (obj == objs.end())
    {
        return false;
    }

    for (auto &attr : obj->second)
    {
        attrs.push_back(*attr.second->getAttr());
    }

    return true;
}

sai_status_t SwitchStateBase::queryTunnelPeerModeCapability(
                   _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (enum_values_capability->count < 2)
    {
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    enum_values_capability->count = 2;
    enum_values_capability->list[0] = SAI_TUNNEL_PEER_MODE_P2MP;
    enum_values_capability->list[1] = SAI_TUNNEL_PEER_MODE_P2P;
    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryPortAutonegFecOverrideSupportCapability(
                   _Out_ sai_attr_capability_t *attr_capability)
{
    SWSS_LOG_ENTER();

    attr_capability->create_implemented = false;
    attr_capability->set_implemented    = false;
    attr_capability->get_implemented    = false;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryVlanfloodTypeCapability(
                   _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (enum_values_capability->count < 3)
    {
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    enum_values_capability->count = 3;
    enum_values_capability->list[0] = SAI_VLAN_FLOOD_CONTROL_TYPE_ALL;
    enum_values_capability->list[1] = SAI_VLAN_FLOOD_CONTROL_TYPE_NONE;
    enum_values_capability->list[2] = SAI_VLAN_FLOOD_CONTROL_TYPE_L2MC_GROUP;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryNextHopGroupTypeCapability(
                   _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (enum_values_capability->count < 5)
    {
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    enum_values_capability->count = 5;
    enum_values_capability->list[0] = SAI_NEXT_HOP_GROUP_TYPE_DYNAMIC_UNORDERED_ECMP;
    enum_values_capability->list[1] = SAI_NEXT_HOP_GROUP_TYPE_DYNAMIC_ORDERED_ECMP;
    enum_values_capability->list[2] = SAI_NEXT_HOP_GROUP_TYPE_FINE_GRAIN_ECMP;
    enum_values_capability->list[3] = SAI_NEXT_HOP_GROUP_TYPE_PROTECTION;
    enum_values_capability->list[4] = SAI_NEXT_HOP_GROUP_TYPE_CLASS_BASED;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryHashNativeHashFieldListCapability(
                   _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (enum_values_capability->count < 19)
    {
        enum_values_capability->count = 19;
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    enum_values_capability->count = 19;
    enum_values_capability->list[0] = SAI_NATIVE_HASH_FIELD_IN_PORT;
    enum_values_capability->list[1] = SAI_NATIVE_HASH_FIELD_DST_MAC;
    enum_values_capability->list[2] = SAI_NATIVE_HASH_FIELD_SRC_MAC;
    enum_values_capability->list[3] = SAI_NATIVE_HASH_FIELD_ETHERTYPE;
    enum_values_capability->list[4] = SAI_NATIVE_HASH_FIELD_VLAN_ID;
    enum_values_capability->list[5] = SAI_NATIVE_HASH_FIELD_IP_PROTOCOL;
    enum_values_capability->list[6] = SAI_NATIVE_HASH_FIELD_DST_IP;
    enum_values_capability->list[7] = SAI_NATIVE_HASH_FIELD_SRC_IP;
    enum_values_capability->list[8] = SAI_NATIVE_HASH_FIELD_L4_DST_PORT;
    enum_values_capability->list[9] = SAI_NATIVE_HASH_FIELD_L4_SRC_PORT;
    enum_values_capability->list[10] = SAI_NATIVE_HASH_FIELD_INNER_DST_MAC;
    enum_values_capability->list[11] = SAI_NATIVE_HASH_FIELD_INNER_SRC_MAC;
    enum_values_capability->list[12] = SAI_NATIVE_HASH_FIELD_INNER_ETHERTYPE;
    enum_values_capability->list[13] = SAI_NATIVE_HASH_FIELD_INNER_IP_PROTOCOL;
    enum_values_capability->list[14] = SAI_NATIVE_HASH_FIELD_INNER_DST_IP;
    enum_values_capability->list[15] = SAI_NATIVE_HASH_FIELD_INNER_SRC_IP;
    enum_values_capability->list[16] = SAI_NATIVE_HASH_FIELD_INNER_L4_DST_PORT;
    enum_values_capability->list[17] = SAI_NATIVE_HASH_FIELD_INNER_L4_SRC_PORT;
    enum_values_capability->list[18] = SAI_NATIVE_HASH_FIELD_IPV6_FLOW_LABEL;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::querySwitchHashAlgorithmCapability(
                   _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (enum_values_capability->count < 7)
    {
        enum_values_capability->count = 7;
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    enum_values_capability->count = 7;
    enum_values_capability->list[0] = SAI_HASH_ALGORITHM_CRC;
    enum_values_capability->list[1] = SAI_HASH_ALGORITHM_XOR;
    enum_values_capability->list[2] = SAI_HASH_ALGORITHM_RANDOM;
    enum_values_capability->list[3] = SAI_HASH_ALGORITHM_CRC_32LO;
    enum_values_capability->list[4] = SAI_HASH_ALGORITHM_CRC_32HI;
    enum_values_capability->list[5] = SAI_HASH_ALGORITHM_CRC_CCITT;
    enum_values_capability->list[6] = SAI_HASH_ALGORITHM_CRC_XOR;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::querySwitchPacketTrimmingDscpResolutionModeCapability(
                   _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_PACKET_TRIM_DSCP_RESOLUTION_MODE_DSCP_VALUE;
    enum_values_capability->list[1] = SAI_PACKET_TRIM_DSCP_RESOLUTION_MODE_FROM_TC;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::querySwitchPacketTrimmingQueueResolutionModeCapability(
                   _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_PACKET_TRIM_QUEUE_RESOLUTION_MODE_STATIC;
    enum_values_capability->list[1] = SAI_PACKET_TRIM_QUEUE_RESOLUTION_MODE_DYNAMIC;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryBufferProfilePacketAdmissionFailActionCapability(
                   _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_BUFFER_PROFILE_PACKET_ADMISSION_FAIL_ACTION_DROP;
    enum_values_capability->list[1] = SAI_BUFFER_PROFILE_PACKET_ADMISSION_FAIL_ACTION_DROP_AND_TRIM;

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryAttrEnumValuesCapability(
                              _In_ sai_object_id_t switch_id,
                              _In_ sai_object_type_t object_type,
                              _In_ sai_attr_id_t attr_id,
                              _Inout_ sai_s32_list_t *enum_values_capability)
{
    SWSS_LOG_ENTER();

    if (object_type == SAI_OBJECT_TYPE_TUNNEL && attr_id == SAI_TUNNEL_ATTR_PEER_MODE)
    {
        return queryTunnelPeerModeCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_VLAN && (attr_id == SAI_VLAN_ATTR_UNKNOWN_UNICAST_FLOOD_CONTROL_TYPE ||
                                                     attr_id == SAI_VLAN_ATTR_UNKNOWN_MULTICAST_FLOOD_CONTROL_TYPE ||
                                                     attr_id == SAI_VLAN_ATTR_BROADCAST_FLOOD_CONTROL_TYPE))
    {
        return queryVlanfloodTypeCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_NEXT_HOP_GROUP && attr_id == SAI_NEXT_HOP_GROUP_ATTR_TYPE)
    {
        return queryNextHopGroupTypeCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_HASH && attr_id == SAI_HASH_ATTR_NATIVE_HASH_FIELD_LIST)
    {
        return queryHashNativeHashFieldListCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_SWITCH && (attr_id == SAI_SWITCH_ATTR_ECMP_DEFAULT_HASH_ALGORITHM ||
                                                       attr_id == SAI_SWITCH_ATTR_LAG_DEFAULT_HASH_ALGORITHM))
    {
        return querySwitchHashAlgorithmCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_SWITCH && attr_id == SAI_SWITCH_ATTR_PACKET_TRIM_DSCP_RESOLUTION_MODE)
    {
        return querySwitchPacketTrimmingDscpResolutionModeCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_SWITCH && attr_id == SAI_SWITCH_ATTR_PACKET_TRIM_QUEUE_RESOLUTION_MODE)
    {
        return querySwitchPacketTrimmingQueueResolutionModeCapability(enum_values_capability);
    }
    else if (object_type == SAI_OBJECT_TYPE_BUFFER_PROFILE && attr_id == SAI_BUFFER_PROFILE_ATTR_PACKET_ADMISSION_FAIL_ACTION)
    {
        return queryBufferProfilePacketAdmissionFailActionCapability(enum_values_capability);
    }

    return SAI_STATUS_NOT_SUPPORTED;
}

sai_status_t SwitchStateBase::queryMacsecPostCapability(
                              _In_ sai_object_type_t object_type,
                              _Out_ sai_attr_capability_t *attr_capability)
{
    SWSS_LOG_ENTER();

    attr_capability->create_implemented = false;
    attr_capability->set_implemented    = false;
    attr_capability->get_implemented    = false;

    std::ifstream ifs;
    ifs.open(VS_SAI_FIPS_POST_CONFIG_FILE);
    if (!ifs.is_open())
    {
        return SAI_STATUS_SUCCESS;
    }

    std::string line;
    std::string post_capability;
    while (std::getline(ifs, line))
    {
        // line format: key value
        std::istringstream iss(line);
        std::string key;
        std::string value;
        iss >> key >> value;

        if (key == "macsec-post-capability" )
        {
            post_capability = value;
        }
    }

    if ((object_type == SAI_OBJECT_TYPE_SWITCH && post_capability == "switch") ||
        (object_type == SAI_OBJECT_TYPE_MACSEC && post_capability == "macsec"))
    {
        SWSS_LOG_NOTICE("MACSEC POST capability: %s", post_capability.c_str());
        attr_capability->create_implemented = true;
    }

    ifs.close();
    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryAttributeCapability(
                              _In_ sai_object_id_t switch_id,
                              _In_ sai_object_type_t object_type,
                              _In_ sai_attr_id_t attr_id,
                              _Out_ sai_attr_capability_t *attr_capability)
{
    SWSS_LOG_ENTER();

    if (object_type == SAI_OBJECT_TYPE_PORT && attr_id == SAI_PORT_ATTR_AUTO_NEG_FEC_MODE_OVERRIDE)
    {
        return queryPortAutonegFecOverrideSupportCapability(attr_capability);
    }

    if ((object_type == SAI_OBJECT_TYPE_SWITCH && attr_id == SAI_SWITCH_ATTR_MACSEC_ENABLE_POST) ||
        (object_type == SAI_OBJECT_TYPE_MACSEC && attr_id == SAI_MACSEC_ATTR_ENABLE_POST))
    {
       return queryMacsecPostCapability(object_type, attr_capability);
    }

    attr_capability->create_implemented = true;
    attr_capability->set_implemented    = true;
    attr_capability->get_implemented    = true;

    return SAI_STATUS_SUCCESS;
}

uint64_t SwitchStateBase::getObjectTypeAvailability(
                              _In_ sai_object_type_t object_type)
{
    SWSS_LOG_ENTER();

    // Default implementation - return 0 for unsupported types
    SWSS_LOG_WARN("getObjectTypeAvailability not implemented for object type %d", object_type);
    return 0;
}

sai_status_t SwitchStateBase::querySwitchStatsCapability(
                              _Inout_ sai_stat_capability_list_t *stats_capability)
{
    SWSS_LOG_ENTER();

    static std::vector<sai_switch_stat_t> switchStatList = {
        SAI_SWITCH_STAT_ECC_DROP,
        SAI_SWITCH_STAT_PACKET_INTEGRITY_DROP,
        SAI_SWITCH_STAT_DROPPED_TRIM_PACKETS,
        SAI_SWITCH_STAT_TX_TRIM_PACKETS
    };

    if (stats_capability->count < switchStatList.size())
    {
        stats_capability->count = static_cast<uint32_t>(switchStatList.size());
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    stats_capability->count = static_cast<uint32_t>(switchStatList.size());

    for (std::uint32_t i = 0; i < switchStatList.size(); i++)
    {
        stats_capability->list[i].stat_modes = SAI_STATS_MODE_READ_AND_CLEAR | SAI_STATS_MODE_READ;
        stats_capability->list[i].stat_enum = static_cast<sai_stat_id_t>(switchStatList.at(i));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryPortStatsCapability(
                              _Inout_ sai_stat_capability_list_t *stats_capability)
{
    SWSS_LOG_ENTER();

    static std::vector<sai_port_stat_t> portStatList = {
        SAI_PORT_STAT_IF_IN_OCTETS,
        SAI_PORT_STAT_IF_IN_UCAST_PKTS,
        SAI_PORT_STAT_IF_IN_NON_UCAST_PKTS,
        SAI_PORT_STAT_IF_IN_DISCARDS,
        SAI_PORT_STAT_IF_IN_ERRORS,
        SAI_PORT_STAT_IF_IN_UNKNOWN_PROTOS,
        SAI_PORT_STAT_IF_IN_BROADCAST_PKTS,
        SAI_PORT_STAT_IF_IN_MULTICAST_PKTS,
        SAI_PORT_STAT_IF_IN_VLAN_DISCARDS,
        SAI_PORT_STAT_IF_OUT_OCTETS,
        SAI_PORT_STAT_IF_OUT_UCAST_PKTS,
        SAI_PORT_STAT_IF_OUT_NON_UCAST_PKTS,
        SAI_PORT_STAT_IF_OUT_DISCARDS,
        SAI_PORT_STAT_IF_OUT_ERRORS,
        SAI_PORT_STAT_IF_OUT_QLEN,
        SAI_PORT_STAT_IF_OUT_BROADCAST_PKTS,
        SAI_PORT_STAT_IF_OUT_MULTICAST_PKTS,
        SAI_PORT_STAT_ETHER_STATS_DROP_EVENTS,
        SAI_PORT_STAT_ETHER_STATS_MULTICAST_PKTS,
        SAI_PORT_STAT_ETHER_STATS_BROADCAST_PKTS,
        SAI_PORT_STAT_ETHER_STATS_UNDERSIZE_PKTS,
        SAI_PORT_STAT_ETHER_STATS_FRAGMENTS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_64_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_65_TO_127_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_128_TO_255_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_256_TO_511_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_512_TO_1023_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_1024_TO_1518_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_1519_TO_2047_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_2048_TO_4095_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_4096_TO_9216_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS_9217_TO_16383_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_OVERSIZE_PKTS,
        SAI_PORT_STAT_ETHER_RX_OVERSIZE_PKTS,
        SAI_PORT_STAT_ETHER_TX_OVERSIZE_PKTS,
        SAI_PORT_STAT_ETHER_STATS_JABBERS,
        SAI_PORT_STAT_ETHER_STATS_OCTETS,
        SAI_PORT_STAT_ETHER_STATS_PKTS,
        SAI_PORT_STAT_ETHER_STATS_COLLISIONS,
        SAI_PORT_STAT_ETHER_STATS_CRC_ALIGN_ERRORS,
        SAI_PORT_STAT_ETHER_STATS_TX_NO_ERRORS,
        SAI_PORT_STAT_ETHER_STATS_RX_NO_ERRORS,
        SAI_PORT_STAT_GREEN_WRED_DROPPED_PACKETS,
        SAI_PORT_STAT_GREEN_WRED_DROPPED_BYTES,
        SAI_PORT_STAT_YELLOW_WRED_DROPPED_PACKETS,
        SAI_PORT_STAT_YELLOW_WRED_DROPPED_BYTES,
        SAI_PORT_STAT_RED_WRED_DROPPED_PACKETS,
        SAI_PORT_STAT_RED_WRED_DROPPED_BYTES,
        SAI_PORT_STAT_WRED_DROPPED_PACKETS,
        SAI_PORT_STAT_WRED_DROPPED_BYTES,
        SAI_PORT_STAT_ECN_MARKED_PACKETS,
        SAI_PORT_STAT_PFC_0_RX_PKTS,
        SAI_PORT_STAT_PFC_0_TX_PKTS,
        SAI_PORT_STAT_PFC_1_RX_PKTS,
        SAI_PORT_STAT_PFC_1_TX_PKTS,
        SAI_PORT_STAT_PFC_2_RX_PKTS,
        SAI_PORT_STAT_PFC_2_TX_PKTS,
        SAI_PORT_STAT_PFC_3_RX_PKTS,
        SAI_PORT_STAT_PFC_3_TX_PKTS,
        SAI_PORT_STAT_PFC_4_RX_PKTS,
        SAI_PORT_STAT_PFC_4_TX_PKTS,
        SAI_PORT_STAT_PFC_5_RX_PKTS,
        SAI_PORT_STAT_PFC_5_TX_PKTS,
        SAI_PORT_STAT_PFC_6_RX_PKTS,
        SAI_PORT_STAT_PFC_6_TX_PKTS,
        SAI_PORT_STAT_PFC_7_RX_PKTS,
        SAI_PORT_STAT_PFC_7_TX_PKTS,
        SAI_PORT_STAT_PFC_0_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_0_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_1_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_1_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_2_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_2_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_3_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_3_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_4_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_4_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_5_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_5_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_6_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_6_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_7_RX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_7_TX_PAUSE_DURATION_US,
        SAI_PORT_STAT_PFC_0_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_1_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_2_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_3_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_4_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_5_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_6_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_PFC_7_ON2OFF_RX_PKTS,
        SAI_PORT_STAT_TRIM_PACKETS,
        SAI_PORT_STAT_DROPPED_TRIM_PACKETS,
        SAI_PORT_STAT_TX_TRIM_PACKETS
    };

    if (stats_capability->count < portStatList.size())
    {
        stats_capability->count = static_cast<uint32_t>(portStatList.size());
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    stats_capability->count = static_cast<uint32_t>(portStatList.size());

    for (std::uint32_t i = 0; i < portStatList.size(); i++)
    {
        stats_capability->list[i].stat_modes = SAI_STATS_MODE_READ_AND_CLEAR | SAI_STATS_MODE_READ;
        stats_capability->list[i].stat_enum = static_cast<sai_stat_id_t>(portStatList.at(i));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryQueueStatsCapability(
                              _Inout_ sai_stat_capability_list_t *stats_capability)
{
    SWSS_LOG_ENTER();

    static std::vector<sai_queue_stat_t> queueStatList = {
        SAI_QUEUE_STAT_PACKETS,
        SAI_QUEUE_STAT_BYTES,
        SAI_QUEUE_STAT_DROPPED_PACKETS,
        SAI_QUEUE_STAT_DROPPED_BYTES,
        SAI_QUEUE_STAT_WRED_DROPPED_PACKETS,
        SAI_QUEUE_STAT_WRED_DROPPED_BYTES,
        SAI_QUEUE_STAT_CURR_OCCUPANCY_BYTES,
        SAI_QUEUE_STAT_SHARED_WATERMARK_BYTES,
        SAI_QUEUE_STAT_WRED_ECN_MARKED_PACKETS,
        SAI_QUEUE_STAT_WRED_ECN_MARKED_BYTES,
        SAI_QUEUE_STAT_CURR_OCCUPANCY_LEVEL,
        SAI_QUEUE_STAT_WATERMARK_LEVEL,
        SAI_QUEUE_STAT_CREDIT_WD_DELETED_PACKETS,
        SAI_QUEUE_STAT_TRIM_PACKETS,
        SAI_QUEUE_STAT_DROPPED_TRIM_PACKETS,
        SAI_QUEUE_STAT_TX_TRIM_PACKETS
    };

    if (stats_capability->count < queueStatList.size())
    {
        stats_capability->count = static_cast<uint32_t>(queueStatList.size());
        return SAI_STATUS_BUFFER_OVERFLOW;
    }

    stats_capability->count = static_cast<uint32_t>(queueStatList.size());

    for (std::uint32_t i = 0; i < queueStatList.size(); i++)
    {
        stats_capability->list[i].stat_modes = SAI_STATS_MODE_READ_AND_CLEAR | SAI_STATS_MODE_READ;
        stats_capability->list[i].stat_enum = static_cast<sai_stat_id_t>(queueStatList.at(i));
    }

    return SAI_STATUS_SUCCESS;
}

sai_status_t SwitchStateBase::queryStatsCapability(
                              _In_ sai_object_id_t switchId,
                              _In_ sai_object_type_t objectType,
                              _Inout_ sai_stat_capability_list_t *stats_capability)
{
    SWSS_LOG_ENTER();

    if (objectType == SAI_OBJECT_TYPE_SWITCH)
    {
        return querySwitchStatsCapability(stats_capability);
    }
    else if (objectType == SAI_OBJECT_TYPE_QUEUE)
    {
        return queryQueueStatsCapability(stats_capability);
    }
    else if (objectType == SAI_OBJECT_TYPE_PORT)
    {
        return queryPortStatsCapability(stats_capability);
    }

    return SAI_STATUS_NOT_SUPPORTED;
}

sai_status_t SwitchStateBase::queryStatsStCapability(
    _In_ sai_object_id_t switchId,
    _In_ sai_object_type_t objectType,
    _Inout_ sai_stat_st_capability_list_t *stats_st_capability)
{
    SWSS_LOG_ENTER();

    sai_stat_capability_list_t stats_capability;
    std::vector<sai_stat_capability_t> stats_list(stats_st_capability->count);
    stats_capability.count = stats_st_capability->count;
    stats_capability.list = stats_list.data();

    sai_status_t status = queryStatsCapability(
        switchId,
        objectType,
        &stats_capability);

    if (status == SAI_STATUS_SUCCESS)
    {
        for (uint32_t i = 0; i < stats_capability.count; i++)
        {
            stats_st_capability->list[i].capability.stat_enum = stats_capability.list[i].stat_enum;
            stats_st_capability->list[i].capability.stat_modes = stats_capability.list[i].stat_modes;
            stats_st_capability->list[i].minimal_polling_interval = static_cast<uint64_t>(1e6 * 100);
            ; // 100ms
        }
    }
    else
    {
        SWSS_LOG_WARN("Failed to query stats capability for object type %s, status: %s",
            sai_serialize_object_type(objectType).c_str(),
            sai_serialize_status(status).c_str());
    }

    return status;
}

void SwitchStateBase::send_tam_tel_type_config_change(
    _In_ sai_object_id_t tam_tel_type_id)
{
    SWSS_LOG_ENTER();

    auto meta = getMeta();

    if (meta)
    {
        meta->meta_sai_on_tam_tel_type_config_change(tam_tel_type_id);
    }

    sai_attribute_t attr;

    attr.id = SAI_SWITCH_ATTR_TAM_TEL_TYPE_CONFIG_CHANGE_NOTIFY;

    sai_status_t status = get(SAI_OBJECT_TYPE_SWITCH, m_switch_id, 1, &attr);

    if (status != SAI_STATUS_SUCCESS)
    {
        SWSS_LOG_ERROR("unable to get SAI_SWITCH_ATTR_TAM_TEL_TYPE_CONFIG_CHANGE_NOTIFY attribute for %s",
                       sai_serialize_object_id(m_switch_id).c_str());

        return;
    }

    auto str = sai_serialize_object_id(tam_tel_type_id);

    sai_switch_notifications_t sn = {};

    sn.on_tam_tel_type_config_change = (sai_tam_tel_type_config_change_notification_fn)attr.value.ptr;

    SWSS_LOG_INFO("send event SAI_SWITCH_ATTR_TAM_TEL_TYPE_CONFIG_CHANGE_NOTIFY %s", str.c_str());

    auto ntf = std::make_shared<sairedis::NotificationTamTelTypeConfigChange>(str);

    auto payload = std::make_shared<EventPayloadNotification>(ntf, sn);

    m_switchConfig->m_eventQueue->enqueue(std::make_shared<Event>(EVENT_TYPE_NOTIFICATION, payload));
}

sai_status_t SwitchStateBase::refresh_tam_tel_ipfix_templates(sai_object_id_t tam_tel_type_id)
{
    SWSS_LOG_ENTER();

    std::vector<uint8_t> ipfix_templates;

    // TODO: This is a placeholder for the actual logic to generate IPFIX templates.
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<uint16_t> dist(0, 255);
    ipfix_templates.resize(64 * 1024);

    for (size_t i = 0; i < ipfix_templates.size(); ++i)
    {
        ipfix_templates[i] = static_cast<uint8_t>(dist(gen));
    }


    sai_attribute_t attr;
    attr.id = SAI_TAM_TEL_TYPE_ATTR_IPFIX_TEMPLATES;
    attr.value.u8list.count = static_cast<uint32_t>(ipfix_templates.size());
    attr.value.u8list.list = ipfix_templates.data();
    sai_status_t status = set(SAI_OBJECT_TYPE_TAM_TEL_TYPE, tam_tel_type_id, &attr);
    if (status != SAI_STATUS_SUCCESS)
    {
        SWSS_LOG_ERROR("Failed to set IPFIX templates for TAM Tel Type %s, status: %s",
                       sai_serialize_object_id(tam_tel_type_id).c_str(),
                       sai_serialize_status(status).c_str());
    }
    else
    {
        SWSS_LOG_INFO("Successfully set IPFIX templates for TAM Tel Type %s",
                      sai_serialize_object_id(tam_tel_type_id).c_str());
    }

    return status;
}

sai_status_t SwitchStateBase::createTam(
    sai_object_id_t tam_id,
    sai_object_id_t switch_id,
    uint32_t attr_count,
    const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    bool include_telemetry_object_list = false;
    std::vector<sai_attribute_t> attrs(attr_list, attr_list + attr_count);
    for (uint32_t i = 0; i < attr_count; i++)
    {
        if (attr_list[i].id == SAI_TAM_ATTR_TELEMETRY_OBJECTS_LIST)
        {
            include_telemetry_object_list = true;
            break;
        }
    }
    if (!include_telemetry_object_list)
    {
        sai_attribute_t attr;
        attr.id = SAI_TAM_ATTR_TELEMETRY_OBJECTS_LIST;
        attr.value.objlist.count = 0;
        attr.value.objlist.list = nullptr;
        attrs.push_back(attr);
    }

    return create_internal(SAI_OBJECT_TYPE_TAM,
                           sai_serialize_object_id(tam_id),
                           switch_id,
                           static_cast<uint32_t>(attrs.size()),
                           attrs.data());
}

sai_status_t SwitchStateBase::createTamTelemetry(
    sai_object_id_t tam_telemetry_id,
    sai_object_id_t switch_id,
    uint32_t attr_count,
    const sai_attribute_t *attr_list)
{
    SWSS_LOG_ENTER();

    bool inlcude_tam_type_list = false;
    std::vector<sai_attribute_t> attrs(attr_list, attr_list + attr_count);
    for (uint32_t i = 0; i < attr_count; i++)
    {
        if (attr_list[i].id == SAI_TAM_TELEMETRY_ATTR_TAM_TYPE_LIST)
        {
            inlcude_tam_type_list = true;
            break;
        }
    }
    if (!inlcude_tam_type_list)
    {
        sai_attribute_t attr;
        attr.id = SAI_TAM_TELEMETRY_ATTR_TAM_TYPE_LIST;
        attr.value.objlist.count = 0;
        attr.value.objlist.list = nullptr;
        attrs.push_back(attr);
    }

    return create_internal(SAI_OBJECT_TYPE_TAM_TELEMETRY,
        sai_serialize_object_id(tam_telemetry_id),
        switch_id,
        static_cast<uint32_t>(attrs.size()),
        attrs.data());
}