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; }