예제 #1
0
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();
}
예제 #2
0
static eEsifError EsifEventMgr_DumpGarbage()
{
	eEsifError rc = ESIF_OK;
	EsifLinkListPtr listPtr = g_EsifEventMgr.garbageList;
	EsifLinkListNodePtr nodePtr = NULL;
	EventMgrEntryPtr entryPtr = NULL;

	if (NULL == listPtr) {
		rc = ESIF_E_UNSPECIFIED;
		goto exit;
	}

	esif_ccb_write_lock(&g_EsifEventMgr.listLock);
	nodePtr = listPtr->head_ptr;
	while(nodePtr) {
		entryPtr = nodePtr->data_ptr;

		/* remove the node first so that it isn't considered active while we disable events */
		esif_link_list_node_remove(listPtr, nodePtr); 
		esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
		EsifEventMgr_DisableEvent(entryPtr);
		esif_ccb_free(entryPtr);
		esif_ccb_write_lock(&g_EsifEventMgr.listLock);

		nodePtr = listPtr->head_ptr;
	}
	esif_ccb_write_unlock(&g_EsifEventMgr.listLock);

exit:
	return rc;
}
예제 #3
0
파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf
/* Unloads a pluggable UPE action by library name */
eEsifError EsifActMgr_StopUpe(EsifString upeName)
{
	eEsifError rc = ESIF_OK;
	EsifActMgrEntryPtr entryPtr = NULL;
	struct esif_link_list_node *nodePtr = NULL;

	if (NULL == upeName) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	esif_ccb_write_lock(&g_actMgr.mgrLock);

	entryPtr = EsifActMgr_GetActEntryByLibname_Locked(upeName);
	if (NULL == entryPtr) {
		esif_ccb_write_unlock(&g_actMgr.mgrLock);
		rc = ESIF_E_ACTION_NOT_IMPLEMENTED;
		ESIF_TRACE_WARN("Failed To Find Action: %s\n", upeName);
		goto exit;
	}

	nodePtr = EsifActMgr_GetNodeFromEntry_Locked(entryPtr);
	esif_link_list_node_remove(g_actMgr.actions, nodePtr);
	g_actMgr.numActions--;

	esif_ccb_write_unlock(&g_actMgr.mgrLock);

	EsifActMgr_DestroyEntry(entryPtr);

	ESIF_TRACE_DEBUG("Stopped Action: %s\n", upeName);
exit:
	return rc;
}
예제 #4
0
// backwards compatibility
eEsifError EsifConfigSet(
	EsifDataPtr nameSpace,
	EsifDataPtr path,
	esif_flags_t flags,
	EsifDataPtr value
	)
{
	eEsifError rc = ESIF_OK;

	// Get the NameSpace or create it if it does not exist
	DataVaultPtr DB = DataBank_GetNameSpace(g_DataBankMgr, (StringPtr)(nameSpace->buf_ptr));
	if (!DB) {
		struct esif_ccb_file dv_file = {0};
		DB = DataBank_OpenNameSpace(g_DataBankMgr, (StringPtr)nameSpace->buf_ptr);
		if (!DB) {
			return ESIF_E_NOT_FOUND;
		}

		esif_build_path(dv_file.filename, sizeof(dv_file.filename), ESIF_PATHTYPE_DV, DB->name, ESIFDV_FILEEXT);
		IOStream_SetFile(DB->stream, dv_file.filename, "rb");
		rc = DataVault_ReadVault(DB);
		if (rc == ESIF_E_NOT_FOUND) {
			rc = ESIF_OK;
		}
	}
	if (rc == ESIF_OK) {
		esif_ccb_write_lock(&DB->lock);
		rc = DataVault_SetValue(DB, path, value, flags);
		esif_ccb_write_unlock(&DB->lock);
	}
	return rc;
}
예제 #5
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
static enum esif_rc esif_ccb_tmrm_get_next_handle(
	esif_ccb_timer_handle_t *handle_ptr
	)
{
	enum esif_rc rc = ESIF_OK;
	struct esif_link_list_node *node_ptr = NULL;
	esif_ccb_timer_t timer = {0};
	u32 try_count = 0;
	/*
	 * Our use case is that we will have a small number of timers ever
	 * active; however the handle counter may eventually roll over to a
	 * counter that has been there the whole time.  So, we make sure that
	 * the handle doesn't overlap. We also protect against an infinite loop.
	 */
	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	do {
		try_count++;
		timer.timer_handle = (esif_ccb_timer_handle_t)(size_t)++g_next_timer_handle;
		node_ptr = esif_ccb_tmrm_find_timer_node_wlock(timer.timer_handle);
	} while ((node_ptr != NULL) && (try_count < ESIF_CNT_HNDL_RETRIES_MAX));

	esif_ccb_write_unlock(&g_tmrm.mgr_lock);

	if(node_ptr != NULL) {
		rc = ESIF_E_UNSPECIFIED;
		goto exit;
	}

	*handle_ptr = timer.timer_handle;
exit:
	return rc;
}
예제 #6
0
파일: esif_uf_pm.c 프로젝트: naitaku/dptf
/* This should only be called when shutting down */
static eEsifError EsifUpManagerDestroyParticipants(void)
{
	eEsifError rc = ESIF_OK;
	EsifUpManagerEntryPtr entry_ptr = NULL;
	UInt8 i = 0;

	esif_ccb_write_lock(&g_uppMgr.fLock);

	for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {
		entry_ptr = &g_uppMgr.fEntries[i];

		if (entry_ptr->fState > ESIF_PM_PARTICIPANT_REMOVED) {
			g_uppMgr.fEntryCount--;
		}
		entry_ptr->fState = ESIF_PM_PARTICIPANT_STATE_AVAILABLE;

		if (NULL != entry_ptr->fUpPtr) {
			esif_ccb_free(entry_ptr->fUpPtr);
			entry_ptr->fUpPtr = NULL;
		}
	}

	esif_ccb_write_unlock(&g_uppMgr.fLock);

	ESIF_TRACE_INFO("The participants are destroyed in ESIF UF participant manager\n");
	return rc;
}
예제 #7
0
void DataBank_CloseNameSpace (
	DataBankPtr self,
	esif_string nameSpace
	)
{
	UInt32 ns;

	esif_ccb_write_lock(&self->lock);

	// Find Existing NameSpace
	for (ns = 0; ns < self->size; ns++) {
		if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
			DataVault_dtor(&self->elements[ns]);

			// Move Array Items down one and wipe the final item
			for ( ; ns + 1 < self->size; ns++)
				esif_ccb_memcpy(&self->elements[ns], &self->elements[ns + 1], sizeof(self->elements[ns]));
			if (ns < ESIF_MAX_NAME_SPACES) {
				WIPEPTR(&self->elements[ns]);
			}
			self->size--;
		}
	}
	esif_ccb_write_unlock(&self->lock);
}
예제 #8
0
파일: esif_uf.c 프로젝트: hoangt/dptf
int EsifLogFile_Open(EsifLogType type, const char *filename, int append)
{
	int rc=0;
	char fullpath[MAX_PATH]={0};
	char mode[3] = {(append ? 'a' : 'w'), 0, 0};

	esif_ccb_write_lock(&g_EsifLogFile[type].lock);
	if (g_EsifLogFile[type].handle != NULL)
		esif_ccb_fclose(g_EsifLogFile[type].handle);

	EsifLogFile_GetFullPath(fullpath, sizeof(fullpath), filename);
#ifdef ESIF_ATTR_OS_WINDOWS
	mode[1] = 'c';
	g_EsifLogFile[type].handle = _fsopen(fullpath, mode, _SH_DENYWR);
	if (g_EsifLogFile[type].handle == NULL)
		rc = errno;
#else
	rc = esif_ccb_fopen(&g_EsifLogFile[type].handle, fullpath, mode);
#endif
	if (rc == 0) {
		esif_ccb_free(g_EsifLogFile[type].filename);
		g_EsifLogFile[type].filename = esif_ccb_strdup((char *)fullpath);
	}
	esif_ccb_write_unlock(&g_EsifLogFile[type].lock);
	return rc;
}
예제 #9
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
static enum esif_rc esif_ccb_tmrm_get_first_timer(
	esif_ccb_timer_t *timer_ptr
	)
{
	enum esif_rc rc = ESIF_E_UNSPECIFIED;
	struct esif_link_list_node *node_ptr = NULL;
	struct esif_tmrm_item *tmrm_item_ptr = NULL;

	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	if (NULL == g_tmrm.timer_list_ptr)
		goto exit;

	node_ptr = g_tmrm.timer_list_ptr->head_ptr;
	if (NULL == node_ptr)
		goto exit;

	tmrm_item_ptr = (struct esif_tmrm_item *)node_ptr->data_ptr;
	if (NULL == tmrm_item_ptr) /* Should never happen */
		goto exit;

	timer_ptr->timer_handle = tmrm_item_ptr->timer_handle;
	rc = ESIF_OK;
exit:
	esif_ccb_write_unlock(&g_tmrm.mgr_lock);
	return rc;
}
예제 #10
0
파일: esif_uf.c 프로젝트: hoangt/dptf
void esif_memtrace_free(void *mem_ptr)
{
	struct memalloc_s *mem   = NULL;
	struct memalloc_s **last = NULL;

	esif_ccb_write_lock(&g_memtrace.lock);
	mem  = g_memtrace.allocated;
	last = &g_memtrace.allocated;

	while (mem) {
		if (mem_ptr == mem->mem_ptr) {
			*last = mem->next;
			native_free(mem);
			goto exit;
		}
		last = &mem->next;
		mem  = mem->next;
	}
exit:
	esif_ccb_write_unlock(&g_memtrace.lock);
	if (mem_ptr) {
		native_free(mem_ptr);
		atomic_inc(&g_memtrace.frees);
	}
}
예제 #11
0
DataVaultPtr DataBank_OpenNameSpace (
	DataBankPtr self,
	esif_string nameSpace
	)
{
	DataVaultPtr DB = NULL;
	UInt32 ns;

	// Exit if NameSpace already exists
	// TODO: Change this to a linked list or array of pointers so each DataVaultPtr is static
	esif_ccb_read_lock(&self->lock);
	for (ns = 0; ns < self->size; ns++) {
		if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
			DB = &self->elements[ns];
			break;
		}
	}
	esif_ccb_read_unlock(&self->lock);
	if (DB != NULL || ns >= ESIF_MAX_NAME_SPACES) {
		return DB;
	}

	// Not Found. Create NameSpace
	esif_ccb_write_lock(&self->lock);
	DB = &self->elements[self->size++];
	DataVault_ctor(DB);
	esif_ccb_strcpy(DB->name, nameSpace, ESIF_NAME_LEN);
	esif_ccb_strlwr(DB->name, sizeof(DB->name));
	esif_ccb_write_unlock(&self->lock);
	return DB;
}
예제 #12
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
void esif_ccb_tmrm_callback(
	esif_ccb_timer_handle_t cb_handle
	)
{
	struct esif_link_list_node *node_ptr = NULL;
	struct esif_tmrm_item *tmrm_item_ptr = NULL;
	struct esif_timer_obj *timer_obj_ptr = NULL;

	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	node_ptr = esif_ccb_tmrm_find_timer_node_by_cb_wlock(cb_handle);

	if ((NULL == node_ptr) || (NULL == node_ptr->data_ptr)) {
		goto lock_exit;	
	}

	tmrm_item_ptr = (struct esif_tmrm_item *)node_ptr->data_ptr;

	/* Clear the CB handle to lower probability of hitting same handle */
	tmrm_item_ptr->timer_cb_handle = 0;
	tmrm_item_ptr->is_in_cb = ESIF_TRUE;

	esif_ccb_write_unlock(&g_tmrm.mgr_lock);

	/* Call the timer callback function */
	timer_obj_ptr = tmrm_item_ptr->timer_obj_ptr;
	esif_ccb_timer_obj_call_cb(timer_obj_ptr);

	/*
	 * Upon return, perform post processing
	 * Note:  The item and node pointers will still be valid as the node
	 * will not be removed while in the callback function
	 */
	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	tmrm_item_ptr->is_in_cb = ESIF_FALSE;

	if (tmrm_item_ptr->marked_for_delete) {
		esif_ccb_tmrm_destroy_timer_node_wlock(node_ptr);
		goto lock_exit;
	}

	 esif_ccb_timer_obj_set_pending_timeout(timer_obj_ptr);
lock_exit:
	esif_ccb_write_unlock(&g_tmrm.mgr_lock);
	return;
}
예제 #13
0
파일: esif_uf.c 프로젝트: hoangt/dptf
int EsifConsole_WriteLogFile(const char *format, va_list args)
{
	int rc=0;
	esif_ccb_write_lock(&g_EsifLogFile[ESIF_LOG_SHELL].lock);
	rc = esif_ccb_vfprintf(g_EsifLogFile[ESIF_LOG_SHELL].handle, format, args);
	esif_ccb_write_unlock(&g_EsifLogFile[ESIF_LOG_SHELL].lock);
	return rc;
}
예제 #14
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
/*
 * Sets a timer timeout in ms
 * Notes:  0 is an invalid timeout
 * The code will cancel any current timeout if possible before setting the new
 * timeout. If in the callback, the timeout will not be set until the function
 * exits.
 */
enum esif_rc esif_ccb_timer_set_msec(
	esif_ccb_timer_t *timer_ptr,
	const esif_ccb_time_t timeout	/* Timeout in msec */
	)
{
	enum esif_rc rc = ESIF_E_UNSPECIFIED;
	struct esif_link_list_node *node_ptr = NULL;
	struct esif_tmrm_item *tmrm_item_ptr = NULL;
	struct esif_timer_obj *timer_obj_ptr = NULL;
	esif_ccb_timer_handle_t timer_cb_handle = {0};

	if (NULL == timer_ptr) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	if (0 == timeout) {
		rc = ESIF_E_REQUEST_DATA_OUT_OF_BOUNDS;
		goto exit;
	}

	/* Order issue check */
	if (!g_tmrm.enabled) 
		goto exit;

	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	node_ptr = esif_ccb_tmrm_find_timer_node_wlock(timer_ptr->timer_handle);
	if ((NULL == node_ptr) || (NULL == node_ptr->data_ptr)) {	
		rc = ESIF_E_INVALID_HANDLE;
		goto lock_exit;
	}

	tmrm_item_ptr = (struct esif_tmrm_item *)node_ptr->data_ptr;

	if (tmrm_item_ptr->marked_for_delete) {
		rc = ESIF_E_INVALID_HANDLE;
		goto lock_exit;
	}

	esif_ccb_tmrm_get_next_cb_handle_wlock(&timer_cb_handle);
	tmrm_item_ptr->timer_cb_handle = timer_cb_handle;

	timer_obj_ptr = tmrm_item_ptr->timer_obj_ptr;
	esif_ccb_timer_obj_save_pending_timeout(timer_obj_ptr,
		timeout,
		timer_cb_handle);

	if (!tmrm_item_ptr->is_in_cb) {
		rc = esif_ccb_timer_obj_set_pending_timeout(timer_obj_ptr);
	} else {
		rc = ESIF_OK;
	}
lock_exit:
	esif_ccb_write_unlock(&g_tmrm.mgr_lock);
exit:
	return rc;
}
예제 #15
0
static void EsifEventMgr_LLEntryDestroyCallback(
	void *dataPtr
	)
{
	esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
	EsifEventMgr_DisableEvent((EventMgrEntryPtr)dataPtr);
	esif_ccb_free(dataPtr);
	esif_ccb_write_lock(&g_EsifEventMgr.listLock);
}
예제 #16
0
파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf
static void EsifActMgr_LLEntryDestroyCallback(
	void *dataPtr
	)
{
	esif_ccb_write_unlock(&g_actMgr.mgrLock);

	EsifActMgr_DestroyEntry((EsifActMgrEntryPtr)dataPtr);

	esif_ccb_write_lock(&g_actMgr.mgrLock);
}
예제 #17
0
파일: esif_uf.c 프로젝트: hoangt/dptf
int EsifLogFile_Close(EsifLogType type)
{
	int rc = EOF;

	esif_ccb_write_lock(&g_EsifLogFile[type].lock);
	if (g_EsifLogFile[type].handle != NULL)
		rc = esif_ccb_fclose(g_EsifLogFile[type].handle);
	g_EsifLogFile[type].handle = NULL;
	esif_ccb_write_unlock(&g_EsifLogFile[type].lock);
	return rc;
}
예제 #18
0
파일: esif_uf.c 프로젝트: hoangt/dptf
int EsifLogFile_WriteArgs(EsifLogType type, const char *fmt, va_list args)
{
	int rc = 0;
	
	esif_ccb_write_lock(&g_EsifLogFile[type].lock);
	if (g_EsifLogFile[type].handle != NULL) {
		rc = esif_ccb_vfprintf(g_EsifLogFile[type].handle, fmt, args);
		fflush(g_EsifLogFile[type].handle);
	}
	esif_ccb_write_unlock(&g_EsifLogFile[type].lock);
	return rc;
}
예제 #19
0
static eEsifError EsifEventMgr_ReleaseEntry(
	EsifFpcEventPtr fpcEventPtr,
	UInt8 participantId,
	UInt16 domainId,
	EVENT_OBSERVER_CALLBACK eventCallback,
	void *contextPtr
	)
{
	eEsifError rc = ESIF_OK;
	EsifLinkListPtr listPtr = NULL;
	EsifLinkListNodePtr nodePtr = NULL;
	EventMgrEntryPtr curEntryPtr = NULL;
	atomic_t refCount = -1;

	ESIF_ASSERT(eventCallback != NULL);
	ESIF_ASSERT(fpcEventPtr != NULL);


	esif_ccb_write_lock(&g_EsifEventMgr.listLock);

	listPtr = g_EsifEventMgr.observerLists[fpcEventPtr->esif_event % NUM_EVENT_LISTS];
	if(NULL == listPtr) {
		rc = ESIF_E_UNSPECIFIED;
		goto exit;
	}

	/* Find the matching entry */
	nodePtr = listPtr->head_ptr;
	while (nodePtr != NULL) {
		curEntryPtr = (EventMgrEntryPtr) nodePtr->data_ptr;
		if ((curEntryPtr->fpcEvent.esif_event == fpcEventPtr->esif_event) &&
			(curEntryPtr->participantId == participantId) &&
			(curEntryPtr->domainId == domainId) &&
			(curEntryPtr->contextPtr == contextPtr) &&
			(curEntryPtr->callback == eventCallback)){
			break;
		}
		nodePtr = nodePtr->next_ptr;
	}

	if (nodePtr != NULL) {
		refCount = atomic_dec(&curEntryPtr->refCount);
		if (refCount <= 0) {
			EsifEventMgr_MoveEntryToGarbage(curEntryPtr);
			esif_link_list_node_remove(listPtr, nodePtr);
		}
		goto exit;
	}
exit:
	esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
	EsifEventMgr_DumpGarbage();
	return rc;
}
예제 #20
0
파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf
EsifActPtr EsifActMgr_GetAction(
	enum esif_action_type type,
	const UInt8 instance
	)
{
	eEsifError rc = ESIF_OK;
	EsifActPtr actPtr = NULL;
	EsifActMgrEntryPtr entryPtr = NULL;
	struct esif_link_list_node *nodePtr = NULL;

	esif_ccb_write_lock(&g_actMgr.mgrLock);

	/* First see if the action is available, else see if it can be loaded */
	entryPtr = EsifActMgr_GetActionEntry_Locked(type);
	if (NULL == entryPtr) {
		esif_ccb_write_unlock(&g_actMgr.mgrLock);
		goto exit;
	}
	if (entryPtr->loadDelayed != ESIF_TRUE) {
		actPtr = entryPtr->actPtr;
		rc = EsifAct_GetRef(actPtr);
		if (rc != ESIF_OK) {
			actPtr = NULL;
		}
		esif_ccb_write_unlock(&g_actMgr.mgrLock);
	} else {
		nodePtr = EsifActMgr_GetNodeFromEntry_Locked(entryPtr);
		esif_link_list_node_remove(g_actMgr.actions, nodePtr);
		g_actMgr.numActions--;
		esif_ccb_write_unlock(&g_actMgr.mgrLock);

		EsifActMgr_DestroyEntry(entryPtr);
		EsifActMgr_LoadDelayLoadAction(type, instance);
		actPtr = EsifActMgr_GetAction(type, instance);
	}
exit:
	return actPtr;
}
예제 #21
0
파일: esif_uf_action.c 프로젝트: 01org/dptf
/*
 * Takes an additional reference on an action object.  (The function is
 * called for you by the Action Manager when one of the functions are
 * called which returns a pointer to an action.)  After using the
 * action, EsifAct_PutRef must be called to release the reference.
 */
eEsifError EsifAct_GetRef(EsifActPtr self)
{
	eEsifError rc = ESIF_OK;

	if (self == NULL) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	esif_ccb_write_lock(&self->objLock);

	if (self->markedForDelete == ESIF_TRUE) {
		esif_ccb_write_unlock(&self->objLock);
		ESIF_TRACE_DEBUG("Action marked for delete\n");
		rc = ESIF_E_UNSPECIFIED;
		goto exit;
	}

	self->refCount++;
	esif_ccb_write_unlock(&self->objLock);
exit:
	return rc;
}
예제 #22
0
파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf
eEsifError EsifActMgr_UnregisterAction(
	EsifActIfacePtr actIfacePtr
	)
{
	eEsifError rc = ESIF_OK;
	enum esif_action_type actType = 0;
	struct esif_link_list_node *nodePtr = NULL;
	EsifActMgrEntryPtr entryPtr = NULL;

	if (NULL == actIfacePtr) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	rc = EsifActIface_GetType(actIfacePtr, &actType);
	if (rc != ESIF_OK) {
		goto exit;
	}
	
	esif_ccb_write_lock(&g_actMgr.mgrLock);

	entryPtr = EsifActMgr_GetActionEntry_Locked(actType);
	if (NULL == entryPtr) {
		esif_ccb_write_unlock(&g_actMgr.mgrLock);
		rc = ESIF_E_NOT_FOUND;
		goto exit;
	}

	nodePtr = EsifActMgr_GetNodeFromEntry_Locked(entryPtr);
	esif_link_list_node_remove(g_actMgr.actions, nodePtr);
	g_actMgr.numActions++;
	esif_ccb_write_unlock(&g_actMgr.mgrLock);

	EsifActMgr_DestroyEntry(entryPtr);
exit:
	return rc;
}
예제 #23
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
/* Every init should have a matching kill */
enum esif_rc esif_ccb_timer_init(
	esif_ccb_timer_t *timer_ptr,
	esif_ccb_timer_cb function_ptr,	/* Callback when timer fires */
	void *context_ptr		/* Callback context if any */
	)
{
	enum esif_rc rc = ESIF_OK;
	struct esif_tmrm_item *tmrm_item_ptr = NULL;

	if ((NULL == timer_ptr) || (NULL == function_ptr)) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	rc = esif_ccb_tmrm_is_ready();
	if (rc != ESIF_OK)
		goto exit;

	rc = esif_ccb_tmrm_create_tmrm_item(function_ptr,
		context_ptr,
		&tmrm_item_ptr);
	if (rc != ESIF_OK)
		goto exit;

	/* Place the handle into the timer being initialized*/
	timer_ptr->timer_handle = tmrm_item_ptr->timer_handle;

	/*
	 * We create the manager list dynamically so that we don't have to call
	 * init/exit functions and can destroy the linked list
	 */
	esif_ccb_write_lock(&g_tmrm.mgr_lock);
	if (NULL == g_tmrm.timer_list_ptr) {

		g_tmrm.timer_list_ptr = esif_link_list_create();
		if(NULL == g_tmrm.timer_list_ptr) {
			rc = ESIF_E_NO_MEMORY;
			goto lock_exit;
		}
	}
	rc = esif_link_list_add_at_back(g_tmrm.timer_list_ptr, tmrm_item_ptr);
lock_exit:
	esif_ccb_write_unlock(&g_tmrm.mgr_lock);
exit:
	if (rc != ESIF_OK)
		esif_ccb_tmrm_destroy_tmrm_item(tmrm_item_ptr);

	return rc;
}
예제 #24
0
파일: esif_uf_pm.c 프로젝트: naitaku/dptf
/* Unregister Upper Participant Instance */
eEsifError EsifUpManagerUnregisterParticipant(
	const eEsifParticipantOrigin origin,
	const void *participantHandle
	)
{
	eEsifError rc    = ESIF_OK;
	EsifUpManagerEntryPtr entry_ptr = NULL;
	EsifUpPtr up_ptr = NULL;
	UInt8 instance;

	UNREFERENCED_PARAMETER(origin);

	/* Validate parameters */
	if (NULL == participantHandle) {
		ESIF_TRACE_ERROR("The participant handle pointer is NULL\n");
		ESIF_ASSERT(participantHandle != NULL);
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	instance = *(UInt8 *)participantHandle;

	if (instance >= MAX_PARTICIPANT_ENTRY) {
		ESIF_TRACE_ERROR("Instance id %d is out of range\n", instance);
		rc = ESIF_E_PARAMETER_IS_OUT_OF_BOUNDS;
		goto exit;
	}

	esif_ccb_write_lock(&g_uppMgr.fLock);

	entry_ptr = &g_uppMgr.fEntries[instance];
	if (NULL != entry_ptr) {
		up_ptr = entry_ptr->fUpPtr;
		if (NULL != up_ptr) {
			entry_ptr->fState = ESIF_PM_PARTICIPANT_REMOVED;
			g_uppMgr.fEntryCount--;
		}
	}
	esif_ccb_write_unlock(&g_uppMgr.fLock);

	if (NULL != up_ptr) {
		rc = EsifAppMgrDestroyParticipantInAllApps(up_ptr);
	}

	ESIF_TRACE_INFO("Unregister participant, instant id = %d\n", instance);
exit:
	return rc;
}
예제 #25
0
파일: esif_ccb_timer.c 프로젝트: 01org/dptf
static enum esif_rc esif_ccb_timer_kill_w_event(
	esif_ccb_timer_t *timer_ptr,
	esif_ccb_event_t *event_ptr
	)
{
	enum esif_rc rc = ESIF_E_UNSPECIFIED;
	struct esif_tmrm_item *tmrm_item_ptr = NULL;
	struct esif_link_list_node *node_ptr = NULL;

	if (NULL == timer_ptr) {
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	if (!g_tmrm.enabled)
		goto exit;

	esif_ccb_write_lock(&g_tmrm.mgr_lock);

	node_ptr = esif_ccb_tmrm_find_timer_node_wlock(timer_ptr->timer_handle);
	if ((NULL == node_ptr) || (NULL == node_ptr->data_ptr)) {
		rc = ESIF_E_INVALID_HANDLE;
		goto lock_exit;
	}

	tmrm_item_ptr = (struct esif_tmrm_item *)node_ptr->data_ptr;

	/* Mark for delete in case it is in the callback */
	tmrm_item_ptr->marked_for_delete = ESIF_TRUE;

	esif_ccb_tmrm_add_destroy_event(tmrm_item_ptr, event_ptr);

	/* If not in callback, the timer can be destroyed now */
	if (!tmrm_item_ptr->is_in_cb) {
		esif_ccb_tmrm_destroy_timer_node_wlock(node_ptr);
	}
	rc = ESIF_OK;
lock_exit:
	esif_ccb_write_unlock(&g_tmrm.mgr_lock);
exit:
	if ((rc != ESIF_OK) && (event_ptr != NULL)) {
		esif_ccb_event_set(event_ptr);
	}

	return rc;
}
예제 #26
0
파일: esif_uf.c 프로젝트: hoangt/dptf
void esif_memtrace_init()
{
	struct memalloc_s *mem = NULL;

	esif_ccb_lock_init(&g_memtrace.lock);
	esif_ccb_write_lock(&g_memtrace.lock);
	mem = g_memtrace.allocated;

	// Ignore any allocations made before this function was called
	while (mem) {
		struct memalloc_s *node = mem;
		mem = mem->next;
		native_free(node);
	}
	g_memtrace.allocated = NULL;
	esif_ccb_write_unlock(&g_memtrace.lock);
	ESIF_TRACE_EXIT_INFO();
}
예제 #27
0
파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf
static eEsifError EsifActMgr_AddEntry(
	EsifActMgrEntryPtr entryPtr
	)
{
	eEsifError rc = ESIF_OK;

	ESIF_ASSERT(entryPtr != NULL);

	esif_ccb_write_lock(&g_actMgr.mgrLock);

	rc =  esif_link_list_add_at_back(g_actMgr.actions, (void *)entryPtr);
	if (rc != ESIF_OK) {
		goto exit;
	}
	g_actMgr.numActions++;
exit:
	esif_ccb_write_unlock(&g_actMgr.mgrLock);
	return rc;
}
예제 #28
0
파일: esif_uf.c 프로젝트: hoangt/dptf
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);
}
예제 #29
0
파일: esif_uf.c 프로젝트: hoangt/dptf
int EsifConsole_WriteTo(u32 writeto, const char *format, ...)
{
	int rc=0;

	if (writeto & CMD_WRITETO_CONSOLE) {
		va_list args;
		va_start(args, format);
		rc = EsifConsole_vprintf(format, args);
		va_end(args);
	}
	if ((writeto & CMD_WRITETO_LOGFILE) && (g_EsifLogFile[ESIF_LOG_SHELL].handle != NULL)) {
		va_list args;
		va_start(args, format);
		esif_ccb_write_lock(&g_EsifLogFile[ESIF_LOG_SHELL].lock);
		rc = esif_ccb_vfprintf(g_EsifLogFile[ESIF_LOG_SHELL].handle, format, args);
		esif_ccb_write_unlock(&g_EsifLogFile[ESIF_LOG_SHELL].lock);
		va_end(args);
	}
	return rc;
}
예제 #30
0
파일: esif_uf_action.c 프로젝트: 01org/dptf
/*
 * Releases a reference on an action object.  This function should be
 * called when done using an action pointer obtained through any of the
 * Action Manager interfaces.
 */
void EsifAct_PutRef(EsifActPtr self)
{
	UInt8 needRelease = ESIF_FALSE;

	if (self != NULL) {
		esif_ccb_write_lock(&self->objLock);

		self->refCount--;

		if ((self->refCount == 0) && (self->markedForDelete)) {
			needRelease = ESIF_TRUE;
		}

		esif_ccb_write_unlock(&self->objLock);

		if (needRelease == ESIF_TRUE) {
			ESIF_TRACE_DEBUG("Signal delete event\n");
			esif_ccb_event_set(&self->deleteEvent);
		}
	}
}