bool cps_api_obj_tool_merge(cps_api_object_t main, cps_api_object_t overlay) {
cps_api_object_it_t it;
cps_api_object_it_begin(overlay,&it);
do {
CPS_CLASS_ATTR_TYPES_t _type;
if (!cps_class_map_attr_class(cps_api_object_attr_id(it.attr),&_type)) {
_type = CPS_CLASS_ATTR_T_LEAF;
}
do {
cps_api_attr_id_t _id = cps_api_object_attr_id(it.attr);
cps_api_object_attr_delete(main,_id);
if (_type==CPS_CLASS_ATTR_T_LEAF_LIST) {
if (cps_api_object_attr_get(main,_id)!=nullptr) {
continue;
}
}
} while (0);
} while (cps_api_object_it_next(&it));
cps_api_object_it_begin(overlay,&it);
do {
size_t _attr_len = cps_api_object_attr_len(it.attr);
if (_attr_len==0) continue;
if (!cps_api_object_attr_add(main,cps_api_object_attr_id(it.attr),cps_api_object_attr_data_bin(it.attr),
_attr_len)) {
return false;
}
} while (cps_api_object_it_next(&it));
return true;
}
extern "C" bool cps_api_obj_tool_matches_filter(cps_api_object_t filter, cps_api_object_t obj, bool require_all_attribs) {
cps_api_object_it_t it;
cps_api_object_it_begin(filter,&it);
cps_api_object_it_t obj_it;
cps_api_object_it_begin(obj,&obj_it);
return __cps_api_obj_tool_matches_filter(it,obj_it,require_all_attribs);
}
/* Parse the attributes */
static cps_api_return_code_t nas_qos_cps_parse_attr(cps_api_object_t obj,
nas_qos_priority_group &priority_group)
{
uint64_t val;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_PRIORITY_GROUP_PORT_ID:
case BASE_QOS_PRIORITY_GROUP_LOCAL_ID:
case BASE_QOS_PRIORITY_GROUP_ID:
break; // These are not settable from cps
case BASE_QOS_PRIORITY_GROUP_BUFFER_PROFILE_ID:
val = cps_api_object_attr_data_u64(it.attr);
priority_group.mark_attr_dirty(id);
priority_group.set_buffer_profile(val);
break;
case CPS_API_ATTR_RESERVE_RANGE_END:
// skip keys
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MAJOR, "QOS", "Unrecognized option: %d", id);
return NAS_QOS_E_UNSUPPORTED;
}
}
return cps_api_ret_code_OK;
}
void nas_route_dump_peer_routing_object_content(cps_api_object_t obj){
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
switch (cps_api_object_attr_id(it.attr)) {
case BASE_ROUTE_PEER_ROUTING_CONFIG_VRF_ID:
std::cout<<"VRF Id "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
case BASE_ROUTE_PEER_ROUTING_CONFIG_PEER_MAC_ADDR:
{
char mt[6];
char mstring[20];
memcpy(mt, cps_api_object_attr_data_bin(it.attr), 6);
sprintf(mstring, "%x:%x:%x:%x:%x:%x", mt[0], mt[1], mt[2], mt[3], mt[4], mt[5]);
std::cout<<"MAC "<<mstring<<std::endl;
}
break;
default:
break;
}
}
}
t_std_error nas_get_lag_if_index (uint64_t ndi_port, hal_ifindex_t *lag_if_index)
{
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_get_request_guard rg(&gp);
EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C", "querying for ifindex of ndi lag id 0x%x ", ndi_port);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
cps_api_key_from_attr_with_qual(cps_api_object_key(obj), DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ,
cps_api_qualifier_TARGET);
cps_api_object_attr_add_u64(obj,BASE_IF_LAG_IF_INTERFACES_INTERFACE_LAG_OPAQUE_DATA, ndi_port);
cps_api_object_attr_add(obj,IF_INTERFACES_INTERFACE_TYPE,
(const char *)IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG,
sizeof(IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG));
if (cps_api_get(&gp)==cps_api_ret_code_OK) {
size_t mx = cps_api_object_list_size(gp.list);
for (size_t ix = 0 ; ix < mx ; ++ix ) {
cps_api_object_t obj = cps_api_object_list_get(gp.list,ix);
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
cps_api_object_attr_t attr = cps_api_object_it_find(&it, DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX);
if (!attr) {
return STD_ERR(INTERFACE, FAIL, 0);
}
*lag_if_index = cps_api_object_attr_data_u32(attr);
}
}
return(STD_ERR_OK);
}
t_std_error nas_sflow_update_session(cps_api_object_t obj, nas_sflow_id_t id){
unsigned int prev_sampling_rate;
std_mutex_simple_lock_guard lock(&nas_sflow_mutex);
nas_sflow_map_it sit = nas_sflow_table.find(id);
if(sit == nas_sflow_table.end()){
NAS_SFLOW_LOG(ERR,ev_log_s_MINOR,"No NAS sFlow session with Id %d exist",(int)id);
return STD_ERR(SFLOW,NEXIST,0);
}
nas_sflow_entry_t & sflow_entry = sit->second;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
int attr_id = (int) cps_api_object_attr_id(it.attr);
switch (attr_id) {
case BASE_SFLOW_ENTRY_DIRECTION :
if(sflow_entry.ndi_sflow_entry.sflow_direction != (BASE_CMN_TRAFFIC_PATH_t)
cps_api_object_attr_data_u32(it.attr)){
if(!nas_sflow_update_session_attr(&(sflow_entry.ndi_sflow_entry),
BASE_SFLOW_ENTRY_DIRECTION,cps_api_object_attr_data_u32(it.attr))){
return STD_ERR(SFLOW,FAIL,0);
}
sflow_entry.ndi_sflow_entry.sflow_direction = (BASE_CMN_TRAFFIC_PATH_t)
cps_api_object_attr_data_u32(it.attr);
NAS_SFLOW_LOG(INFO,3,"Updated sFlow session %d direction to %d",sflow_entry.nas_sflow_id,
sflow_entry.ndi_sflow_entry.sflow_direction);
}
break;
case BASE_SFLOW_ENTRY_SAMPLING_RATE :
if(sflow_entry.ndi_sflow_entry.sampling_rate != cps_api_object_attr_data_u32(it.attr)){
prev_sampling_rate = sflow_entry.ndi_sflow_entry.sampling_rate;
sflow_entry.ndi_sflow_entry.sampling_rate = cps_api_object_attr_data_u32(it.attr);
if(!nas_sflow_update_session_attr(&(sflow_entry.ndi_sflow_entry),
BASE_SFLOW_ENTRY_SAMPLING_RATE, cps_api_object_attr_data_u32(it.attr))){
sflow_entry.ndi_sflow_entry.sampling_rate = prev_sampling_rate;
return STD_ERR(SFLOW,FAIL,0);
}
NAS_SFLOW_LOG(INFO,3,"Updated sFlow session %d sampling rate to %d",sflow_entry.nas_sflow_id,
sflow_entry.ndi_sflow_entry.sampling_rate);
}
break;
default:
break;
}
}
return STD_ERR_OK;
}
void nas_route_dump_route_object_content(cps_api_object_t obj) {
char str[INET6_ADDRSTRLEN];
char if_name[IFNAMSIZ];
uint32_t addr_len = 0, af_data = 0;
uint32_t nhc = 0, nh_itr = 0;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
cps_api_object_attr_t af = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_AF);
af_data = cps_api_object_attr_data_u32(af) ;
addr_len = ((af_data == AF_INET) ? HAL_INET4_LEN : HAL_INET6_LEN);
cps_api_object_attr_t prefix = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX);
cps_api_object_attr_t pref_len = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN);
cps_api_object_attr_t nh_count = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_NH_COUNT);
std::cout<<"AF "<<((af_data == AF_INET) ? "IPv4" : "IPv6")<<","<<
inet_ntop(af_data, cps_api_object_attr_data_bin(prefix), str,addr_len)<<"/"<<
cps_api_object_attr_data_u32(pref_len)<<std::endl;
if (nh_count != CPS_API_ATTR_NULL) {
nhc = cps_api_object_attr_data_u32(nh_count);
std::cout<<"NHC "<<nhc<<std::endl;
}
for (nh_itr = 0; nh_itr < nhc; nh_itr++)
{
cps_api_attr_id_t ids[3] = { BASE_ROUTE_OBJ_ENTRY_NH_LIST,
0, BASE_ROUTE_OBJ_ENTRY_NH_LIST_NH_ADDR};
const int ids_len = sizeof(ids)/sizeof(*ids);
ids[1] = nh_itr;
cps_api_object_attr_t attr = cps_api_object_e_get(obj,ids,ids_len);
if (attr != CPS_API_ATTR_NULL)
std::cout<<"NextHop "<<inet_ntop(af_data,cps_api_object_attr_data_bin(attr),str,addr_len)<<std::endl;
ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_IFINDEX;
attr = cps_api_object_e_get(obj,ids,ids_len);
if (attr != CPS_API_ATTR_NULL)
if_indextoname((int)cps_api_object_attr_data_u32(attr), if_name);
std::cout<<"IfIndex "<<if_name<<"("<<cps_api_object_attr_data_u32(attr)<<")"<<std::endl;
ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_WEIGHT;
attr = cps_api_object_e_get(obj,ids,ids_len);
if (attr != CPS_API_ATTR_NULL)
std::cout<<"Weight "<<cps_api_object_attr_data_u32(attr)<<std::endl;
ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_RESOLVED;
attr = cps_api_object_e_get(obj,ids,ids_len);
if (attr != CPS_API_ATTR_NULL)
std::cout<<"Is Next Hop Resolved "<<cps_api_object_attr_data_u32(attr)<<std::endl;
}
}
/* Parse the attributes */
static cps_api_return_code_t nas_qos_cps_parse_attr(cps_api_object_t obj,
nas_qos_scheduler_group &scheduler_group)
{
uint_t val;
uint64_t val64;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_SCHEDULER_GROUP_SWITCH_ID:
case BASE_QOS_SCHEDULER_GROUP_ID:
break; // These are for part of the keys
case BASE_QOS_SCHEDULER_GROUP_CHILD_COUNT:
case BASE_QOS_SCHEDULER_GROUP_CHILD_LIST:
// non-configurable.
break;
case BASE_QOS_SCHEDULER_GROUP_PORT_ID:
val = cps_api_object_attr_data_u32(it.attr);
if (scheduler_group.set_port_id(val) != STD_ERR_OK)
return NAS_QOS_E_FAIL;
break;
case BASE_QOS_SCHEDULER_GROUP_LEVEL:
val = cps_api_object_attr_data_u32(it.attr);
scheduler_group.set_level(val);
break;
case BASE_QOS_SCHEDULER_GROUP_SCHEDULER_PROFILE_ID:
val64 = cps_api_object_attr_data_u64(it.attr);
scheduler_group.set_scheduler_profile_id(val64);
break;
case CPS_API_ATTR_RESERVE_RANGE_END:
// skip keys
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MAJOR, "QOS", "Unrecognized option: %d", id);
return NAS_QOS_E_UNSUPPORTED;
}
}
return cps_api_ret_code_OK;
}
void nas_route_dump_arp_object_content(cps_api_object_t obj){
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
char str[INET_ADDRSTRLEN];
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
switch (cps_api_object_attr_id(it.attr)) {
case BASE_ROUTE_OBJ_NBR_ADDRESS:
std::cout<<"IP Address "<<inet_ntop(AF_INET,cps_api_object_attr_data_bin(it.attr),str,INET_ADDRSTRLEN)<<std::endl;
break;
case BASE_ROUTE_OBJ_NBR_MAC_ADDR:
{
char mt[6];
char mstring[20];
memcpy(mt, cps_api_object_attr_data_bin(it.attr), 6);
sprintf(mstring, "%x:%x:%x:%x:%x:%x", mt[0], mt[1], mt[2], mt[3], mt[4], mt[5]);
std::cout<<"MAC "<<mstring<<std::endl;
}
break;
case BASE_ROUTE_OBJ_NBR_VRF_ID:
std::cout<<"VRF Id "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
case BASE_ROUTE_OBJ_NBR_IFINDEX:
std::cout<<"Ifindex "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
case BASE_ROUTE_OBJ_NBR_FLAGS:
std::cout<<"Flags "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
case BASE_ROUTE_OBJ_NBR_STATE:
std::cout<<"State "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
case BASE_ROUTE_OBJ_NBR_TYPE:
std::cout<<"Type "<<cps_api_object_attr_data_u32(it.attr)<<std::endl;
break;
default:
break;
}
}
}
static bool nas_sflow_fill_session_info(cps_api_object_t obj,nas_sflow_entry_t *entry){
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
int id = (int) cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_SFLOW_ENTRY_IFINDEX :
if(entry->attr_set.contains(BASE_SFLOW_ENTRY_IFINDEX)){
NAS_SFLOW_LOG(ERR,ev_log_s_MINOR,"Multiple Interface Index passed "
"for creating sFlow session");
return false;
}
entry->ifindex = cps_api_object_attr_data_u32(it.attr);
entry->attr_set.add(BASE_SFLOW_ENTRY_IFINDEX);
break;
case BASE_SFLOW_ENTRY_DIRECTION :
if(entry->attr_set.contains(BASE_SFLOW_ENTRY_DIRECTION)){
NAS_SFLOW_LOG(ERR,ev_log_s_MINOR,"Multiple Direction Attributes passed "
"for creating sFlow session");
return false;
}
entry->ndi_sflow_entry.sflow_direction = (BASE_CMN_TRAFFIC_PATH_t)
cps_api_object_attr_data_u32(it.attr);
entry->attr_set.add(BASE_SFLOW_ENTRY_DIRECTION);
break;
case BASE_SFLOW_ENTRY_SAMPLING_RATE :
if(entry->attr_set.contains(BASE_SFLOW_ENTRY_SAMPLING_RATE)){
NAS_SFLOW_LOG(ERR,ev_log_s_MINOR,"Multiple Sampling Attributes passed "
"for creating sFlow session");
return false;
}
entry->ndi_sflow_entry.sampling_rate = cps_api_object_attr_data_u32(it.attr);
entry->attr_set.add(BASE_SFLOW_ENTRY_SAMPLING_RATE);
break;
default:
break;
}
}
return nas_validate_sflow_entry(entry);
}
static bool qos_map_entry_attr_is_set(cps_api_object_t obj, nas_qos_map_type_t type)
{
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
if (id == qos_map_entry_obj_id(type) ||
id == qos_map_entry_key_1_obj_id(type) ||
id == qos_map_entry_key_2_obj_id(type) ||
id == qos_map_entry_attr_1_obj_id(type) ||
id == qos_map_entry_attr_2_obj_id(type))
return true; //found
}
return false;
}
/* Parse the attributes */
static cps_api_return_code_t nas_qos_cps_parse_attr(cps_api_object_t obj,
nas_qos_map_entry &entry )
{
nas_qos_map_type_t type = entry.get_type();
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
_attr_parse_fn fn;
if (id == qos_map_entry_attr_1_obj_id(type)) {
fn = qos_map_entry_attr_1_parse_fn(type);
fn(it.attr, entry);
}
if (id == qos_map_entry_attr_2_obj_id(type)) {
fn = qos_map_entry_attr_2_parse_fn(type);
fn(it.attr, entry);
}
}
return cps_api_ret_code_OK;
}
/**
* This function provides NAS-QoS priority_group stats CPS API read function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_stat_read (void * context,
cps_api_get_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->filters, ix);
cps_api_object_attr_t port_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID);
cps_api_object_attr_t local_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID);
if (port_id_attr == NULL ||
local_id_attr == NULL ) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Incomplete key: port-id, priority_group local id must be specified\n");
return NAS_QOS_E_MISSING_KEY;
}
uint32_t switch_id = 0;
nas_qos_priority_group_key_t key;
key.port_id = cps_api_object_attr_data_u32(port_id_attr);
key.local_id = *(uint8_t *)cps_api_object_attr_data_bin(local_id_attr);
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Read switch id %u, port_id %u priority_group local id %u stat\n",
switch_id, key.port_id, key.local_id);
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
// If the port is not be initialized yet, initialize it in NAS
nas_qos_port_priority_group_init(key.port_id);
nas_qos_switch *switch_p = nas_qos_get_switch(switch_id);
if (switch_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "switch_id %u not found", switch_id);
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group * priority_group_p = switch_p->get_priority_group(key);
if (priority_group_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group not found");
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group_stat_counter_t stats = {0};
std::vector<BASE_QOS_PRIORITY_GROUP_STAT_t> counter_ids;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID:
case BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID:
break;
case BASE_QOS_PRIORITY_GROUP_STAT_PACKETS:
case BASE_QOS_PRIORITY_GROUP_STAT_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_CURRENT_OCCUPANCY_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_WATERMARK_BYTES:
counter_ids.push_back((BASE_QOS_PRIORITY_GROUP_STAT_t)id);
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Unknown priority_group STAT flag: %u, ignored", id);
break;
}
}
if (ndi_qos_get_priority_group_stats(priority_group_p->get_ndi_port_id(),
priority_group_p->ndi_obj_id(),
&counter_ids[0],
counter_ids.size(),
&stats) != STD_ERR_OK) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group stats get failed");
return NAS_QOS_E_FAIL;
}
// return stats objects to cps-app
cps_api_object_t ret_obj = cps_api_object_list_create_obj_and_append(param->list);
if (ret_obj == NULL) {
return cps_api_ret_code_ERR;
}
cps_api_key_from_attr_with_qual(cps_api_object_key(ret_obj),
BASE_QOS_PRIORITY_GROUP_STAT_OBJ,
cps_api_qualifier_TARGET);
cps_api_set_key_data(ret_obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID,
cps_api_object_ATTR_T_U32,
&(key.port_id), sizeof(uint32_t));
cps_api_set_key_data(ret_obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID,
cps_api_object_ATTR_T_BIN,
&(key.local_id), sizeof(uint8_t));
uint64_t val64;
for (uint_t i=0; i< counter_ids.size(); i++) {
BASE_QOS_PRIORITY_GROUP_STAT_t id = counter_ids[i];
val64 = get_stats_by_type(&stats, id);
cps_api_object_attr_add_u64(ret_obj, id, val64);
}
return cps_api_ret_code_OK;
}
static bool nas_mirror_fill_entry(cps_api_object_t obj,nas_mirror_entry *entry
,nas_mirror_src_intf_map_t & new_intf_map,bool update){
nas::attr_set_t attrs;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
int id = (int) cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_MIRROR_ENTRY_DST_INTF :
if(attrs.contains(BASE_MIRROR_ENTRY_DST_INTF) ||
attrs.contains(BASE_MIRROR_ENTRY_LAG_OPAQUE_DATA)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Destination Interface Index passed "
"for creating/updating Mirroring session");
return false;
}
entry->set_dst_intf(cps_api_object_attr_data_u32(it.attr));
interface_ctrl_t intf_ctrl;
if(!nas_mirror_intf_to_port(entry->get_dst_intf(),&intf_ctrl)){
return false;
}
entry->set_dst_port(intf_ctrl.npu_id,intf_ctrl.port_id);
attrs.add(BASE_MIRROR_ENTRY_DST_INTF);
break;
case BASE_MIRROR_ENTRY_LAG_OPAQUE_DATA :
if(attrs.contains(BASE_MIRROR_ENTRY_LAG_OPAQUE_DATA) ||
attrs.contains(BASE_MIRROR_ENTRY_DST_INTF)){
NAS_MIRROR_LOG(ERR,0,"Multiple Destination Lag opaque data "
"passed for creating/updating Mirroring session");
return false;
}
{
nas::ndi_obj_id_table_t lag_opaque_data_table;
cps_api_attr_id_t attr_id_list[] = {BASE_MIRROR_ENTRY_LAG_OPAQUE_DATA};
if(!nas::ndi_obj_id_table_cps_unserialize (lag_opaque_data_table, obj,attr_id_list,
sizeof(attr_id_list)/
sizeof(attr_id_list[0]))){
NAS_MIRROR_LOG(ERR,0,"Failed to unserialize lag opaque data");
return false;
}
auto lag_opaue_it = lag_opaque_data_table.begin();
if(lag_opaue_it == lag_opaque_data_table.end()){
NAS_MIRROR_LOG(ERR,0,"No lag opaque data passed");
return false;
}
entry->set_ndi_lag_id(lag_opaue_it->first,lag_opaue_it->second);
}
attrs.add(BASE_MIRROR_ENTRY_LAG_OPAQUE_DATA);
break;
case BASE_MIRROR_ENTRY_INTF:
if(!update) attrs.add(BASE_MIRROR_ENTRY_INTF);
if(!get_src_intf_attr(obj, new_intf_map , it)) return false;
break;
case BASE_MIRROR_ENTRY_FLOW_ENABLED :
entry->set_flow(cps_api_object_attr_data_u32(it.attr));
break;
case BASE_MIRROR_ENTRY_TYPE:
if(attrs.contains(BASE_MIRROR_ENTRY_TYPE)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Mirror types passed "
"for creating Mirroring session");
return false;
}
entry->set_mode((BASE_MIRROR_MODE_t)cps_api_object_attr_data_u32(it.attr));
attrs.add(BASE_MIRROR_ENTRY_TYPE);
break;
}
}
if(update){
if(!nas_mirror_update_attrs(entry,attrs)) return false;
if(new_intf_map.size() > 0){
if(!entry->update_src_intf_map(new_intf_map)) return false;
}
}
else{
if(!nas_mirror_validate_attr(attrs)) return false;
}
if(entry->get_mode() == BASE_MIRROR_MODE_RSPAN ){
if(!nas_mirror_fill_rspan_attr(obj,entry,update)){
return false;
}
}
if(entry->get_mode() == BASE_MIRROR_MODE_ERSPAN){
if(!nas_mirror_fill_erspan_attr(obj,entry,update)){
return false;
}
}
return true;
}
static bool nas_mirror_fill_erspan_attr(cps_api_object_t obj, nas_mirror_entry *entry, bool update){
nas::attr_set_t attrs;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
int id = (int) cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_MIRROR_ENTRY_ERSPAN_VLAN_ID:
if(attrs.contains(BASE_MIRROR_ENTRY_ERSPAN_VLAN_ID)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple VLAN Ids passed for creating ERSPAN Mirroring session");
return false;
}
entry->set_vlan(cps_api_object_attr_data_u32(it.attr));
attrs.add(BASE_MIRROR_ENTRY_ERSPAN_VLAN_ID);
break;
case BASE_MIRROR_ENTRY_DESTINATION_IP:
if( attrs.contains(BASE_MIRROR_ENTRY_DESTINATION_IP)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Dst IP Address passed for creating ERSPAN Mirroring session");
return false;
}
entry->set_dst_ip(cps_api_object_attr_data_u32(it.attr));
attrs.add(BASE_MIRROR_ENTRY_DESTINATION_IP);
break;
case BASE_MIRROR_ENTRY_SOURCE_IP:
if( attrs.contains(BASE_MIRROR_ENTRY_SOURCE_IP)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Source IP Address passed for creating ERSPAN Mirroring session");
return false;
}
entry->set_src_ip(cps_api_object_attr_data_u32(it.attr));
attrs.add(BASE_MIRROR_ENTRY_SOURCE_IP);
break;
case BASE_MIRROR_ENTRY_DEST_MAC:
if( attrs.contains(BASE_MIRROR_ENTRY_DEST_MAC)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Dst MAC Address passed for creating ERSPAN Mirroring session");
return false;
}
entry->set_dst_mac(cps_api_object_attr_data_bin(it.attr));
attrs.add(BASE_MIRROR_ENTRY_DEST_MAC);
break;
case BASE_MIRROR_ENTRY_SOURCE_MAC:
if( attrs.contains(BASE_MIRROR_ENTRY_SOURCE_MAC)){
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Multiple Source MAC Address passed for creating ERSPAN Mirroring session");
return false;
}
entry->set_src_mac(cps_api_object_attr_data_bin(it.attr));
attrs.add(BASE_MIRROR_ENTRY_SOURCE_MAC);
break;
}
}
if(update){
return nas_mirror_update_attrs(entry,attrs);
}
return nas_mirror_validate_erspan_attr(attrs);
}
/**
* This function provides NAS-QoS SCHEDULER_GROUP CPS API read function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_scheduler_group_read (void * context,
cps_api_get_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->filters, ix);
cps_api_object_attr_t sg_attr = cps_api_get_key_data(obj, BASE_QOS_SCHEDULER_GROUP_ID);
uint32_t port_id = 0, level;
bool have_port = false, have_level = false;
if (!sg_attr) {
cps_api_object_it_t it;
cps_api_object_it_begin(obj, &it);
for ( ; cps_api_object_it_valid(&it); cps_api_object_it_next(&it)) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
if (id == BASE_QOS_SCHEDULER_GROUP_PORT_ID) {
port_id = cps_api_object_attr_data_u32(it.attr);
have_port = true;
} else if (id == BASE_QOS_SCHEDULER_GROUP_LEVEL) {
level = cps_api_object_attr_data_u32(it.attr);
have_level = true;
}
}
}
if (!sg_attr && !have_port) {
EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS",
"Invalid input attributes for reading");
return NAS_QOS_E_MISSING_KEY;
}
uint_t switch_id = 0;
nas_obj_id_t scheduler_group_id = (sg_attr? cps_api_object_attr_data_u64(sg_attr): 0);
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Read switch id %u, scheduler_group id 0x%016lX\n",
switch_id, scheduler_group_id);
std_mutex_simple_lock_guard p_m(&scheduler_group_mutex);
if (have_port) {
nas_qos_port_scheduler_group_init(port_id);
}
nas_qos_switch * p_switch = nas_qos_get_switch(switch_id);
if (p_switch == NULL)
return NAS_QOS_E_FAIL;
std::vector<nas_qos_scheduler_group *> sg_list;
if (sg_attr) {
nas_qos_scheduler_group *scheduler_group = p_switch->get_scheduler_group(scheduler_group_id);
if (scheduler_group == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS",
"Could not find scheduler group with ID %llu", scheduler_group_id);
return NAS_QOS_E_FAIL;
}
sg_list.push_back(scheduler_group);
} else {
int match_level = have_level ? (int)level : -1;
p_switch->get_port_scheduler_groups(port_id, match_level, sg_list);
}
/* fill in data */
cps_api_object_t ret_obj;
for (auto scheduler_group: sg_list) {
ret_obj = cps_api_object_list_create_obj_and_append (param->list);
if (ret_obj == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS",
"Failed to create cps object");
return cps_api_ret_code_ERR;
}
cps_api_key_from_attr_with_qual(cps_api_object_key(ret_obj),BASE_QOS_SCHEDULER_GROUP_OBJ,
cps_api_qualifier_TARGET);
cps_api_set_key_data(ret_obj, BASE_QOS_SCHEDULER_GROUP_SWITCH_ID,
cps_api_object_ATTR_T_U32,
&switch_id, sizeof(uint32_t));
scheduler_group_id = scheduler_group->get_scheduler_group_id();
cps_api_set_key_data(ret_obj, BASE_QOS_SCHEDULER_GROUP_ID,
cps_api_object_ATTR_T_U64,
&scheduler_group_id, sizeof(uint64_t));
cps_api_object_attr_add_u32(ret_obj,
BASE_QOS_SCHEDULER_GROUP_CHILD_COUNT,
scheduler_group->get_child_count());
for (uint32_t idx = 0; idx < scheduler_group->get_child_count(); idx++) {
cps_api_object_attr_add_u64(ret_obj,
BASE_QOS_SCHEDULER_GROUP_CHILD_LIST,
scheduler_group->get_child_id(idx));
}
cps_api_object_attr_add_u32(ret_obj, BASE_QOS_SCHEDULER_GROUP_PORT_ID,
scheduler_group->get_port_id());
cps_api_object_attr_add_u32(ret_obj, BASE_QOS_SCHEDULER_GROUP_LEVEL,
scheduler_group->get_level());
cps_api_object_attr_add_u64(ret_obj, BASE_QOS_SCHEDULER_GROUP_SCHEDULER_PROFILE_ID,
scheduler_group->get_scheduler_profile_id());
}
return cps_api_ret_code_OK;
}
/**
* This function provides NAS-QoS priority_group stats CPS API clear function
* To clear the priority_group stats, set relevant counters to zero
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_stat_clear (void * context,
cps_api_transaction_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op != cps_api_oper_SET)
return NAS_QOS_E_UNSUPPORTED;
cps_api_object_attr_t port_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID);
cps_api_object_attr_t local_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID);
if (port_id_attr == NULL ||
local_id_attr == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Incomplete key: port-id, priority_group local id must be specified\n");
return NAS_QOS_E_MISSING_KEY;
}
uint32_t switch_id = 0;
nas_qos_priority_group_key_t key;
key.port_id = cps_api_object_attr_data_u32(port_id_attr);
key.local_id = *(uint8_t *)cps_api_object_attr_data_bin(local_id_attr);
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Read switch id %u, port_id %u priority_group local_id %u stat\n",
switch_id, key.port_id, key.local_id);
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
// If the port is not be initialized yet, initialize it in NAS
nas_qos_port_priority_group_init(key.port_id);
nas_qos_switch *switch_p = nas_qos_get_switch(switch_id);
if (switch_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "switch_id %u not found", switch_id);
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group * priority_group_p = switch_p->get_priority_group(key);
if (priority_group_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group not found");
return NAS_QOS_E_FAIL;
}
std::vector<BASE_QOS_PRIORITY_GROUP_STAT_t> counter_ids;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID:
case BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID:
break;
case BASE_QOS_PRIORITY_GROUP_STAT_PACKETS:
case BASE_QOS_PRIORITY_GROUP_STAT_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_WATERMARK_BYTES:
counter_ids.push_back((BASE_QOS_PRIORITY_GROUP_STAT_t)id);
break;
case BASE_QOS_PRIORITY_GROUP_STAT_CURRENT_OCCUPANCY_BYTES:
// READ-only
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Unknown priority_group STAT flag: %u, ignored", id);
break;
}
}
if (ndi_qos_clear_priority_group_stats(priority_group_p->get_ndi_port_id(),
priority_group_p->ndi_obj_id(),
&counter_ids[0],
counter_ids.size()) != STD_ERR_OK) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group stats clear failed");
return NAS_QOS_E_FAIL;
}
return cps_api_ret_code_OK;
}
