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 Execute
enum 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 Disconnect
void 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);
}