t_std_error nas_os_util_int_mtu_set(const char *name, unsigned int mtu)
{
struct ifreq ifr;
strncpy(ifr.ifr_ifrn.ifrn_name,name,sizeof(ifr.ifr_ifrn.ifrn_name)-1);
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock==-1) return STD_ERR(INTERFACE,FAIL,errno);
t_std_error err = STD_ERR_OK;
ifr.ifr_mtu = mtu;
if (ioctl(sock, SIOCSIFMTU, &ifr) < 0) {
err = STD_ERR(INTERFACE,FAIL,errno);
EV_LOG_ERRNO(ev_log_t_INTERFACE,3,"DB-LINUX-SET",errno);
}
close(sock);
return err;
}
void* MINI_CIRCUITS_STD_Driver_Equipment_Info ( int hLowLevelHandle , char *pAddress , char **pVendor , char **pSerialNumber , char **pModel , char **pFirmware )
{
STD_ERROR StdError = {0};
CAObjHandle handle = 0;
short value = 0;
ERRORINFO errorInfo = {0};
STD_ERR( ModularZT_New_USB_Control(NULL,1,LOCALE_NEUTRAL,0,&handle));
STD_ERR( ModularZT__USB_ControlConnect( handle , NULL , pAddress , &value ));
if ( pModel )
{
STD_ERR( ModularZT__USB_ControlRead_ModelName ( handle , &errorInfo , &pModel , &value ));
}
if ( pFirmware )
{
STD_ERR( ModularZT__USB_ControlGetFirmware ( handle , &errorInfo , &value ));
CALLOC( *pFirmware , 128 , sizeof(char));
sprintf( *pFirmware , "%d" , value );
}
if ( pSerialNumber )
{
STD_ERR( ModularZT__USB_ControlRead_SN ( handle , &errorInfo , &pSerialNumber , &value ));
}
if ( pVendor )
{
CALLOC_COPY_STRING( *pVendor , "Mini-Circuits" );
}
Error:
RETURN_STDERR_POINTER;
}
t_std_error nas_mirror_set_session(cps_api_object_t obj,nas_mirror_id_t id){
nas_mirror_table_it it = nas_mirror_table.find(id);
NAS_MIRROR_LOG(INFO,3,"updating mirror session %d",(int)id);
if(it == nas_mirror_table.end()){
NAS_MIRROR_LOG(ERR,ev_log_s_MAJOR,"No Mirror id %d exist for updating mirror session",(int)id);
return STD_ERR(MIRROR,NEXIST,0);
}
nas_mirror_entry & entry = it->second;
nas_mirror_src_intf_map_t intf_map;
std_mutex_simple_lock_guard lock(&nas_mirror_mutex);
nas_mirror_entry orig_entry(entry);
if(!(nas_mirror_fill_entry(obj,&entry,intf_map,true))){
entry = std::move(orig_entry);
return STD_ERR(MIRROR,FAIL,0);
}
return STD_ERR_OK;
}
t_std_error nas_os_set_route (cps_api_object_t obj)
{
if (nas_os_update_route(obj, NAS_RT_SET) != cps_api_ret_code_OK) {
EV_LOG(ERR, NAS_OS, ev_log_s_CRITICAL, "ROUTE-SET", "Kernel write failed");
return (STD_ERR(NAS_OS, FAIL, 0));
}
return STD_ERR_OK;
}
t_std_error std_shlib_load(const char* shlib_name, std_shlib_hndl *hndl,
std_shlib_func_map_t func_map[], size_t func_map_sz)
{
t_std_error rc = STD_ERR_OK;
size_t iter = 0;
if (NULL == hndl || NULL == shlib_name) {
return STD_ERR(COM,FAIL,EINVAL);
}
*hndl = STD_SHLIB_INVALID_HNDL;
if (std_shlib_is_loaded(shlib_name)) {
return STD_ERR(COM,FAIL,EEXIST);
}
*hndl = dlopen(shlib_name, RTLD_NOW | RTLD_LOCAL);
if (NULL == *hndl) {
*hndl = STD_SHLIB_INVALID_HNDL;
EV_LOG_ERR(ev_log_t_COM,0,"COM-SHLIB","%s not found",
shlib_name);
return STD_ERR(COM,FAIL,ENOENT); // no entity
}
for (iter = 0; iter < func_map_sz; ++iter) {
if (NULL == func_map[iter].name) {
// Ignore NULL names - this is useful to optionally load some functions...
*func_map[iter].pp_func = NULL;
continue;
}
(void)dlerror(); // reset error string, as per dlsym man page
*func_map[iter].pp_func = dlsym(*hndl, func_map[iter].name);
// Note. As per dlsym man page, in case of dlsym failure, we have dlerror() != NULL
// Keep load all functions, in order to allow the user app to figura out which functions could not be mapped.
if (dlerror() != NULL) {
*func_map[iter].pp_func = NULL;
EV_LOG_INFO(ev_log_t_COM,0,"COM-SHLIB","%s no such function[%d]: %s",
shlib_name, iter,func_map[iter].name);
rc = STD_ERR(COM,FAIL,EFAULT);
}
}
if (rc != STD_ERR_OK) {
(void)dlclose(*hndl);
*hndl = STD_SHLIB_INVALID_HNDL;
}
return rc;
}
t_std_error nas_os_del_neighbor (cps_api_object_t obj)
{
if (nas_os_update_neighbor(obj, NAS_RT_DEL) != cps_api_ret_code_OK) {
EV_LOG(ERR, NAS_OS, ev_log_s_CRITICAL, "NEIGH-DEL", "Kernel write failed");
return (STD_ERR(NAS_OS, FAIL, 0));
}
return STD_ERR_OK;
}
STD_ERROR DLLEXPORT DRV_FunctionGenerator_ReleaseLock ( int Handle )
{
STD_ERROR StdError = {0};
tsDriverInfo *pDriverInfo = NULL;
CmtThreadLockHandle LockHandle = 0;
int LockCounter = 0;
int InstrumentType = 0;
if ( Handle == 0 )
{STD_ERR (DRV_ERROR_PASSED_NULL);}
if ( CmtGetTSVPtr ( Handle , &pDriverInfo ) < 0 )
{STD_ERR (DRV_ERROR_GET_TSV_POINTER);}
InstrumentType = pDriverInfo->InstrumentType;
LockHandle = pDriverInfo->InstrumentLockHandle;
LockCounter = pDriverInfo->LockCounter;
CmtReleaseTSVPtr ( Handle );
if ( InstrumentType != DRIVER_TYPE_FUNCTION_GENERATOR )
{STD_ERR (DRV_ERROR_INCORRECT_DRIVER_TYPE);}
if ( LockHandle && LockCounter)
{
CmtReleaseLock (LockHandle);
if ( CmtGetTSVPtr ( Handle , &pDriverInfo ) == 0 )
{
pDriverInfo->LockCounter--;
CmtReleaseTSVPtr ( Handle );
}
}
Error:
return StdError;
}
void* DLLEXPORT SignalGenerator_RecallState ( int InstrumentHandle , char *pszStateFile )
{
STD_ERROR StdError = {0};
STD_ERR( AgRfSigGen_SystemRecallState ( InstrumentHandle , pszStateFile ));
Error:
return SignalGenerator_GetLastErrorTextMessage(InstrumentHandle,NULL);
}
t_std_error ds_api_linux_route_init(cps_api_operation_handle_t handle) {
cps_api_registration_functions_t f;
memset(&f,0,sizeof(f));
f.handle = handle;
f._read_function = db_read_function;
f._write_function = _write_function;
cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0);
cps_api_return_code_t rc = cps_api_register(&f);
if (rc!=cps_api_ret_code_OK) {
return STD_ERR(INTERFACE,FAIL,rc);
}
f._read_function = NULL;
cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_EVENT,0);
rc = cps_api_register(&f);
return STD_ERR_OK_IF_TRUE(rc==cps_api_ret_code_OK,STD_ERR(INTERFACE,FAIL,rc));
}
STD_ERROR DLLEXPORT DRV_FunctionGenerator_TryToGetLock ( int Handle , int *pSuccess)
{
STD_ERROR StdError = {0};
tsDriverInfo *pDriverInfo = NULL;
CmtThreadLockHandle LockHandle = 0;
int iSucces = 0;
int InstrumentType = 0;
IF ((pSuccess == NULL) , "Error passed NULL pointer.");
if ( Handle == 0 )
{STD_ERR (DRV_ERROR_PASSED_NULL);}
if ( CmtGetTSVPtr ( Handle , &pDriverInfo ) < 0 )
{STD_ERR (DRV_ERROR_GET_TSV_POINTER);}
InstrumentType = pDriverInfo->InstrumentType;
LockHandle = pDriverInfo->InstrumentLockHandle;
CmtReleaseTSVPtr ( Handle );
if ( InstrumentType != DRIVER_TYPE_FUNCTION_GENERATOR )
{STD_ERR (DRV_ERROR_INCORRECT_DRIVER_TYPE);}
CmtTryToGetLock ( LockHandle , &iSucces);
*pSuccess = iSucces;
if (iSucces)
if ( CmtGetTSVPtr ( Handle , &pDriverInfo ) == 0 )
{
pDriverInfo->LockCounter++;
CmtReleaseTSVPtr ( Handle );
}
Error:
return StdError;
}
void* DLLEXPORT SignalGenerator_Init( int hParentInstrumentHandle , char* szRsrcAddress , int *phInstrumentHandle , int *InstrumentConnectStatus , int *InstrumentChannelsQuantity )
{
STD_ERROR StdError = {0};
int iChannelCount = 1;
char szErrorTextMessage[256] = {0};
ViSession handle = 0;
if ( hParentInstrumentHandle == 0 )
{
STD_ERR ( AgRfSigGen_init ( szRsrcAddress, VI_FALSE, VI_FALSE, &handle));
}
else
handle = hParentInstrumentHandle;
if ( phInstrumentHandle )
*phInstrumentHandle = handle;
STD_ERR ( AgRfSigGen_ClearError (handle));
if ( InstrumentChannelsQuantity )
*InstrumentChannelsQuantity = iChannelCount;
Error:
if (( IS_NOT_OK ) || (iChannelCount < 1))
{
AgRfSigGen_error_message (handle, StdError.error , szErrorTextMessage);
//MessagePopup("Signal Generator Initializing Error!",szErrorTextMessage);
AgRfSigGen_close (handle);
*phInstrumentHandle = 0;
}
else
if ( InstrumentConnectStatus )
*InstrumentConnectStatus = 1;
RETURN_STDERR_POINTER;
}
t_std_error ds_api_linux_interface_init(cps_api_operation_handle_t handle) {
cps_api_registration_functions_t f;
memset(&f,0,sizeof(f));
f.handle = handle;
f._read_function = ds_api_linux_interface_get_function;
f._write_function = ds_api_linux_interface_set_function;
cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_INTERFACE,0,0);
cps_api_return_code_t rc = cps_api_register(&f);
return STD_ERR_OK_IF_TRUE(rc==cps_api_ret_code_OK,STD_ERR(INTERFACE,FAIL,rc));
}
t_std_error nas_mac_lag_obj_id_get (hal_ifindex_t if_index, ndi_obj_id_t& obj_id)
{
nas::ndi_obj_id_table_t tmp_ndi_oid_tbl;
if (dn_nas_lag_get_ndi_ids (if_index, &tmp_ndi_oid_tbl) != STD_ERR_OK) {
NAS_MAC_LOG(ERR, ev_log_s_MAJOR, "Lag object get failed for %d", if_index);
return STD_ERR(MAC,NEXIST,0);
}
/* TODO - Handle multiple NPU scenerio */
obj_id = tmp_ndi_oid_tbl[0];
return STD_ERR_OK;
}
t_std_error nas_switch_log_init(cps_api_operation_handle_t handle) {
cps_api_return_code_t rc;
cps_api_registration_functions_t f;
memset(&f,0,sizeof(f));
f.handle = handle;
f._write_function = cps_nas_switch_log_set_function;
char buff[CPS_API_KEY_STR_MAX];
if (!cps_api_key_from_attr_with_qual(&f.key,BASE_SWITCH_SET_LOG_OBJ,cps_api_qualifier_TARGET)) {
EV_LOG(ERR,SYSTEM,0,"NAS-DIAG","Could not translate %d to key %s",
(int)(BASE_SWITCH_SET_LOG_OBJ),cps_api_key_print(&f.key,buff,sizeof(buff)-1));
return STD_ERR(DIAG,FAIL,0);
}
if ((rc = cps_api_register(&f)) != cps_api_ret_code_OK) return STD_ERR(DIAG,FAIL,rc);
return STD_ERR_OK;
}
t_std_error nas_os_util_int_mac_addr_get(const char *name, hal_mac_addr_t *macAddr) {
struct ifreq ifr;
strncpy(ifr.ifr_ifrn.ifrn_name,name,sizeof(ifr.ifr_ifrn.ifrn_name)-1);
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock==-1) return STD_ERR(INTERFACE,FAIL,errno);
t_std_error err = STD_ERR_OK;
do {
ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
if (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0) {
memcpy(*macAddr, ifr.ifr_hwaddr.sa_data,sizeof(*macAddr));
break;
}
err = STD_ERR(INTERFACE,FAIL,errno);
EV_LOG_ERRNO(ev_log_t_INTERFACE,3,"DB-LINUX-SET",STD_ERR_EXT_PRIV(err));
} while (0);
close(sock);
return err;
}
t_std_error nas_os_util_int_mtu_get(const char *name, unsigned int *mtu) {
struct ifreq ifr;
strncpy(ifr.ifr_ifrn.ifrn_name,name,sizeof(ifr.ifr_ifrn.ifrn_name)-1);
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock==-1) return STD_ERR(INTERFACE,FAIL,errno);
t_std_error err = STD_ERR_OK;
do {
if (ioctl(sock, SIOCGIFMTU, &ifr) >= 0) {
*mtu = (ifr.ifr_mtu ) ;
break;
}
err = STD_ERR(INTERFACE,FAIL,errno);
EV_LOG_ERRNO(ev_log_t_INTERFACE,3,"DB-LINUX-GET",STD_ERR_EXT_PRIV(err));
} while(0);
close(sock);
return err;
}
t_std_error nas_sflow_get_all_info(cps_api_object_list_t list){
std_mutex_simple_lock_guard lock(&nas_sflow_mutex);
nas_sflow_map_it it = nas_sflow_table.begin();
for ( ; it != nas_sflow_table.end() ; ++it){
cps_api_object_t obj=cps_api_object_create();
if(obj == NULL){
NAS_SFLOW_LOG(ERR,0,"Failed to create new object");
return STD_ERR(SFLOW,NOMEM,0);
}
if (!cps_api_object_list_append(list,obj)) {
cps_api_object_delete(obj);
return STD_ERR(SFLOW,FAIL,0);
}
nas_sflow_fill_object(obj,it);
}
return STD_ERR_OK;
}
void* MINI_CIRCUITS_STD_Driver_GetValue( int hHandle , char **pGetCommandName , void **pGetValue , int *piValueLength , int *piValueSize, ... )
{
STD_ERROR StdError = {0};
tsLocalStorage *pLocalStorage = NULL;
short value = 0;
char *retStr = NULL;
char szCommand[LOW_STRING] = {0};
int iCommandIndex = 0;
char *pError = szCommand,
*pCommand = szCommand;
IF (( hHandle == 0 ) , "Handle can't be zero." );
CHK_CMT( CmtGetTSVPtr ( hHandle, &pLocalStorage));
IF (( pGetValue == NULL ), "Get Value pointer is NULL" );
iCommandIndex = pLocalStorage->iLastIndex;
sprintf( szCommand , ":%s:%s:STATE?" , pLocalStorage->pMINI_CIRCUITS_CommandList[iCommandIndex].szSubDeviceName , pLocalStorage->pMINI_CIRCUITS_CommandList[iCommandIndex].szSubDeviceLocation );
STD_ERR( ModularZT__USB_ControlSend_SCPI ( pLocalStorage->hDriverHandle , NULL , &pCommand ,&retStr, &value ));
IF (( value == 0 ) , "Not successfully." );
if ( retStr )
{
StdError.error = atoi(retStr);
if ( IS_NOT_OK )
{
pError = strchr( retStr , ' ' );
if ( pError )
{
FORCE_ERR( StdError.error , pError )
}
}
}
Error:
if (hHandle)
CmtReleaseTSVPtr (hHandle);
RETURN_STDERR_POINTER;
}
t_std_error ndi_delete_vlan(npu_id_t npu_id, hal_vlan_id_t vlan_id)
{
sai_status_t sai_ret = SAI_STATUS_FAILURE;
nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(npu_id);
STD_ASSERT(ndi_db_ptr != NULL);
if ((sai_ret = ndi_sai_vlan_api(ndi_db_ptr)->remove_vlan((sai_vlan_id_t)vlan_id))
!= SAI_STATUS_SUCCESS) {
return STD_ERR(INTERFACE, CFG, sai_ret);
}
return STD_ERR_OK;
}
static t_std_error _cps_init ()
{
cps_api_operation_handle_t handle;
cps_api_return_code_t rc;
cps_api_registration_functions_t f;
rc = cps_api_operation_subsystem_init (&handle,1);
if (rc != cps_api_ret_code_OK) {
NAS_ACL_LOG_ERR ("NAS ACL CPS Subsystem Init failed");
return STD_ERR(QOS, FAIL, rc);
}
memset (&f, 0, sizeof(f));
f.handle = handle;
f._read_function = nas_acl_cps_api_read;
f._write_function = nas_acl_cps_api_write;
f._rollback_function = nas_acl_cps_api_rollback;
/*
* Register all ACL objects
* TODO: Need to check with CPS app teams, if ACL needs to register for
* OBSERVED state.
*/
cps_api_key_init (&f.key,
cps_api_qualifier_TARGET,
cps_api_obj_CAT_BASE_ACL,
0, /* register all sub-categories */
0);
rc = cps_api_register (&f);
if (rc != cps_api_ret_code_OK) {
NAS_ACL_LOG_ERR ("NAS ACL CPS object Register failed");
return STD_ERR(QOS, FAIL, rc);
}
return STD_ERR_OK;
}
t_std_error nas_mirror_create_session(cps_api_object_t obj) {
nas_mirror_entry entry;
nas_mirror_src_intf_map_t intf_map;
if(!nas_mirror_fill_entry(obj,&entry,intf_map,false)){
return STD_ERR(MIRROR,CFG,0);
}
std_mutex_simple_lock_guard lock(&nas_mirror_mutex);
if(ndi_mirror_create_session(entry.get_ndi_entry()) != STD_ERR_OK){
return STD_ERR(MIRROR,FAIL,0);
}
if(!entry.update_src_intf_map(intf_map)){
if(!entry.remove_src_intf()){
NAS_MIRROR_LOG(ERR,0,"Failed to remove source ports while create failure "
"for Mirror Session");
return STD_ERR(MIRROR,FAIL,0);
}
NAS_MIRROR_LOG(ERR,0,"Failed to Enable Mirroring on Source Ports");
ndi_mirror_delete_session(entry.get_ndi_entry());
return STD_ERR(MIRROR,FAIL,0);
}
nas_mirror_id_t id = nas_mirror_get_next_id();
entry.set_id(id);
cps_api_set_key_data(obj,BASE_MIRROR_ENTRY_ID,cps_api_object_ATTR_T_U32,
&id,sizeof(id));
nas::ndi_obj_id_table_t mirror_opaque_data_table;
mirror_opaque_data_table[entry.get_npu_id()] = entry.get_ndi_id();
cps_api_attr_id_t attr_id_list[] = {BASE_MIRROR_ENTRY_OPAQUE_DATA};
nas::ndi_obj_id_table_cps_serialize (mirror_opaque_data_table, obj, attr_id_list,
sizeof(attr_id_list)/sizeof(attr_id_list[0]));
NAS_MIRROR_LOG(INFO,3,"Created New Mirror Session with id %d",entry.get_id());
nas_mirror_table.insert(nas_mirror_table_pair(entry.get_id(),std::move(entry)));
return STD_ERR_OK;
}
/**
* This function gets the queue statistics
* @param ndi_port_id
* @param ndi_queue_id
* @param list of queue counter types to query
* @param number of queue counter types specified
* @param[out] counter stats
* return standard error
*/
t_std_error ndi_qos_get_queue_stats(ndi_port_t ndi_port_id,
ndi_obj_id_t ndi_queue_id,
BASE_QOS_QUEUE_STAT_t *counter_ids,
uint_t number_of_counters,
nas_qos_queue_stat_counter_t *stats)
{
sai_status_t sai_ret = SAI_STATUS_FAILURE;
nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(ndi_port_id.npu_id);
if (ndi_db_ptr == NULL) {
NDI_LOG_TRACE(ev_log_t_NDI, "NDI-QOS",
"npu_id %d not exist\n", ndi_port_id.npu_id);
return STD_ERR(QOS, CFG, 0);
}
std::vector<sai_queue_stat_counter_t> counter_id_list;
std::vector<uint64_t> counters(number_of_counters);
for (uint_t i= 0; i<number_of_counters; i++) {
counter_id_list.push_back(nas2sai_queue_counter_type.at(counter_ids[i]));
}
if ((sai_ret = ndi_sai_qos_queue_api(ndi_db_ptr)->
get_queue_stats(ndi2sai_queue_id(ndi_queue_id),
&counter_id_list[0],
number_of_counters,
&counters[0]))
!= SAI_STATUS_SUCCESS) {
NDI_LOG_TRACE(ev_log_t_NDI, "NDI-QOS",
"queue get stats fails: npu_id %u\n",
ndi_port_id.npu_id);
return STD_ERR(QOS, CFG, sai_ret);
}
// copy the stats out
for (uint i= 0; i<number_of_counters; i++) {
_fill_counter_stat_by_type(counter_id_list[i], counters[i], stats);
}
return STD_ERR_OK;
}
t_std_error nas_os_util_int_get_if_details(const char *name, cps_api_object_t obj)
{
struct ifreq ifr;
strncpy(ifr.ifr_ifrn.ifrn_name,name,sizeof(ifr.ifr_ifrn.ifrn_name)-1);
const int NAS_LINK_MTU_HDR_SIZE = 32;
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock==-1) return STD_ERR(INTERFACE,FAIL,errno);
t_std_error err = STD_ERR(INTERFACE,FAIL,errno);
cps_api_object_attr_add(obj, IF_INTERFACES_INTERFACE_NAME, name, (strlen(name)+1));
do {
if (ioctl(sock, SIOCGIFFLAGS, &ifr) >= 0) {
cps_api_object_attr_add_u32(obj,BASE_IF_LINUX_IF_INTERFACES_INTERFACE_IF_FLAGS, ifr.ifr_flags);
cps_api_object_attr_add_u32(obj,IF_INTERFACES_INTERFACE_ENABLED,
(ifr.ifr_flags & IFF_UP) ? true :false);
} else break;
ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
if (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0) {
char buff[40];
const char *_p = std_mac_to_string((const hal_mac_addr_t *)(ifr.ifr_hwaddr.sa_data),
buff, sizeof(buff));
cps_api_object_attr_add(obj,DELL_IF_IF_INTERFACES_INTERFACE_PHYS_ADDRESS,_p,strlen(_p)+1);
} else break;
if (ioctl(sock, SIOCGIFMTU, &ifr) >= 0) {
cps_api_object_attr_add_u32(obj, DELL_IF_IF_INTERFACES_INTERFACE_MTU,
(ifr.ifr_mtu + NAS_LINK_MTU_HDR_SIZE));
} else break;
err = STD_ERR_OK;
} while(0);
close(sock);
return err;
}
t_std_error std_event_server_init(std_event_server_handle_t *handle,
const char * event_channel_name, size_t threads) {
std_socket_event_server_t * p = new std_socket_event_server_t;
if (p==NULL) {
EV_LOG(ERR,COM,0,"COM-EVENT-INIT-FAILED","Failed to initialize the event service");
return STD_ERR(COM,NOMEM,0);
}
std_socket_server_t serv;
memset(&serv,0,sizeof(serv));
serv.context = p;
serv.name = COM_EVT_SERV_NAME;
serv.thread_pool_size = threads;
serv.new_client = event_new_client;
serv.del_client = event_del_client;
serv.some_data = event_some_data;
setup_address(&serv.address, event_channel_name);
if (std_socket_service_init(&p->m_sock_service,&serv)!=STD_ERR_OK) {
delete p;
return STD_ERR(COM,FAIL,0);
}
t_std_error rc = STD_ERR(COM,FAIL,0);
do {
if ((rc=std_rw_lock_create_default(&p->m_tree_lock))!=STD_ERR_OK) break;
if (std_socket_service_run(p->m_sock_service)!=STD_ERR_OK) break;
*handle = p;
return rc;
} while (0);
delete p;
return rc;
}
t_std_error dn_pas_psu_get(cps_api_get_params_t * param, size_t key_idx)
{
t_std_error result = STD_ERR_OK, ret;
cps_api_object_t req_obj = cps_api_object_list_get(param->filters, key_idx);
cps_api_qualifier_t qual;
bool slot_valid;
uint_t slot, slot_start, slot_limit;
dn_pas_obj_key_psu_get(req_obj, &qual, &slot_valid, &slot);
if (slot_valid) {
slot_start = slot_limit = slot;
} else {
struct pas_config_entity *e;
e = dn_pas_config_entity_get_type(PLATFORM_ENTITY_TYPE_PSU);
if (e == 0) return (STD_ERR(PAS, FAIL, 0));
slot_start = 1;
slot_limit = e->num_slots;
}
for (slot = slot_start; slot <= slot_limit; ++slot) {
ret = dn_pas_psu_get1(param, qual, slot);
if (ret == STD_ERR(PAS, NEXIST, 0)) {
if (slot_valid) {
result = STD_ERR(PAS, NEXIST, 0);
}
break;
} else if (STD_IS_ERR(ret)) {
result = STD_ERR(PAS, FAIL, 0);
}
}
return (result);
}
t_std_error ndi_set_vlan_learning(npu_id_t npu_id, hal_vlan_id_t vlan_id,
bool learning_mode)
{
nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(npu_id);
if(ndi_db_ptr == NULL){
return STD_ERR(NPU, PARAM, 0);
}
sai_status_t sai_ret;
sai_attribute_t vlan_attr;
vlan_attr.id = SAI_VLAN_ATTR_LEARN_DISABLE;
vlan_attr.value.booldata = learning_mode;
if ((sai_ret = ndi_sai_vlan_api(ndi_db_ptr)->set_vlan_attribute(vlan_id
,&vlan_attr))!= SAI_STATUS_SUCCESS) {
NDI_VLAN_LOG_ERROR("Returned failure %d while setting learning mode for VLAN ID %d",
sai_ret, vlan_id);
return STD_ERR(INTERFACE, CFG, sai_ret);
}
return STD_ERR_OK;
}
t_std_error nas_mirror_get_all_info(cps_api_object_list_t list){
std_mutex_simple_lock_guard lock(&nas_mirror_mutex);
auto it = nas_mirror_table.begin();
for ( ; it != nas_mirror_table.end() ; ++it){
cps_api_object_t obj=cps_api_object_create();
if (obj==NULL) {
NAS_MIRROR_LOG(ERR,0,"Failed to create a new object");
return STD_ERR(MIRROR,NOMEM,0);
}
if (!cps_api_object_list_append(list,obj)) {
cps_api_object_delete(obj);
NAS_MIRROR_LOG(ERR,ev_log_s_MINOR,"Failed to append object to object list");
return STD_ERR(MIRROR,FAIL,0);
}
nas_mirror_fill_object(obj,it);
}
return STD_ERR_OK;
}
t_std_error ndi_vlan_stats_get(npu_id_t npu_id, hal_vlan_id_t vlan_id,
ndi_stat_id_t *ndi_stat_ids,
uint64_t* stats_val, size_t len)
{
sai_vlan_id_t sai_vlan_id;
const unsigned int list_len = len;
sai_vlan_stat_counter_t sai_vlan_stats_ids[list_len];
t_std_error ret_code = STD_ERR_OK;
sai_status_t sai_ret = SAI_STATUS_FAILURE;
nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(npu_id);
if (ndi_db_ptr == NULL) {
NDI_VLAN_LOG_ERROR("Invalid NPU Id %d passed",npu_id);
return STD_ERR(NPU, PARAM, 0);
}
if ((ret_code = ndi_sai_vlan_id_get(npu_id, vlan_id, &sai_vlan_id) != STD_ERR_OK)) {
return ret_code;
}
size_t ix = 0;
for ( ; ix < len ; ++ix){
if(!ndi_to_sai_vlan_stats(ndi_stat_ids[ix],&sai_vlan_stats_ids[ix])){
return STD_ERR(NPU,PARAM,0);
}
}
if ((sai_ret = ndi_sai_vlan_api(ndi_db_ptr)->get_vlan_stats(sai_vlan_id,sai_vlan_stats_ids,
len, stats_val)) != SAI_STATUS_SUCCESS) {
NDI_VLAN_LOG_ERROR("Vlan stats Get failed for npu %d, vlan %d, ret %d \n",
npu_id, vlan_id, sai_ret);
return STD_ERR(NPU, FAIL, sai_ret);
}
return ret_code;
}
t_std_error ndi_add_or_del_ports_to_vlan(npu_id_t npu_id, hal_vlan_id_t vlan_id,
ndi_port_list_t *p_tagged_list,
ndi_port_list_t *p_untagged_list,
bool add_vlan)
{
sai_status_t sai_ret = SAI_STATUS_FAILURE;
uint32_t t_port_count = p_tagged_list ? p_tagged_list->port_count : 0 ;
uint32_t ut_port_count = p_untagged_list ? p_untagged_list->port_count : 0 ;
uint32_t port_count = ut_port_count + t_port_count;
sai_vlan_port_t sai_vlan_port_list[port_count];
nas_ndi_db_t *ndi_db_ptr = ndi_db_ptr_get(npu_id);
if(ndi_db_ptr == NULL){
return STD_ERR(NPU, PARAM, 0);
}
memset(sai_vlan_port_list, 0, (sizeof(sai_vlan_port_t) * port_count));
ndi_sai_copy_vlan_ports(&sai_vlan_port_list[0], p_tagged_list, p_untagged_list);
if(add_vlan) {
if ((sai_ret = ndi_sai_vlan_api(ndi_db_ptr)->add_ports_to_vlan((sai_vlan_id_t)vlan_id,
port_count,
&sai_vlan_port_list[0]))
!= SAI_STATUS_SUCCESS) {
return STD_ERR(INTERFACE, CFG, sai_ret);
}
}
else {
if ((sai_ret = ndi_sai_vlan_api(ndi_db_ptr)->remove_ports_from_vlan((sai_vlan_id_t)vlan_id,
port_count, &sai_vlan_port_list[0]))
!= SAI_STATUS_SUCCESS) {
return STD_ERR(INTERFACE, CFG, sai_ret);
}
}
return STD_ERR_OK;
}
static t_std_error ndi_packet_get_attr (const sai_attribute_t *p_attr, ndi_packet_attr_t *p_ndi_attr)
{
ndi_port_t ndi_port;
sai_object_id_t sai_port;
if(!p_attr) return STD_ERR(INTERFACE, FAIL, 0);
switch (p_attr->id) {
case SAI_HOSTIF_PACKET_INGRESS_PORT:
sai_port = p_attr->value.oid;
if (ndi_npu_port_id_get(sai_port, &ndi_port.npu_id, &ndi_port.npu_port) != STD_ERR_OK) {
NDI_LOG_TRACE(ev_log_t_NDI, "NDI-PKT", "Port get failed: sai port 0x%llx", sai_port);
return STD_ERR(INTERFACE, FAIL, 0);
}
p_ndi_attr->npu_id = ndi_port.npu_id;
p_ndi_attr->rx_port = ndi_port.npu_port;
break;
case SAI_HOSTIF_PACKET_INGRESS_LAG:
// @Todo - to handle lag case
break;
case SAI_HOSTIF_PACKET_TRAP_ID:
if(p_attr->value.s32 == SAI_HOSTIF_TRAP_ID_SAMPLEPACKET)
p_ndi_attr->trap_id = NDI_PACKET_TRAP_ID_SAMPLEPACKET;
else if (p_attr->value.s32 == SAI_HOSTIF_TRAP_ID_L3_MTU_ERROR)
p_ndi_attr->trap_id = NDI_PACKET_TRAP_ID_L3_MTU_ERROR;
break;
default:
NDI_LOG_TRACE(ev_log_t_NDI, "NDI-PKT", "Invalid attribute");
return STD_ERR(INTERFACE, FAIL, 0);
}
return STD_ERR_OK;
}
