void EsifEventMgr_Exit(void) { UInt8 i; EsifLinkListPtr listPtr = NULL; ESIF_TRACE_ENTRY_INFO(); /* Remove all listeners */ esif_ccb_write_lock(&g_EsifEventMgr.listLock); for (i = 0; i < NUM_EVENT_LISTS; i++) { listPtr = g_EsifEventMgr.observerLists[i]; esif_link_list_free_data_and_destroy(listPtr, EsifEventMgr_LLEntryDestroyCallback); g_EsifEventMgr.observerLists[i] = NULL; } esif_ccb_write_unlock(&g_EsifEventMgr.listLock); /* Destroy the event thread */ /* Event thread should already be destroyed in the disable func. Destroy the queue */ esif_queue_destroy(g_EsifEventMgr.eventQueuePtr, EsifEventMgr_QueueDestroyCallback); g_EsifEventMgr.eventQueuePtr = NULL; /* Destroy the garbage list */ esif_ccb_write_lock(&g_EsifEventMgr.listLock); esif_link_list_free_data_and_destroy(g_EsifEventMgr.garbageList, EsifEventMgr_LLEntryDestroyCallback); g_EsifEventMgr.garbageList = NULL; esif_ccb_write_unlock(&g_EsifEventMgr.listLock); esif_ccb_lock_uninit(&g_EsifEventMgr.listLock); ESIF_TRACE_EXIT_INFO(); }
void EsifAppMgrExit() { u8 i = 0; EsifAppPtr a_app_ptr = NULL; ESIF_TRACE_ENTRY_INFO(); EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_SUSPEND, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL); EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_RESUME, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL); EsifAppExit(); ESIF_TRACE_DEBUG("Exit Action Manager (APPMGR)"); esif_ccb_read_lock(&g_appMgr.fLock); for (i = 0; i < ESIF_MAX_APPS; i++) { a_app_ptr = &g_appMgr.fEntries[i]; // Attempt to gracefully shutdown App before forcing library unload if (a_app_ptr->fLibNamePtr != NULL) { EsifAppStop(a_app_ptr); } if (a_app_ptr->fLibNamePtr != NULL) { esif_ccb_library_unload(a_app_ptr->fLibHandle); esif_ccb_free(a_app_ptr->fLibNamePtr); esif_ccb_memset(a_app_ptr, 0, sizeof(*a_app_ptr)); } } esif_ccb_read_unlock(&g_appMgr.fLock); esif_ccb_lock_uninit(&g_appMgr.fLock); ESIF_TRACE_EXIT_INFO(); }
void EsifActMgrExit() { u8 i = 0; EsifActPtr a_act_ptr = NULL; ESIF_TRACE_ENTRY_INFO(); /* Call before destroying action manager */ EsifActExit(); if (NULL != g_actMgr.fActTypes) { esif_link_list_destroy(g_actMgr.fActTypes); g_actMgr.fActTypes = NULL; //set to null so that it will be caught if mid-execution } esif_ccb_read_lock(&g_actMgr.fLock); for (i = 0; i < ESIF_MAX_ACTIONS; i++) { a_act_ptr = &g_actMgr.fEnrtries[i]; esif_ccb_free(a_act_ptr->fLibNamePtr); esif_ccb_library_unload(a_act_ptr->fLibHandle); esif_ccb_memset(a_act_ptr, 0, sizeof(*a_act_ptr)); } esif_ccb_read_unlock(&g_actMgr.fLock); esif_ccb_lock_uninit(&g_actMgr.fLock); ESIF_TRACE_EXIT_INFO(); }
void EsifAct_DestroyAction( EsifActPtr self ) { if (NULL == self) { goto exit; } self->markedForDelete = ESIF_TRUE; EsifAct_PutRef(self); ESIF_TRACE_INFO("Destroy action %d : waiting for delete event...\n", self->type); esif_ccb_event_wait(&self->deleteEvent); EsifAct_UnregisterEvents(self); EsifAct_CallIfaceDestroy(self); esif_ccb_event_uninit(&self->deleteEvent); esif_ccb_lock_uninit(&self->objLock); esif_ccb_free(self); exit: return; }
/* Exit */ void esif_event_exit(void) { esif_queue_destroy(g_event_queue); esif_ccb_lock_uninit(&g_event_lock); ESIF_TRACE_DYN_INIT("%s: Exit Event\n", ESIF_FUNC); }
void EsifDspMgrExit(void) { ESIF_TRACE_ENTRY_INFO(); esif_dsp_table_destroy(); esif_ccb_lock_uninit(&g_dm.lock); ESIF_TRACE_EXIT_INFO(); }
// destructor static void DataVault_dtor(DataVaultPtr self) { if (self) { DataCache_Destroy(self->cache); IOStream_Destroy(self->stream); esif_ccb_lock_uninit(&self->lock); WIPEPTR(self); } }
void DataBank_Destroy (DataBankPtr self) { UInt32 idx; for (idx = 0; idx < self->size; idx++) DataVault_dtor(&self->elements[idx]); self->size = 0; esif_ccb_lock_uninit(&self->lock); esif_ccb_free(self); }
/* Exit manager */ void EsifUppMgrExit(void) { /* Clean up resources */ EsifUpManagerDestroyParticipants(); /* Uninitialize Lock */ esif_ccb_lock_uninit(&g_uppMgr.fLock); ESIF_TRACE_INFO("%s: Exit Upper Participant Manager (PM)", ESIF_FUNC); }
void EsifLogMgrExit(void) { int j; ESIF_TRACE_ENTRY_INFO(); for (j=0; j < MAX_ESIFLOG; j++) { if (g_EsifLogFile[j].handle != NULL) { esif_ccb_fclose(g_EsifLogFile[j].handle); } esif_ccb_free(g_EsifLogFile[j].name); esif_ccb_free(g_EsifLogFile[j].filename); esif_ccb_lock_uninit(&g_EsifLogFile[j].lock); } esif_ccb_memset(g_EsifLogFile, 0, sizeof(g_EsifLogFile)); ESIF_TRACE_EXIT_INFO(); }
void esif_memtrace_exit() { struct memalloc_s *mem = NULL; char tracefile[MAX_PATH] = {0}; FILE *tracelog = NULL; esif_build_path(tracefile, sizeof(tracefile), ESIF_PATHTYPE_LOG, "memtrace.txt", NULL); esif_pathlist_exit(); esif_ccb_write_lock(&g_memtrace.lock); mem = g_memtrace.allocated; g_memtrace.allocated = NULL; esif_ccb_write_unlock(&g_memtrace.lock); CMD_OUT("MemTrace: Allocs=" ATOMIC_FMT " Frees=" ATOMIC_FMT "\n", atomic_read(&g_memtrace.allocs), atomic_read(&g_memtrace.frees)); if (!mem) { goto exit; } CMD_OUT("\n*** MEMORY LEAKS DETECTED ***\nFor details see %s\n", tracefile); esif_ccb_fopen(&tracelog, tracefile, "a"); if (tracelog) { time_t now = time(NULL); char timestamp[MAX_CTIME_LEN] = {0}; esif_ccb_ctime(timestamp, sizeof(timestamp), &now); fprintf(tracelog, "\n*** %.24s: MEMORY LEAKS DETECTED (%s) ***\n", timestamp, ESIF_UF_VERSION); } while (mem) { struct memalloc_s *node = mem; if (tracelog) { fprintf(tracelog, "[%s @%s:%d]: (%lld bytes) %p\n", mem->func, mem->file, mem->line, (long long)mem->size, mem->mem_ptr); } mem = mem->next; native_free(node->mem_ptr); native_free(node); } if (tracelog) { esif_ccb_fclose(tracelog); } exit: esif_ccb_lock_uninit(&g_memtrace.lock); }
void EsifCnjMgrExit() { u8 i = 0; EsifCnjPtr a_conjure_ptr = NULL; EsifCnjExit(); ESIF_TRACE_DEBUG("%s: Exit Action Manager (CNJMGR)", ESIF_FUNC); esif_ccb_read_lock(&g_cnjMgr.fLock); for (i = 0; i < ESIF_MAX_CONJURES; i++) { a_conjure_ptr = &g_cnjMgr.fEnrtries[i]; esif_ccb_free(a_conjure_ptr->fLibNamePtr); esif_ccb_library_unload(a_conjure_ptr->fLibHandle); esif_ccb_memset(a_conjure_ptr, 0, sizeof(*a_conjure_ptr)); } esif_ccb_read_unlock(&g_cnjMgr.fLock); esif_ccb_lock_uninit(&g_cnjMgr.fLock); ESIF_TRACE_EXIT_INFO(); }
void EsifActMgrExit() { ESIF_TRACE_ENTRY_INFO(); /* Call before destroying action manager */ EsifActMgr_UninitActions(); esif_ccb_write_lock(&g_actMgr.mgrLock); esif_link_list_free_data_and_destroy(g_actMgr.actions, EsifActMgr_LLEntryDestroyCallback); g_actMgr.actions = NULL; esif_link_list_free_data_and_destroy(g_actMgr.possibleActions, EsifActMgr_LLEntryDestroyCallback); g_actMgr.possibleActions = NULL; esif_ccb_write_unlock(&g_actMgr.mgrLock); esif_ccb_lock_uninit(&g_actMgr.mgrLock); ESIF_TRACE_EXIT_INFO(); }
/* * This functions is expected to be called when the system is in a "known" state * where no attempts to create any timers are in flight as this function * destroys the lock controlling synchronization */ void esif_ccb_tmrm_exit(void) { esif_ccb_timer_t cur_timer; if (!g_tmrm.enabled) goto exit; /* Mark to make sure no further timers are created */ g_tmrm.marked_for_delete = ESIF_TRUE; /* Kill all existing timers and wait for destruction */ while(esif_ccb_tmrm_get_first_timer(&cur_timer) == ESIF_OK) { esif_ccb_timer_kill_w_wait(&cur_timer); } g_tmrm.enabled = ESIF_FALSE; esif_ccb_lock_uninit(&g_tmrm.mgr_lock); g_tmrm.marked_for_delete = ESIF_FALSE; exit: return; }
/* Exit */ void esif_action_systemio_exit(void) { ESIF_TRACE_DYN_INIT("Exit SYSTEMIO Action\n"); esif_ccb_lock_uninit(&g_esif_action_systemio_lock); }
/* Exit */ void esif_action_mmio_exit(void) { esif_ccb_lock_uninit(&g_esif_action_mmio_lock); ESIF_TRACE_DYN_INIT("Exit MMIO Action\n"); }