自学教程：C++ ESIF_TRACE_DEBUG函数代码示例

/* * This function processes requests for either websocket connections or * http connections. */static eEsifError esif_ws_client_process_request(ClientRecordPtr clientPtr){	eEsifError result = ESIF_OK;	size_t messageLength  = 0;		esif_ccb_memset(g_ws_http_buffer, 0, WS_BUFFER_LENGTH);	/*Pull the next message from the client socket */	messageLength = (size_t)recv(clientPtr->socket, (char*)g_ws_http_buffer, WS_BUFFER_LENGTH, 0);	if (messageLength == 0 || messageLength == SOCKET_ERROR) {		ESIF_TRACE_DEBUG("no messages received from the socket/n");		result =  ESIF_E_WS_DISC;		goto exit;	} else {		ESIF_TRACE_DEBUG("%d bytes received/n", (int)messageLength);	}	if (clientPtr->state == STATE_NORMAL) {		result = esif_ws_client_process_active_client(clientPtr, (char *)g_ws_http_buffer, WS_BUFFER_LENGTH, messageLength);		goto exit;	}	if (clientPtr->state == STATE_OPENING) {		result = esif_ws_client_open_client(clientPtr, (char *)g_ws_http_buffer, WS_BUFFER_LENGTH, messageLength);		goto exit;	}	result =  ESIF_E_WS_DISC;exit:	return result;}

static eEsifError CreateDomains(	EsifAppPtr appPtr,	EsifUpPtr upPtr,	AppParticipantDataMapPtr participantDataMapPtr	){	eEsifError rc = ESIF_OK;	UInt8 i = 0;	ESIF_TRACE_DEBUG("Create Domains/n");	for (i = 0; i < upPtr->fDspPtr->get_domain_count(upPtr->fDspPtr); i++) {		struct esif_fpc_domain *domain_ptr = upPtr->fDspPtr->get_domain(upPtr->fDspPtr, i + 1);		if (NULL == domain_ptr) {			continue;		}		rc = CreateDomain(i, appPtr, participantDataMapPtr, domain_ptr);		if (ESIF_OK != rc) {			goto exit;		}		ESIF_TRACE_DEBUG("Create Domain %s/n", domain_ptr->descriptor.name);	}exit:	return rc;}

static eEsifError DestroyDomain(	EsifAppPtr appPtr,	AppParticipantDataMapPtr participantDataMapPtr,	AppDomainDataMapPtr domainDataMapPtr	){	eEsifError rc = ESIF_OK;	rc = appPtr->fInterface.fDomainDestroyFuncPtr(			appPtr->fHandle,			participantDataMapPtr->fAppParticipantHandle,			domainDataMapPtr->fAppDomainHandle);	if (ESIF_OK == rc) {		ESIF_TRACE_DEBUG("DomainMap(%u) Esif 0x%p UnMapped From Handle 0x%p/n",						 domainDataMapPtr->fAppDomainId,						 domainDataMapPtr->fAppDomainDataPtr,						 domainDataMapPtr->fAppDomainHandle);	} else {		ESIF_TRACE_DEBUG("DomainMap(%u) Esif UnMapping Error %s(%d)/n",						 domainDataMapPtr->fAppDomainId,						 esif_rc_str(rc), rc);	}	memset(domainDataMapPtr, 0, sizeof(*domainDataMapPtr));	return rc;}

// IPC Executeenum esif_rc ipc_execute (struct esif_ipc *ipc){	enum esif_rc rc = ESIF_OK;	struct timeval start  = {0};	struct timeval finish = {0};	struct timeval result;	if (g_ipc_handle == ESIF_INVALID_HANDLE) {		rc = ESIF_E_NO_LOWER_FRAMEWORK;		goto exit;	}	if (g_timestamp) {		esif_ccb_get_time(&start);	}	rc = esif_ipc_execute(g_ipc_handle, ipc);	if (g_timestamp) {		esif_ccb_get_time(&finish);	}	if (g_timestamp) {		ESIF_TRACE_DEBUG("Start time: %06lu.%06lu/n",						 start.tv_sec, start.tv_usec);		ESIF_TRACE_DEBUG("Finish time: %06lu.%06lu/n",						 finish.tv_sec, finish.tv_usec);		timeval_subtract(&result, &finish, &start);		ESIF_TRACE_DEBUG("IPC Exec Time: %06lu.%06lu (%06lu usecs)/n",						 result.tv_sec, result.tv_usec, result.tv_usec);	}exit:	return rc;}

/* Start Conjure Library */eEsifError EsifConjureStart(EsifCnjPtr conjurePtr){	eEsifError rc = ESIF_OK;	GetIfaceFuncPtr iface_func_ptr = NULL;	EsifString iface_func_name     = "GetConjureInterface";	char libPath[ESIF_LIBPATH_LEN];	ESIF_TRACE_DEBUG("%s name=%s/n", ESIF_FUNC, conjurePtr->fLibNamePtr);	esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_PATHTYPE_DLL, conjurePtr->fLibNamePtr, ESIF_LIB_EXT);	conjurePtr->fLibHandle = esif_ccb_library_load(libPath);	if (NULL == conjurePtr->fLibHandle) {		rc = ESIF_E_UNSPECIFIED;		ESIF_TRACE_ERROR("%s esif_ccb_library_load() %s failed./n", ESIF_FUNC, libPath);		goto exit;	}	ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s completed./n", ESIF_FUNC, libPath);	iface_func_ptr = (GetIfaceFuncPtr)esif_ccb_library_get_func(conjurePtr->fLibHandle, (EsifString)iface_func_name);	if (NULL == iface_func_ptr) {		rc = ESIF_E_UNSPECIFIED;		ESIF_TRACE_ERROR("%s esif_ccb_library_get_func() %s failed./n", ESIF_FUNC, iface_func_name);		goto exit;	}	ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s completed./n", ESIF_FUNC, iface_func_name);	rc = ConjureCreate(conjurePtr, iface_func_ptr);	ESIF_TRACE_DEBUG("%s ConjureCreate completed./n", ESIF_FUNC);exit:	return rc;}

/* IPC OS Execution */enum esif_rc esif_os_ipc_execute(	esif_handle_t handle,	struct esif_ipc *ipc_ptr	){	int rc = 0;	ESIF_TRACE_DEBUG("linux_%s: handle = %d, IPC = %p/n",			 __func__,			 handle,			 ipc_ptr);	/* use IOCTL or read here */#ifdef ESIF_ATTR_OS_ANDROID	rc = read(handle, ipc_ptr, ipc_ptr->data_len + sizeof(struct esif_ipc));	ESIF_TRACE_DEBUG("linux_%s: READ handle = %d, IPC = %p rc = %d/n",			 __func__, handle, ipc_ptr, rc);#else	rc = ioctl(handle, ESIF_IOCTL_IPC, ipc_ptr);	ESIF_TRACE_DEBUG("linux_%s: IOCTL handle = %d, IPC = %p rc = %d/n",			 __func__, handle, ipc_ptr, rc);	if (rc)		return ESIF_E_UNSPECIFIED;#endif	return ESIF_OK;}

/* Get By Instance From ID */EsifUpPtr EsifUpManagerGetAvailableParticipantByInstance (	const UInt8 id	){	EsifUpPtr up_ptr = NULL;	ESIF_TRACE_DEBUG("%s: instance %d/n", ESIF_FUNC, id);	if (id >= MAX_PARTICIPANT_ENTRY) {		ESIF_TRACE_ERROR("Instance id %d is out of range/n", id);		ESIF_ASSERT(0);		goto exit;	}	/* Lock manager */	esif_ccb_read_lock(&g_uppMgr.fLock);	if (g_uppMgr.fEntries[id].fState > ESIF_PM_PARTICIPANT_REMOVED) {		up_ptr = g_uppMgr.fEntries[id].fUpPtr;	}	/* Unlock Manager */	esif_ccb_read_unlock(&g_uppMgr.fLock);exit:	if (NULL == up_ptr) {		ESIF_TRACE_DEBUG("%s: instance %d NOT found or OUT OF BOUNDS/n",						 ESIF_FUNC, id);	}	return up_ptr;}

void ipc_connect (){	g_ipc_handle = esif_ipc_connect((char*)SESSION_ID);	if (g_ipc_handle != ESIF_INVALID_HANDLE) {		char *kern_str = esif_cmd_info(g_out_buf);		ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Opened/n");		if (NULL != kern_str) {			ESIF_TRACE_DEBUG("%s", kern_str);			esif_ccb_sprintf(sizeof(g_esif_kernel_version), g_esif_kernel_version, "%s", kern_str);		}	}}

eEsifError EsifAppDestroyParticipant(	const EsifAppPtr appPtr,	const EsifUpPtr upPtr	){	eEsifError rc = ESIF_OK;	AppParticipantDataMapPtr participant_data_map_ptr = NULL;	if (NULL == appPtr || NULL == upPtr) {		rc = ESIF_E_PARAMETER_IS_NULL;		goto exit;	}	participant_data_map_ptr = &appPtr->fParticipantData[upPtr->fInstance];	// If created as NULL no need for callback.	if (NULL == participant_data_map_ptr ||		NULL == participant_data_map_ptr->fAppParticipantHandle) {		goto exit;	}	rc = DestroyDomains(appPtr, participant_data_map_ptr);	if (rc != ESIF_OK) {		goto exit;	}	rc = appPtr->fInterface.fParticipantDestroyFuncPtr(			appPtr->fHandle,			participant_data_map_ptr->fAppParticipantHandle);	if (ESIF_OK == rc) {		ESIF_TRACE_DEBUG("ParticipantMap(%u) Esif 0x%p UnMapped From Handle 0x%p/n",						 participant_data_map_ptr->fUpPtr->fInstance,						 participant_data_map_ptr->fUpPtr,						 participant_data_map_ptr->fAppParticipantHandle);	} else {		ESIF_TRACE_DEBUG("ParticipantMap(%u) UnMapping Error %s(%d)/n",						 participant_data_map_ptr->fUpPtr->fInstance,						 esif_rc_str(rc), rc);	}exit:	if (participant_data_map_ptr != NULL) {		if (participant_data_map_ptr->fUpPtr != NULL) {			/* release reference on participant since we get reference on it in EsifAppCreateParticipant */			EsifUp_PutRef(participant_data_map_ptr->fUpPtr);		}		memset(participant_data_map_ptr, 0, sizeof(*participant_data_map_ptr));	}	return rc;}

/* IPC Disconnect */void esif_ipc_disconnect(	esif_handle_t handle	){	ESIF_TRACE_DEBUG("IPC handle = %d/n", handle);	esif_os_ipc_disconnect(handle);}

static eEsifError UnRegisterParticipant(const EsifParticipantIfacePtr pi){	UNREFERENCED_PARAMETER(pi);	ESIF_TRACE_DEBUG("%s/n", ESIF_FUNC);	return ESIF_E_NOT_IMPLEMENTED;}

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

// IPC Disconnectvoid ipc_disconnect (){	esif_ipc_disconnect(g_ipc_handle);	g_ipc_handle = ESIF_INVALID_HANDLE;	ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Closed/n");}

/* Data For Interface Marshaling */static AppDomainDataPtr CreateDomainData(const struct esif_fpc_domain *domainPtr){	AppDomainDataPtr dom_data_ptr = (AppDomainDataPtr)esif_ccb_malloc(sizeof(AppDomainData));	ESIF_TRACE_DEBUG("%s/n", domainPtr->descriptor.name);	if (NULL == dom_data_ptr) {		goto exit;	}	dom_data_ptr->fName.buf_ptr  = (void *)domainPtr->descriptor.name;	dom_data_ptr->fName.buf_len  = ESIF_NAME_LEN;	dom_data_ptr->fName.data_len = (UInt32)esif_ccb_strlen(domainPtr->descriptor.name, ESIF_NAME_LEN);	dom_data_ptr->fName.type     = ESIF_DATA_STRING;	dom_data_ptr->fDescription.buf_ptr  = (void *)domainPtr->descriptor.description;	dom_data_ptr->fDescription.buf_len  = ESIF_DESC_LEN;	dom_data_ptr->fDescription.data_len = (UInt32)esif_ccb_strlen(domainPtr->descriptor.description, ESIF_DESC_LEN);	dom_data_ptr->fDescription.type     = ESIF_DATA_STRING;	dom_data_ptr->fGuid.buf_ptr  = (void *)domainPtr->descriptor.guid;	dom_data_ptr->fGuid.buf_len  = ESIF_GUID_LEN;	dom_data_ptr->fGuid.data_len = ESIF_GUID_LEN;	dom_data_ptr->fGuid.type     = ESIF_DATA_GUID;	dom_data_ptr->fVersion    = APP_DOMAIN_VERSION;	dom_data_ptr->fType       = (enum esif_domain_type)domainPtr->descriptor.domainType;	dom_data_ptr->fCapability = domainPtr->capability_for_domain.capability_flags;	esif_ccb_memcpy(dom_data_ptr->fCapabilityBytes, domainPtr->capability_for_domain.capability_mask, 32);exit:	return dom_data_ptr;}

/* IPC Connect */esif_handle_t esif_ipc_connect(	esif_string session_id	){	ESIF_TRACE_DEBUG("IPC session_id = %s/n", session_id);	return esif_os_ipc_connect(session_id);}

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

/* Handle each weighted Minterm */static int compare_and_weight_minterm(	esif_string dsp,	esif_string qry,enum dspSelectorWeight weight	){	int score = 0;		if (0 == *dsp) {	/* DSP don't care trumps all */		score = 0;	}	else if ('*' == *dsp) {	/* Wildcard DSP matches all but with lower score than exact match */		score = ((int)weight) / 4;	}	else if (0 == *qry || '*' == *qry) {	/* blank == blank don't care. */		score = 0;	}	else if (minterm_matches(dsp, qry)) { /* data == exact match or qry in "data|data|...|data" */		score = (int)weight;	}	else {		score = -1;	/* no match. */	}	ESIF_TRACE_DEBUG("DSP VALUE: %s VERSUS PARTICIPANT VALUE: %s  = SCORE: %d /n", dsp, qry, score);	return score;}

enum esif_rc EsifActMgrInit (){	enum esif_rc rc = ESIF_OK;	u8 i = 0;	ESIF_TRACE_DEBUG("%s: Init Action Manager (ACTMGR)", ESIF_FUNC);	g_actMgr.fActTypes = esif_link_list_create();	if (NULL == g_actMgr.fActTypes) {		return ESIF_E_NO_MEMORY;	}	g_actMgr.GetActType     = GetActionType;	g_actMgr.GetActFromName = GetActionFromName;	g_actMgr.AddActType     = AddAction;	g_actMgr.RemoveActType  = RemoveAction;	/* Add static Kernel Entries */	for (i = 0; g_kernelActions[i].fType; i++)		g_actMgr.AddActType(&g_actMgr, &g_kernelActions[i]);	/* Action manager must be initialized */	EsifActInit();	return rc;}

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

/* Insert Action Into List */static eEsifError AddAction(	EsifActMgrPtr THIS,	EsifActTypePtr actionPtr	){	ESIF_TRACE_DEBUG("Item %p", actionPtr);	return  esif_link_list_add_at_back(THIS->fActTypes, (void *)actionPtr);}

/* IPC Execute */enum esif_rc esif_ipc_execute(	esif_handle_t handle,	struct esif_ipc *ipc_ptr	){	ESIF_TRACE_DEBUG("Handle = %d, IPC = %p/n", handle, ipc_ptr);	return esif_os_ipc_execute(handle, ipc_ptr);}

static void EsifDataLogSchedule(const void *ctx){	eEsifError rc = ESIF_OK;	UNREFERENCED_PARAMETER(ctx);	if (dataLogContextPtr == NULL) {		ESIF_TRACE_DEBUG("Data logging schedule fired had no context./n");		goto exit;	}	if (dataLogContextPtr->dataLogScheduleTimer == NULL) {		ESIF_TRACE_DEBUG("Data logging schedule fired but had no reference to the members./n");		goto exit;	}	/*	* Serialize access to the datalog state.	*/	while (atomic_set(&g_dataLogLock, ESIF_TRUE)) {		esif_ccb_sleep_msec(ESIF_DATALOG_LOCK_SLEEP_MS);	}	if (EsifDataIsLogStarted()){		ESIF_TRACE_DEBUG("Data logging schedule fired but was already started./n");		goto exit;	}	rc = EsifDataLogValidateParticipantList(dataLogContextPtr->dataLogParticipantList);	if (rc != ESIF_OK) {		ESIF_TRACE_ERROR("There was a problem with your participant list. You may have selected invalid participants, or too many participants. /n");		goto exit;	}	rc = EsifDataLogOpenLogFile();	if (rc != ESIF_OK) {		ESIF_TRACE_ERROR("Error opening scheduled log file... /n");		goto exit;	}	ESIF_TRACE_DEBUG("Data logging starting... /n");	g_dataLogInterval = dataLogContextPtr->dataLogInterval;	EsifDataLogStart();exit:	EsifDataLogCleanup();	atomic_set(&g_dataLogLock, ESIF_FALSE);}

eEsifError EsifActCallPluginGet(	esif_context_t actCtx,	EsifUpPtr upPtr,	const EsifFpcActionPtr fpcActionPtr,	ActExecuteGetFunction actGetFuncPtr,	const EsifDataPtr requestPtr,	const EsifDataPtr responsePtr	){	eEsifError rc = ESIF_OK;	EsifData params[NUMBER_OF_PARAMETERS_FOR_AN_ACTION] = {0};	/*  Participant Check */	if (NULL == upPtr) {		rc = ESIF_E_PARAMETER_IS_NULL;		ESIF_TRACE_WARN("Participant For Participant ID %d NOT FOUND/n", EsifUp_GetInstance(upPtr));		goto exit;	}	if (NULL == fpcActionPtr) {		rc = ESIF_E_PARAMETER_IS_NULL;		ESIF_TRACE_WARN("NULL action pointer received/n");		goto exit;		}	if (NULL == actGetFuncPtr) {		ESIF_TRACE_DEBUG("Plugin function pointer is NULL/n");		rc = ESIF_E_PARAMETER_IS_NULL;		goto exit;	}	if (NULL == requestPtr) {		rc = ESIF_E_PARAMETER_IS_NULL;		ESIF_TRACE_WARN("NULL request pointer/n");		goto exit;	}	rc = EsifFpcAction_GetParams(fpcActionPtr,		params,		sizeof(params)/sizeof(*params));	if (ESIF_OK != rc) {		goto exit;	}	rc = actGetFuncPtr(actCtx,		(esif_handle_t)(size_t)upPtr->fInstance,		upPtr->fMetadata.fDevicePath,		&params[0],		&params[1],		&params[2],		&params[3],		&params[4],		requestPtr,		responsePtr);exit:	return rc;}

/* Insert Action Into List */static eEsifError AddAction (	EsifActMgrPtr THIS,	EsifActTypePtr actionPtr	){	esif_link_list_node_add(THIS->fActTypes, esif_link_list_create_node(actionPtr));	ESIF_TRACE_DEBUG("%s: item %p", ESIF_FUNC, actionPtr);	return ESIF_OK;}

eEsifError esif_uf_init(){	eEsifError rc = ESIF_OK;	ESIF_TRACE_ENTRY_INFO();#ifdef ESIF_ATTR_SHELL_LOCK	esif_ccb_mutex_init(&g_shellLock);#endif	ESIF_TRACE_DEBUG("Init Upper Framework (UF)");	esif_ccb_mempool_init_tracking();	// Get Home directory	CMD_OUT("Home: %s/n", esif_pathlist_get(ESIF_PATHTYPE_HOME));	/* OS Agnostic */	EsifLogMgrInit();	esif_link_list_init();	esif_ht_init();	esif_ccb_tmrm_init();	EsifCfgMgrInit();	EsifEventMgr_Init();	EsifCnjMgrInit();	EsifUpPm_Init();	EsifDspMgrInit();	EsifActMgrInit();	/* Web Server optionally started by shell scripts in esif_init */	/* OS Specific */	rc = esif_uf_os_init();	if (ESIF_OK != rc) {		goto exit;	}	/* Start App Manager after all dependent components started	 * This does not actually start any apps.	 */	EsifAppMgrInit();#ifdef ESIF_FEAT_OPT_ACTION_SYSFS	SysfsRegisterParticipants();#else	ipc_connect();	sync_lf_participants();#endifexit: 	ESIF_TRACE_EXIT_INFO_W_STATUS(rc);	return rc;}

void EsifActMgrExit (){	/* Call before destroying action manager */	EsifActExit();	if (NULL != g_actMgr.fActTypes) {		esif_link_list_destroy(g_actMgr.fActTypes);	}	ESIF_TRACE_DEBUG("%s: Exit Action Manager (ACTMGR)", ESIF_FUNC);}

/* Lookup participant data for a instance */static AppParticipantDataMapPtr EsifApp_GetParticipantDataMapFromInstance(	const EsifAppPtr appPtr,	const u8 participantId	){	UInt8 i = 0;	AppParticipantDataMapPtr upDataMapPtr = NULL;	/* First Find Upper Framework Pointer */	EsifUpPtr upPtr = EsifUpPm_GetAvailableParticipantByInstance(participantId);	if (NULL == upPtr) {		goto exit;	}	ESIF_TRACE_DEBUG("Have Event For Participant %s/n", EsifUp_GetName(upPtr));	/*	 * Okay now we have to find the correct particpant handle based on the appPtr.  Note each	 * app will have a different particpant handle.	 */	for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {		if (NULL == appPtr->fParticipantData[i].fUpPtr) {			continue;		}		if (appPtr->fParticipantData[i].fUpPtr == upPtr) {			upDataMapPtr = &appPtr->fParticipantData[i];			ESIF_TRACE_DEBUG("Found participant data map for %s/n", EsifUp_GetName(upPtr));			break;		}	}exit:	if (upPtr != NULL) {		EsifUp_PutRef(upPtr);	}	return upDataMapPtr;}

/* IPC OS Connect */esif_handle_t esif_os_ipc_connect(char *session_id){	int fd = 0;	char device[64];/* Jacob Is There a Standard Path Length? */	sprintf(device, "/dev/%s", IPC_DEVICE);	fd = open(device, O_RDWR);	ESIF_TRACE_DEBUG("linux_%s: session_id=%s device=%s handle=%d/n",			 __func__, session_id, device, fd);	return fd;}