C++ (Cpp) esif_ccb_library_unload 예제들

예제 #1

파일: esif_uf_appmgr.c 프로젝트: hoangt/dptf

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

예제 #2

파일: esif_uf_actmgr.c 프로젝트: hoangt/dptf

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

예제 #3

파일: esif_uf_app.c 프로젝트: hoangt/dptf

eEsifError EsifAppStart(EsifAppPtr appPtr)
{
	ESIF_TRACE_ENTRY_INFO();

	eEsifError rc = ESIF_OK;
	GetIfaceFuncPtr iface_func_ptr = NULL;
	esif_string iface_func_name    = GET_APPLICATION_INTERFACE_FUNCTION;

	char libPath[ESIF_LIBPATH_LEN];
	ESIF_TRACE_DEBUG("name=%s\n", appPtr->fLibNamePtr);
	esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_PATHTYPE_DLL, appPtr->fLibNamePtr, ESIF_LIB_EXT);
	appPtr->fLibHandle = esif_ccb_library_load(libPath);

	if (NULL == appPtr->fLibHandle || NULL == appPtr->fLibHandle->handle) {
		rc = esif_ccb_library_error(appPtr->fLibHandle);
		ESIF_TRACE_DEBUG("esif_ccb_library_load() %s failed [%s (%d)]: %s\n", libPath, esif_rc_str(rc), rc, esif_ccb_library_errormsg(appPtr->fLibHandle));
		goto exit;
	}

	ESIF_TRACE_DEBUG("esif_ccb_library_load() %s completed.\n", libPath);

	iface_func_ptr = (GetIfaceFuncPtr)esif_ccb_library_get_func(appPtr->fLibHandle, (char*)iface_func_name);
	if (NULL == iface_func_ptr) {
		rc = esif_ccb_library_error(appPtr->fLibHandle);
		ESIF_TRACE_DEBUG("esif_ccb_library_get_func() %s failed [%s (%d)]: %s\n", iface_func_name, esif_rc_str(rc), rc, esif_ccb_library_errormsg(appPtr->fLibHandle));
		goto exit;
	}

	ESIF_TRACE_DEBUG("esif_ccb_library_get_func() %s completed.\n", iface_func_name);
	rc = AppCreate(appPtr, iface_func_ptr);
	if (ESIF_OK != rc) {
		ESIF_TRACE_DEBUG("AppCreate failed.\n");
		goto exit;
	}
	ESIF_TRACE_DEBUG("AppCreate completed.\n");

	rc = EsifApp_RegisterParticipantsWithApp(appPtr);
	if (ESIF_OK != rc) {
		ESIF_TRACE_DEBUG("EsifApp_RegisterParticipantsWithApp failed.\n");
		goto exit;
	}
	ESIF_TRACE_DEBUG("EsifApp_RegisterParticipantsWithApp completed.\n");

exit:

	if (ESIF_OK != rc) {
		esif_ccb_library_unload(appPtr->fLibHandle);
		appPtr->fLibHandle = NULL;
	}
	ESIF_TRACE_EXIT_INFO_W_STATUS(rc);
	return rc;
}

예제 #4

파일: esif_uf_conjure.c 프로젝트: naitaku/dptf

eEsifError EsifConjureStop(EsifCnjPtr conjurePtr)
{
	eEsifError rc = ESIF_OK;
	ESIF_ASSERT(conjurePtr != NULL);

	rc = conjurePtr->fInterface.fConjureDestroyFuncPtr(conjurePtr->fHandle);
	if (ESIF_OK == rc) {
		esif_ccb_free(conjurePtr->fLibNamePtr);
		esif_ccb_library_unload(conjurePtr->fLibHandle);
		memset(conjurePtr, 0, sizeof(*conjurePtr));
	}
	return rc;
}

예제 #5

파일: esif_uf_action.c 프로젝트: naitaku/dptf

eEsifError EsifActStop (EsifActPtr actPtr)
{
	eEsifError rc = ESIF_OK;
	ESIF_ASSERT(actPtr != NULL);

	// TODO: Cleanup

	if (ESIF_OK == rc) {
		esif_ccb_free(actPtr->fLibNamePtr);
		esif_ccb_library_unload(actPtr->fLibHandle);
		memset(actPtr, 0, sizeof(*actPtr));
	}
	return rc;
}

예제 #6

파일: esif_uf_actmgr.c 프로젝트: LjdCN/dptf

static eEsifError EsifActMgr_UnloadAction(EsifActMgrEntryPtr entryPtr)
{
	eEsifError rc = ESIF_OK;

	if (entryPtr == NULL) {
		ESIF_TRACE_ERROR("\tactPtr is NULL");
		rc = ESIF_E_PARAMETER_IS_NULL;
		goto exit;
	}

	esif_ccb_library_unload(entryPtr->lib);
	entryPtr->lib = NULL;
exit:
	return rc;
}

예제 #7

파일: esif_uf_app.c 프로젝트: hoangt/dptf

eEsifError EsifAppStop(EsifAppPtr appPtr)
{
	eEsifError rc = ESIF_OK;
	ESIF_ASSERT(appPtr != NULL);

	rc = EsifApp_DestroyParticipants(appPtr);
	ESIF_TRACE_DEBUG("EsifUpManagerDestroyParticipantsInApp completed.\n");

	rc = appPtr->fInterface.fAppDestroyFuncPtr(appPtr->fHandle);
	if (ESIF_OK == rc) {
		esif_ccb_library_unload(appPtr->fLibHandle);
		esif_ccb_free(appPtr->fLibNamePtr);
		memset(appPtr, 0, sizeof(*appPtr));
	}

	return rc;
}

예제 #8

파일: esif_uf_cnjmgr.c 프로젝트: naitaku/dptf

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