void cmd_exit()
{
SWSS_LOG_ENTER();
run_user = false;
sendtoclient("bye\n");
}
static const char* profile_get_value(
_In_ sai_switch_profile_id_t profile_id,
_In_ const char* variable)
{
SWSS_LOG_ENTER();
return NULL;
}
sai_status_t meta_pre_set_vlan_member_attribute(
_In_ sai_object_id_t vlan_member_id,
_In_ const sai_attribute_t *attr)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
sai_status_t meta_pre_create_mirror_session(
_In_ uint32_t attr_count,
_In_ const sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
return is_header_version_ok(attr_count, attr_list);
}
sai_status_t meta_pre_create_vlan_member(
_In_ uint32_t attr_count,
_In_ const sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
void redisSetLogLevel(swss::Logger::Priority prio)
{
SWSS_LOG_ENTER();
std::string level = swss::Logger::priorityToString(prio);
g_redisClient->set("LOGLEVEL", level);
}
void on_switch_shutdown_request_notification(
_In_ sai_object_id_t switch_id)
{
SWSS_LOG_ENTER();
SWSS_LOG_ERROR("got shutdown request, syncd failed!");
exit(EXIT_FAILURE);
}
sai_status_t meta_pre_set_route_attribute(
_In_ const sai_unicast_route_entry_t* unicast_route_entry,
_In_ const sai_attribute_t *attr)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
void on_packet_event(
_In_ const void *buffer,
_In_ sai_size_t buffer_size,
_In_ uint32_t attr_count,
_In_ const sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
}
void translate_rid_to_vid_list(
_In_ sai_object_type_t object_type,
_In_ uint32_t attr_count,
_In_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
// we receive real id's here, if they are new then create new id
// for them and put in db, if entry exists in db, use it
for (uint32_t i = 0; i < attr_count; i++)
{
sai_attribute_t &attr = attr_list[i];
sai_attr_serialization_type_t serialization_type;
sai_status_t status = sai_get_serialization_type(object_type, attr.id, serialization_type);
if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_ERROR("unable to find serialization type for object type %x, attribute %x", object_type, attr.id);
exit(EXIT_FAILURE);
}
switch (serialization_type)
{
case SAI_SERIALIZATION_TYPE_OBJECT_ID:
attr.value.oid = translate_rid_to_vid(attr.value.oid);
break;
case SAI_SERIALIZATION_TYPE_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID:
attr.value.aclfield.data.oid = translate_rid_to_vid(attr.value.aclfield.data.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.aclfield.data.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID:
attr.value.aclaction.parameter.oid = translate_rid_to_vid(attr.value.aclaction.parameter.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.aclaction.parameter.objlist);
break;
case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT:
translate_list_rid_to_vid(attr.value.portbreakout.port_list);
default:
break;
}
}
}
void translate_vid_to_rid_list(
_In_ sai_object_type_t object_type,
_In_ uint32_t attr_count,
_In_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
// all id's reseived from sairedis should be virtual, so
// lets translate them to real id's
for (uint32_t i = 0; i < attr_count; i++)
{
sai_attribute_t &attr = attr_list[i];
sai_attr_serialization_type_t serialization_type;
sai_status_t status = sai_get_serialization_type(object_type, attr.id, serialization_type);
if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_ERROR("unable to find serialization type for object type %x, attribute %x", object_type, attr.id);
exit(EXIT_FAILURE);
}
switch (serialization_type)
{
case SAI_SERIALIZATION_TYPE_OBJECT_ID:
attr.value.oid = translate_vid_to_rid(attr.value.oid);
break;
case SAI_SERIALIZATION_TYPE_OBJECT_LIST:
translate_list_vid_to_rid(attr.value.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID:
attr.value.aclfield.data.oid = translate_vid_to_rid(attr.value.aclfield.data.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST:
translate_list_vid_to_rid(attr.value.aclfield.data.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID:
attr.value.aclaction.parameter.oid = translate_vid_to_rid(attr.value.aclaction.parameter.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST:
translate_list_vid_to_rid(attr.value.aclaction.parameter.objlist);
break;
case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT:
translate_list_vid_to_rid(attr.value.portbreakout.port_list);
default:
break;
}
}
}
void processFdbEntriesForAging()
{
SWSS_LOG_ENTER();
if (!g_recursive_mutex.try_lock())
{
return;
}
SWSS_LOG_INFO("fdb infos to process: %zu", g_fdb_info_set.size());
uint32_t current = (uint32_t)time(NULL);
// find aged fdb entries
for (auto it = g_fdb_info_set.begin(); it != g_fdb_info_set.end();)
{
sai_attribute_t attr;
attr.id = SAI_SWITCH_ATTR_FDB_AGING_TIME;
sai_status_t status = vs_generic_get(SAI_OBJECT_TYPE_SWITCH, it->fdb_entry.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(it->fdb_entry.switch_id).c_str());
++it;
continue;
}
uint32_t aging_time = attr.value.u32;
if (aging_time == 0)
{
// aging is disabled
++it;
continue;
}
if ((current - it->timestamp) >= aging_time)
{
fdb_info_t fi = *it;
processFdbInfo(fi, SAI_FDB_EVENT_AGED);
it = g_fdb_info_set.erase(it);
}
else
{
++it;
}
}
g_recursive_mutex.unlock();
}
sai_object_id_t create_dummy_object_id(
_In_ sai_object_type_t objecttype)
{
SWSS_LOG_ENTER();
static uint64_t index = 0;
return (((sai_object_id_t)objecttype) << 48) | ++index;
}
sai_status_t redis_clear_port_all_stats(
_In_ sai_object_id_t port_id)
{
MUTEX();
SWSS_LOG_ENTER();
return SAI_STATUS_NOT_IMPLEMENTED;
}
/**
* Routine Description:
* @brief Clear port statistics counters.
*
* Arguments:
* @param[in] port_id - port id
* @param[in] counter_ids - specifies the array of counter ids
* @param[in] number_of_counters - number of counters in the array
*
* Return Values:
* @return SAI_STATUS_SUCCESS on success
* Failure status code on error
*/
sai_status_t redis_clear_port_stats(
_In_ sai_object_id_t port_id,
_In_ const sai_port_stat_counter_t *counter_ids,
_In_ uint32_t number_of_counters)
{
SWSS_LOG_ENTER();
return SAI_STATUS_NOT_IMPLEMENTED;
}
sai_status_t meta_pre_get_vlan_member_attribute(
_In_ sai_object_id_t vlan_member_id,
_In_ uint32_t attr_count,
_Inout_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
sai_status_t meta_pre_get_route_attribute(
_In_ const sai_unicast_route_entry_t* unicast_route_entry,
_In_ uint32_t attr_count,
_Inout_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
sai_status_t meta_pre_get_mirror_session_attribute(
_In_ sai_object_id_t session_id,
_In_ uint32_t attr_count,
_Inout_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
return SAI_STATUS_SUCCESS;
}
void on_switch_shutdown_request()
{
SWSS_LOG_ENTER();
/* TODO: Later a better restart story will be told here */
SWSS_LOG_ERROR("Syncd stopped");
exit(EXIT_FAILURE);
}
int test_profile_get_next_value (
_In_ sai_switch_profile_id_t profile_id,
_Out_ const char **variable,
_Out_ const char **value)
{
SWSS_LOG_ENTER();
return -1;
}
static sai_status_t create_bridge_ports()
{
SWSS_LOG_ENTER();
sai_object_id_t switch_id = ss->getSwitchId();
/*
* 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(vs_generic_create(SAI_OBJECT_TYPE_BRIDGE_PORT, &default_bridge_port_1q_router, ss->getSwitchId(), 1, &attr));
attr.id = SAI_SWITCH_ATTR_DEFAULT_1Q_BRIDGE_ID;
CHECK_STATUS(vs_generic_get(SAI_OBJECT_TYPE_SWITCH, switch_id, 1, &attr));
/*
* Create bridge ports for regular ports.
*/
sai_object_id_t default_1q_bridge_id = attr.value.oid;
bridge_port_list_port_based.clear();
for (const auto &port_id: 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 = default_1q_bridge_id;
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(vs_generic_create(SAI_OBJECT_TYPE_BRIDGE_PORT, &bridge_port_id, switch_id, 4, attrs));
bridge_port_list_port_based.push_back(bridge_port_id);
}
return SAI_STATUS_SUCCESS;
}
sai_object_id_t translate_rid_to_vid(
_In_ sai_object_id_t rid)
{
SWSS_LOG_ENTER();
if (rid == SAI_NULL_OBJECT_ID)
{
SWSS_LOG_DEBUG("translated RID null to VID null");
return SAI_NULL_OBJECT_ID;
}
sai_object_id_t vid;
std::string str_rid;
std::string str_vid;
sai_serialize_primitive(rid, str_rid);
auto pvid = g_redisClient->hget(RIDTOVID, str_rid);
if (pvid != NULL)
{
// object exists
str_vid = *pvid;
int index = 0;
sai_deserialize_primitive(str_vid, index, vid);
SWSS_LOG_DEBUG("translated RID %llx to VID %llx", rid, vid);
return vid;
}
SWSS_LOG_INFO("spotted new RID %llx", rid);
sai_object_type_t object_type = sai_object_type_query(rid);
if (object_type == SAI_OBJECT_TYPE_NULL)
{
SWSS_LOG_ERROR("sai_object_type_query returned NULL type for RID %llx", rid);
exit(EXIT_FAILURE);
}
vid = redis_create_virtual_object_id(object_type);
SWSS_LOG_DEBUG("translated RID %llx to VID %llx", rid, vid);
sai_serialize_primitive(vid, str_vid);
g_redisClient->hset(RIDTOVID, str_rid, str_vid);
g_redisClient->hset(VIDTORID, str_vid, str_rid);
return vid;
}
void redisSetDefaultVirtualRouterId(sai_object_id_t vr_id)
{
SWSS_LOG_ENTER();
std::string strVrId;
sai_serialize_primitive(vr_id, strVrId);
g_redisClient->hset(HIDDEN, DEFAULT_VIRTUAL_ROUTER_ID, strVrId);
}
void translate_local_to_redis(
_In_ T &element)
{
SWSS_LOG_ENTER();
for (uint32_t i = 0; i < element.count; i++)
{
element.list[i] = translate_local_to_redis(element.list[i]);
}
}
sai_status_t sai_log_set(
_In_ sai_api_t sai_api_id,
_In_ sai_log_level_t log_level)
{
MUTEX();
SWSS_LOG_ENTER();
return SAI_STATUS_NOT_IMPLEMENTED;
}
void redisSetCpuId(sai_object_id_t cpuId)
{
SWSS_LOG_ENTER();
std::string strCpuId;
sai_serialize_primitive(cpuId, strCpuId);
g_redisClient->hset(HIDDEN, CPU_PORT_ID, strCpuId);
}
void channelOpEnableUnittests(
_In_ const std::string &key,
_In_ const std::vector<swss::FieldValueTuple> &values)
{
SWSS_LOG_ENTER();
bool enable = (key == "true");
meta_unittests_enable(enable);
}
void translate_list_rid_to_vid(
_In_ T &element)
{
SWSS_LOG_ENTER();
for (uint32_t i = 0; i < element.count; i++)
{
element.list[i] = translate_rid_to_vid(element.list[i]);
}
}
void notifySyncd(swss::NotificationConsumer &consumer)
{
std::lock_guard<std::mutex> lock(g_mutex);
SWSS_LOG_ENTER();
std::string op;
std::string data;
std::vector<swss::FieldValueTuple> values;
consumer.pop(op, data, values);
if (g_veryFirstRun)
{
SWSS_LOG_NOTICE("very first run is TRUE, op = %s", op.c_str());
// on the very first start of syncd, "compile" view is directly
// applied on device, since it will make it easier to switch
// to new asic state later on when we restart orch agent
if (op == NOTIFY_SAI_APPLY_VIEW)
{
g_veryFirstRun = false;
SWSS_LOG_NOTICE("setting very first run to FALSE, op = %s", op.c_str());
}
sendResponse(SAI_STATUS_SUCCESS);
return;
}
sai_status_t status = SAI_STATUS_FAILURE;
if (op == NOTIFY_SAI_INIT_VIEW)
{
// TODO
SWSS_LOG_ERROR("op = %s - not implemented", op.c_str());
status = SAI_STATUS_NOT_IMPLEMENTED;
}
if (op == NOTIFY_SAI_APPLY_VIEW)
{
// TODO
SWSS_LOG_ERROR("op = %s - not implemented", op.c_str());
status = SAI_STATUS_NOT_IMPLEMENTED;
}
else
{
SWSS_LOG_ERROR("unknown operation: %s", op.c_str());
}
sendResponse(status);
}
static sai_status_t refresh_vlan_member_list(
_In_ const sai_attr_metadata_t *meta,
_In_ sai_object_id_t vlan_id,
_In_ sai_object_id_t switch_id)
{
SWSS_LOG_ENTER();
auto &all_vlan_members = g_switch_state_map.at(switch_id)->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 = g_switch_state_map.at(switch_id)->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 vs_generic_set(SAI_OBJECT_TYPE_VLAN, vlan_id, &attr);
}
