/**************************************************************************** * Name : glnd_lib_req * * Description : This is the NCS SE API which is used to init/destroy or * Create/destroy PWE's. This will be called by SBOM. * * Arguments : req_info - This is the pointer to the input information * which SBOM gives. * * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.. * * Notes : None. *****************************************************************************/ uint32_t glnd_lib_req(NCS_LIB_REQ_INFO *req_info) { uint32_t res = NCSCC_RC_FAILURE; TRACE_ENTER(); switch (req_info->i_op) { case NCS_LIB_REQ_CREATE: if( (res = glnd_se_lib_create(NCS_HM_POOL_ID_COMMON))!= NCSCC_RC_SUCCESS ) TRACE_2("GLND se lib create failed"); break; case NCS_LIB_REQ_DESTROY: if( (res = glnd_se_lib_destroy()) != NCSCC_RC_SUCCESS ) TRACE_2("GLND se lib destroy failed"); break; default: break; } TRACE_LEAVE2("%s return value %u", (res == NCSCC_RC_SUCCESS)?"SUCCESS":"FAILURE", res); return (res); }
/******************************************************************************************* * Name : cpd_a2s_ckpt_dest_down * * Description : Function to delete the destination of the already existing * checkpoint * * Arguments : CPD_CKPT_INFO_NODE - CPD Checkpoint info node * * Return Values : None , Error message is logged * ********************************************************************************************/ void cpd_a2s_ckpt_dest_down(CPD_CB *cb, CPD_CKPT_INFO_NODE *ckpt_node, MDS_DEST *dest) { CPD_MBCSV_MSG cpd_msg; uint32_t rc = SA_AIS_OK; TRACE_ENTER(); memset(&cpd_msg, '\0', sizeof(CPD_MBCSV_MSG)); cpd_msg.type = CPD_A2S_MSG_CKPT_DEST_DOWN; cpd_msg.info.dest_down.ckpt_id = ckpt_node->ckpt_id; cpd_msg.info.dest_down.mds_dest = *dest; TRACE("CPND 1 IS IN RESTART NOW "); rc = cpd_mbcsv_async_update(cb, &cpd_msg); if (rc != SA_AIS_OK) TRACE_4("cpd A2S ckpt async update failed for ckptid:%llx,dest: %"PRIu64,cpd_msg.info.dest_down.ckpt_id, *dest); else TRACE_1("cpd A2S ckpt async update del success for ckptid:%llx,dest:%"PRIu64,cpd_msg.info.dest_down.ckpt_id, *dest); TRACE_LEAVE(); }
static void Permedia2SubsequentHorVertLine(ScrnInfoPtr pScrn,int x,int y,int len,int dir) { GLINTPtr pGlint = GLINTPTR(pScrn); TRACE_ENTER("Permedia2SubsequentHorVertLine"); GLINT_WAIT(6); GLINT_WRITE_REG(x<<16, StartXDom); GLINT_WRITE_REG(y<<16, StartY); if (dir == DEGREES_0) { GLINT_WRITE_REG(1<<16, dXDom); GLINT_WRITE_REG(0<<16, dY); } else { GLINT_WRITE_REG(0<<16, dXDom); GLINT_WRITE_REG(1<<16, dY); } GLINT_WRITE_REG(len, GLINTCount); GLINT_WRITE_REG(PrimitiveLine, Render); }
/** * response to the lib on a saNtfNotificationSend request * @param error error code sent back to the client * @param notificationId * @param mdsCtxt * @param frDest * */ void notfication_result_lib(SaAisErrorT error, SaNtfIdentifierT notificationId, MDS_SYNC_SND_CTXT *mdsCtxt, MDS_DEST frDest) { uns32 rc; ntfsv_msg_t msg; TRACE_ENTER(); msg.type = NTFSV_NTFA_API_RESP_MSG; msg.info.api_resp_info.type = NTFSV_SEND_NOT_RSP; msg.info.api_resp_info.rc = error; msg.info.api_resp_info.param.send_not_rsp.notificationId = notificationId; TRACE_4("not_id: %llu, rv: %u", notificationId, error); rc = ntfs_mds_msg_send(ntfs_cb, &msg, &frDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH); if (rc != NCSCC_RC_SUCCESS) { TRACE("ntfs_mds_msg_send FAILED"); /* TODO: what to do exit here? */ } TRACE_LEAVE(); };
void saImmOmAdminOperationContinueAsync_01(void) { TRACE_ENTER(); const SaNameT objectName = {strlen("opensafImm=opensafImm,safApp=safImmService"), "opensafImm=opensafImm,safApp=safImmService"}; const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__; SaImmAdminOwnerHandleT ownerHandle; SaInvocationT invocation=999; SaImmContinuationIdT continuationId = 666; safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK); safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK); test_validate(saImmOmAdminOperationContinueAsync( ownerHandle, invocation, &objectName, continuationId), SA_AIS_ERR_NOT_SUPPORTED); safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK); safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK); TRACE_LEAVE(); }
/** * Response to the lib on a saNtfNotificationReadInitialize * request * * @param error error code sent back to the library * @param readerId out parameter, unique id for the new reader * set by admin to identify a reader. */ void new_reader_res_lib(SaAisErrorT error, unsigned int readerId, MDS_DEST mdsDest, MDS_SYNC_SND_CTXT *mdsCtxt) { uns32 rc = NCSCC_RC_SUCCESS; ntfsv_msg_t msg; TRACE_ENTER(); msg.type = NTFSV_NTFA_API_RESP_MSG; msg.info.api_resp_info.type = NTFSV_READER_INITIALIZE_RSP; msg.info.api_resp_info.rc = error; msg.info.api_resp_info.param.reader_init_rsp.readerId = readerId; TRACE_4("readerId: %u, rv: %u", readerId, error); rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mdsDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH); if (rc != NCSCC_RC_SUCCESS) { TRACE("ntfs_mds_msg_send FAILED"); /* TODO: what to do exit here? */ } /* TODO: async update*/ };
/****************************************************************************************************************** * Name :glsv_gld_mbcsv_chgrole * * Description : To assign role for a component * Arguments : GLSV_GLD_CB - cb pointer * * Return Values : Success / Error * * Notes : This API is use for setting the role. Role Standby - initiate Cold Sync Request if it finds Active Role Active - send ckpt data to multiple standby peers *********************************************************************************************************************/ uint32_t glsv_gld_mbcsv_chgrole(GLSV_GLD_CB *gld_cb) { NCS_MBCSV_ARG arg; uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); memset(&arg, '\0', sizeof(NCS_MBCSV_ARG)); arg.i_op = NCS_MBCSV_OP_CHG_ROLE; arg.i_mbcsv_hdl = gld_cb->mbcsv_handle; arg.info.chg_role.i_ckpt_hdl = gld_cb->o_ckpt_hdl; arg.info.chg_role.i_ha_state = gld_cb->ha_state; /* ha_state is assigned at the time of amf_init where csi_set_callback will assign the state */ LOG_IN("Setting the state HaState as :%d", gld_cb->ha_state); if (ncs_mbcsv_svc(&arg) != SA_AIS_OK) { LOG_ER("GLD mbcsv chgrole failed"); rc = NCSCC_RC_FAILURE; } TRACE_LEAVE(); return rc; }
/** * Response to the lib after saNtfNotificationUnsubscribe request * * @param error error code sent back to the library * @param subId Subscribtion id for the canceled subscription */ void unsubscribe_res_lib(SaAisErrorT error, SaNtfSubscriptionIdT subId, MDS_DEST mdsDest, MDS_SYNC_SND_CTXT *mdsCtxt) { uns32 rc = NCSCC_RC_SUCCESS; ntfsv_msg_t msg; TRACE_ENTER(); msg.type = NTFSV_NTFA_API_RESP_MSG; msg.info.api_resp_info.type = NTFSV_UNSUBSCRIBE_RSP; msg.info.api_resp_info.rc = error; msg.info.api_resp_info.param.unsubscribe_rsp.subscriptionId = subId; TRACE_4("subscriptionId: %u, rv: %u", subId, error); rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mdsDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH); if (rc != NCSCC_RC_SUCCESS) { TRACE("ntfs_mds_msg_send FAILED"); /* TODO: what to do exit here? */ } TRACE_LEAVE(); };
/**************************************************************************** Name : avnd_pgdb_mem_rec_rmv Description : This routine removes a PG member record from the PG record. Arguments : cb - ptr to the AvND control block pg - ptr to the pg rec comp_name - ptr to the comp-name Return Values : ptr to the pg member rec, if successfully removed 0, otherwise Notes : This routine only pops the cooresponding member record. It doesn't delete it. ******************************************************************************/ AVND_PG_MEM *avnd_pgdb_mem_rec_rmv(AVND_CB *cb, AVND_PG *pg, SaNameT *comp_name) { AVND_PG_MEM *pg_mem = 0; TRACE_ENTER(); /* get the pg mem record */ pg_mem = m_AVND_PGDB_MEM_REC_GET(*pg, *comp_name); if (!pg_mem) return 0; /* remove from the dll */ ncs_db_link_list_remove(&pg->mem_list, (uns8 *)comp_name); /* update the params that are no longer valid */ pg_mem->info.change = SA_AMF_PROTECTION_GROUP_REMOVED; pg_mem->info.member.haState = 0; TRACE_LEAVE(); return pg_mem; }
/**************************************************************************** * Name : cpnd_ckpt_sec_get_create * * Description : Function to Find the section in a checkpoint before create. * * Arguments : CPND_CKPT_NODE *cp_node - Check point node. * : SaCkptSectionIdT id - Section Identifier * * Return Values : NULL/CPND_CKPT_SECTION_INFO * * Notes : None. *****************************************************************************/ CPND_CKPT_SECTION_INFO *cpnd_ckpt_sec_get_create(CPND_CKPT_NODE *cp_node, SaCkptSectionIdT *id) { CPND_CKPT_SECTION_INFO *pSecPtr = NULL; TRACE_ENTER(); if (cp_node->replica_info.n_secs == 0) { TRACE_2("cpnd replica has no sections for ckpt_id:%llx",cp_node->ckpt_id); TRACE_LEAVE(); return NULL; } pSecPtr = cp_node->replica_info.section_info; while (pSecPtr != NULL) { if ((pSecPtr->sec_id.idLen == id->idLen) && (memcmp(pSecPtr->sec_id.id, id->id, id->idLen) == 0)) { TRACE_LEAVE(); return pSecPtr; } pSecPtr = pSecPtr->next; } TRACE_LEAVE(); return NULL; }
static void __exit exit_dldwd_cs(void) { TRACE_ENTER("dldwd"); unregister_pccard_driver(&dev_info); if (dev_list) DEBUG(0, "orinoco_cs: Removing leftover devices.\n"); while (dev_list != NULL) { del_timer(&dev_list->release); if (dev_list->state & DEV_CONFIG) dldwd_cs_release((u_long) dev_list); dldwd_cs_detach(dev_list); } TRACE_EXIT("dldwd"); exit_dldwd(); }
/**************************************************************************** * Name : cpd_amf_register * * Description : CPD registers with AMF for involking process. * * Arguments : cpd_cb - Ifsv control block pointer. * * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE. * * Notes : None. *****************************************************************************/ uint32_t cpd_amf_register(CPD_CB *cpd_cb) { SaAisErrorT error; TRACE_ENTER(); /* get the component name */ error = saAmfComponentNameGet(cpd_cb->amf_hdl, &cpd_cb->comp_name); if (error != SA_AIS_OK) { LOG_ER("cpd amf compname get failed with Error: %u",error); TRACE_LEAVE(); return NCSCC_RC_FAILURE; } if (saAmfComponentRegister(cpd_cb->amf_hdl, &cpd_cb->comp_name, (SaNameT *)NULL) == SA_AIS_OK) { TRACE_LEAVE2("cpd amf register success for %s",cpd_cb->comp_name.value); return NCSCC_RC_SUCCESS; } else { TRACE_LEAVE2("cpd Amf component register failed for %s",cpd_cb->comp_name.value); return NCSCC_RC_FAILURE; } }
/***************************************************************************** PROCEDURE NAME : gld_process_send_non_master_status DESCRIPTION : This function sends the nonmaster status to all the masters corresponding to the resources opened by this node ARGUMENTS :gld_cb - ptr to the GLD control block node_details status RETURNS :NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS NOTES : None *****************************************************************************/ static uint32_t gld_process_send_non_master_status(GLSV_GLD_CB *gld_cb, GLSV_GLD_GLND_DETAILS *node_details, uint32_t status) { GLSV_GLD_GLND_RSC_REF *glnd_rsc = NULL; GLSV_GLND_EVT glnd_evt; NCSMDS_INFO snd_mds; uint32_t res = NCSCC_RC_FAILURE; TRACE_ENTER(); glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)0); while (glnd_rsc) { if (glnd_rsc->rsc_info->node_list->node_id != node_details->node_id) { memset(&glnd_evt, '\0', sizeof(GLSV_GLND_EVT)); glnd_evt.type = GLSV_GLND_EVT_NON_MASTER_INFO; glnd_evt.info.non_master_info.dest_id = node_details->dest_id; glnd_evt.info.non_master_info.status = status; snd_mds.i_mds_hdl = gld_cb->mds_handle; snd_mds.i_svc_id = NCSMDS_SVC_ID_GLD; snd_mds.i_op = MDS_SEND; snd_mds.info.svc_send.i_msg = (NCSCONTEXT)&glnd_evt; snd_mds.info.svc_send.i_to_svc = NCSMDS_SVC_ID_GLND; snd_mds.info.svc_send.i_priority = MDS_SEND_PRIORITY_HIGH; snd_mds.info.svc_send.i_sendtype = MDS_SENDTYPE_SND; snd_mds.info.svc_send.info.snd.i_to_dest = glnd_rsc->rsc_info->node_list->dest_id; res = ncsmds_api(&snd_mds); if (res != NCSCC_RC_SUCCESS) { LOG_ER("MDS Send failed"); goto end; } } glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)&glnd_rsc->rsc_id); } end: TRACE_LEAVE(); return res; }
/************************************************************ Start the unbind of a network driver from the protocol driver ************************************************************/ VOID NDIS_API PacketUnbindAdapter( OUT PNDIS_STATUS Status, IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE UnbindContext ) { POPEN_INSTANCE Open; NDIS_STATUS nsCloseStatus; TRACE_ENTER( "UnbindAdapter" ); Open = (POPEN_INSTANCE)ProtocolBindingContext; Open->BindAdapterContext = UnbindContext; /*clean the pending requests*/ PacketCleanUp( Status, Open ); Open->Status = NDIS_STATUS_PENDING; /*Calls NDIS to close the selected adapter*/ NdisCloseAdapter( &nsCloseStatus, Open->AdapterHandle ); if ( nsCloseStatus == NDIS_STATUS_PENDING ) { while ( Open->Status == NDIS_STATUS_PENDING ) YieldExecution(); } else { PacketUnbindAdapterComplete( Open, nsCloseStatus ); } *Status = Open->Status; if ( *Status == NDIS_STATUS_SUCCESS ) { NdisFreeMemory( Open, sizeof( OPEN_INSTANCE ) , 0 ); } else { IF_TRACE( "Unbind Operation FAILED!" ); } TRACE_LEAVE( "CloseAdapter" ); return; }
/** * Thread start routine to register with AMF and start health check * Error handling: exits process at failure * @param __cb control block pointer */ static void* amf_init_start(void *notused) { SaAisErrorT error; const char *health_key; SaAmfHealthcheckKeyT healthy; TRACE_ENTER(); error = saAmfComponentRegister(immd_cb->amf_hdl, &immd_cb->comp_name, NULL); if (error != SA_AIS_OK) { LOG_ER("saAmfComponentRegister failed: %u, exiting", error); exit(1); } memset(&healthy, 0, sizeof(healthy)); health_key = getenv("IMMSV_ENV_HEALTHCHECK_KEY"); if (health_key == NULL) { strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key)); healthy.keyLen = (SaUint16T) strlen((char *)healthy.key); } else { healthy.keyLen = (SaUint16T) strlen((char *)health_key); if (healthy.keyLen < sizeof(healthy.key)) { strncpy((char *)healthy.key, health_key, sizeof(healthy.key)); } else { LOG_ER("Health check key too long:%u, exiting", healthy.keyLen); exit(1); } } error = saAmfHealthcheckStart(immd_cb->amf_hdl, &immd_cb->comp_name, &healthy, SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER); if (error != SA_AIS_OK) { LOG_ER("saAmfHealthcheckStart failed: %u, exiting", error); exit(1); } TRACE_LEAVE(); return NULL; }
NTSTATUS NTAPI WSKCloseSocket( IN PWSK_SOCKET WskSocket ) { KEVENT CompletionEvent = { 0 }; PIRP Irp = NULL; NTSTATUS Status = STATUS_UNSUCCESSFUL; TRACE_ENTER(); if (g_SocketsState != INITIALIZED || !WskSocket) { TRACE_EXIT(); return STATUS_INVALID_PARAMETER; } Status = InitWskData(&Irp, &CompletionEvent); if (!NT_SUCCESS(Status)) { TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCloseSocket()::InitWskData() failed with status 0x%08X\n", Status); TRACE_EXIT(); return Status; } Status = ((PWSK_PROVIDER_BASIC_DISPATCH)WskSocket->Dispatch)->WskCloseSocket(WskSocket, Irp); if (Status == STATUS_PENDING) { KeWaitForSingleObject(&CompletionEvent, Executive, KernelMode, FALSE, NULL); Status = Irp->IoStatus.Status; } else if (Status != STATUS_SUCCESS) { TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCloseSocket()::Dispatch::WskSocket() failed with status 0x%08X\n", Status); } IoFreeIrp(Irp); TRACE_EXIT(); return Status; }
HRESULT CKsIrpTarget::SetPropertyMulti( IN REFGUID guidPropertySet, IN ULONG nProperty, OUT PKSMULTIPLE_ITEM* ppKsMultipleItem) { TRACE_ENTER(); HRESULT hr = S_OK; ULONG cbMultipleItem = 0; ULONG ulReturned = 0; KSPROPERTY ksProperty; ksProperty.Set = guidPropertySet; ksProperty.Id = nProperty; ksProperty.Flags = KSPROPERTY_TYPE_SET; hr = SyncIoctl( m_handle, IOCTL_KS_PROPERTY, &ksProperty, sizeof(KSPROPERTY), NULL, 0, &cbMultipleItem); if (SUCCEEDED(hr)) { *ppKsMultipleItem = (PKSMULTIPLE_ITEM)LocalAlloc(LPTR, cbMultipleItem); hr = SyncIoctl ( m_handle, IOCTL_KS_PROPERTY, &ksProperty, sizeof(KSPROPERTY), (PVOID)*ppKsMultipleItem, cbMultipleItem, &ulReturned); } TRACE_LEAVE_HRESULT(hr); return hr; }
void File_impl::setFilePointer (CORBA::ULong _filePointer) throw (CORBA::SystemException, CF::File::InvalidFilePointer, CF::FileException) { TRACE_ENTER(File_impl) boost::mutex::scoped_lock lock(interfaceAccess); if (_filePointer > this->_local_sizeOf ()) { LOG_ERROR(File_impl, "File pointer set beyond EOF") throw CF::File::InvalidFilePointer (); } int fsOpSuccessAttempts = 0; bool fsOpSuccess = false; while (!fsOpSuccess) { try { f.seekg(_filePointer); f.seekp(_filePointer); fsOpSuccess = true; } catch ( const fs::filesystem_error& ex ) { LOG_WARN(File_impl, "Error in filesystem: "<<ex.what()<<". Attempting again") fsOpSuccessAttempts++; if (fsOpSuccessAttempts == 10) { break; } usleep(10000); } catch ( ... ) { LOG_WARN(File_impl, "Caught an unhandled file system exception. Attempting again") fsOpSuccessAttempts++; if (fsOpSuccessAttempts == 10) { break; } usleep(10000); } } if (!fsOpSuccess) { LOG_ERROR(File_impl, "Error setting file pointer for file, " << fName); throw (CF::File::IOException (CF::CF_EIO, "[File_impl::setFilePointer] Error setting file pointer for file")); } TRACE_EXIT(File_impl) }
void adjust_xy( short ck , short oldX, short oldY, short &newX, short &newY ) { TRACE_ENTER("adjust_xy"); if (ck) //control key? { // | center of leftmost rectangle // v newX = max( (cxBlock / 2), // | centered to inside rectangle // v min( ((oldX/cxBlock)*cxBlock) + (cxBlock / 2), // | center of rightmost rectangle // v (cxBlock * (DIVISIONS -1)) + (cxBlock / 2) ) ) ; TRACE_INT(newX); // | center of leftmost rectangle // v newY = max( (cyBlock / 2), // | centered to inside rectangle // v min( ((oldY/cyBlock)*cyBlock) + (cyBlock / 2), // | center of rightmost rectangle // v (cyBlock * (DIVISIONS -1)) + (cyBlock / 2) ) ) ; TRACE_INT(newY); } else { newX = max(0,min(oldX,cxClient)); newY = max(0,min(oldY,cyClient)); } TRACE_EXIT("adjust_xy"); }
/**************************************************************************** Name : lga_mds_finalize Description : This routine unregisters the LGA Service from MDS. Arguments : cb - ptr to the LGA control block Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None. ******************************************************************************/ void lga_mds_finalize(lga_cb_t *cb) { NCSMDS_INFO mds_info; uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* Un-install your service into MDS. No need to cancel the services that are subscribed */ memset(&mds_info, '\0', sizeof(NCSMDS_INFO)); mds_info.i_mds_hdl = cb->mds_hdl; mds_info.i_svc_id = NCSMDS_SVC_ID_LGA; mds_info.i_op = MDS_UNINSTALL; if ((rc = ncsmds_api(&mds_info)) != NCSCC_RC_SUCCESS) { TRACE("mds api call failed"); } TRACE_LEAVE(); return; }
static int airport_open(struct net_device *dev) { dldwd_priv_t *priv = dev->priv; dldwd_card_t* card = (dldwd_card_t *)priv->card; int rc; TRACE_ENTER(priv->ndev.name); rc = dldwd_reset(priv); if (rc) airport_stop(dev); else { card->open = 1; netif_device_attach(dev); } // TRACE_EXIT(priv->ndev.name); return rc; }
void saImmOmAdminOperationContinue_02(void) { TRACE_ENTER(); const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__; SaImmAdminOwnerHandleT ownerHandle; SaImmContinuationIdT continuationId = 666; SaAisErrorT operationReturnValue=SA_AIS_OK; SaImmAdminOperationParamsT_2 **returnParams; safassert(saImmOmInitialize_o2(&immOmHandle, &immOmA2bCallbacks, &immVersion), SA_AIS_OK); safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK); test_validate(saImmOmAdminOperationContinue_o2( ownerHandle, &rootObj, continuationId, &operationReturnValue, &returnParams), SA_AIS_ERR_NOT_SUPPORTED); safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK); safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK); TRACE_LEAVE(); }
VOID NTAPI NPF_WSKFreeSockets( ) { TRACE_ENTER(); if (g_IPv4Socket) { WSKCloseSocket(g_IPv4Socket); g_IPv4Socket = NULL; } if (g_IPv6Socket) { WSKCloseSocket(g_IPv6Socket); g_IPv6Socket = NULL; } TRACE_EXIT(); }
/** * Function to reset the poll fdlist * * @param fd * * @return NCSCC_RC_SUCCESS * @return NCSCC_RC_FAILURE * */ uint32_t dtm_intranode_reset_poll_fdlist(int fd) { DTM_INTRANODE_POLLFD_LIST *mov_ptr = dtm_intranode_cb->fd_list_ptr_head; TRACE_ENTER(); if (mov_ptr == NULL) { LOG_ER("DTM:Unable to set the event in the poll list"); return NCSCC_RC_FAILURE; } while (mov_ptr != NULL) { if (fd == mov_ptr->dtm_intranode_fd.fd) { mov_ptr->dtm_intranode_fd.events = POLLIN; dtm_intranode_fill_fd_set(); return NCSCC_RC_SUCCESS; } mov_ptr = mov_ptr->next; } LOG_ER("DTM:Unable to set the event in the poll list"); TRACE_LEAVE(); return NCSCC_RC_FAILURE; }
static uint32_t cpa_mds_rcv(CPA_CB *cb, MDS_CALLBACK_RECEIVE_INFO *rcv_info) { uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); CPSV_EVT *evt = (CPSV_EVT *)rcv_info->i_msg; evt->sinfo.ctxt = rcv_info->i_msg_ctxt; evt->sinfo.dest = rcv_info->i_fr_dest; evt->sinfo.to_svc = rcv_info->i_fr_svc_id; /* Process the received event at CPA */ if (cpa_process_evt(cb, evt) != NCSCC_RC_SUCCESS) rc = NCSCC_RC_FAILURE; /* Free the Event */ m_MMGR_FREE_CPSV_EVT(evt, NCS_SERVICE_ID_CPA); TRACE_LEAVE2("retal = %d",rc); return rc; }
static void Permedia2SubsequentFillRectSolid(ScrnInfoPtr pScrn, int x, int y, int w, int h) { GLINTPtr pGlint = GLINTPTR(pScrn); int speed = 0; TRACE_ENTER("Permedia2SubsequentFillRectSolid"); if (pGlint->ROP == GXcopy) { GLINT_WAIT(3); Permedia2LoadCoord(pScrn, x, y, w, h); speed = FastFillEnable; } else { GLINT_WAIT(4); Permedia2LoadCoord(pScrn, x>>pGlint->BppShift, y, (w+7)>>pGlint->BppShift, h); GLINT_WRITE_REG(x<<16|(x+w), PackedDataLimits); speed = 0; } GLINT_WRITE_REG(PrimitiveRectangle | XPositive | YPositive | speed, Render); TRACE_EXIT("Permedia2SubsequentFillRectSolid"); }
/**************************************************************************** Name : ava_hdl_init Description : This routine initializes the handle database. Arguments : hdl_db - ptr to the handle database Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ uint32_t ava_hdl_init(AVA_HDL_DB *hdl_db) { NCS_PATRICIA_PARAMS param; uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); memset(¶m, 0, sizeof(NCS_PATRICIA_PARAMS)); /* init the hdl db tree */ param.key_size = sizeof(uint32_t); param.info_size = 0; rc = ncs_patricia_tree_init(&hdl_db->hdl_db_anchor, ¶m); if (NCSCC_RC_SUCCESS == rc) hdl_db->num = 0; else TRACE("Patricia tree init failed for Handled DB"); TRACE_LEAVE(); return rc; }
/**************************************************************************** * Name : glnd_se_lib_destroy * * Description : This is the function which destroy the GLND libarary. * * Arguments : * * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE. * * Notes : None. *****************************************************************************/ uint32_t glnd_se_lib_destroy() { GLND_CB *glnd_cb; uint32_t rc = NCSCC_RC_FAILURE; TRACE_ENTER(); /* take the handle */ glnd_cb = (GLND_CB *)m_GLND_TAKE_GLND_CB; if (!glnd_cb) { LOG_ER("GLND cb take handle failed"); goto end; } if ((rc = glnd_cb_destroy(glnd_cb)) != NCSCC_RC_SUCCESS) { TRACE_2("GLND cb destroy failed"); rc= NCSCC_RC_FAILURE; } end: TRACE_LEAVE2("%s return value %u", (rc == NCSCC_RC_SUCCESS)?"SUCCESS":"FAILURE", rc); return rc; }
/**************************************************************************** Name : ava_hdl_del Description : This routine deletes the handle database. Arguments : cb - ptr to the AvA control block Return Values : None Notes : None ******************************************************************************/ void ava_hdl_del(AVA_CB *cb) { AVA_HDL_DB *hdl_db = &cb->hdl_db; AVA_HDL_REC *hdl_rec = 0; TRACE_ENTER(); /* scan the entire handle db & delete each record */ while ((hdl_rec = (AVA_HDL_REC *) ncs_patricia_tree_getnext(&hdl_db->hdl_db_anchor, 0))) { ava_hdl_rec_del(cb, hdl_db, &hdl_rec); } /* there shouldn't be any record left */ osafassert(!hdl_db->num); /* destroy the hdl db tree */ ncs_patricia_tree_destroy(&hdl_db->hdl_db_anchor); TRACE_LEAVE(); return; }
Bool MapUserMemToGPU(GALINFOPTR galInfo, MemMapInfoPtr mmInfo) { TRACE_ENTER(); gceSTATUS status = gcvSTATUS_OK; gctPOINTER logical = (gctPOINTER) mmInfo->mUserAddr; gctSIZE_T size = (gctSIZE_T) (mmInfo->mSize); gctPOINTER mappingInfo = NULL; gctUINT32 physical = 0; VIVGPUPtr gpuctx = (VIVGPUPtr) (galInfo->mGpu); status = gcoOS_MapUserMemory(gpuctx->mDriver->mOs, logical, size, &mappingInfo, &physical); if (status < 0) { TRACE_ERROR("Mapping Failed\n"); gcoOS_UnmapUserMemory(gpuctx->mDriver->mOs, logical, size, mappingInfo, physical); mmInfo->physical = 0; mmInfo->mapping = NULL; TRACE_EXIT(FALSE); } mmInfo->physical = physical; mmInfo->mapping = mappingInfo; TRACE_EXIT(TRUE); }