Temperature EsifServices::primitiveExecuteGetAsTemperatureC(esif_primitive_type primitive,
UIntN participantIndex, UIntN domainIndex, UInt8 instance)
{
throwIfParticipantDomainCombinationInvalid(FLF, participantIndex, domainIndex);
EsifDataTemperature esifResult;
eEsifError rc = m_esifInterface.fPrimitiveFuncPtr(m_esifHandle, m_dptfManager,
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(participantIndex),
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(domainIndex),
EsifDataVoid(), esifResult, primitive, instance);
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
// Added to help debug issue with missing temperature threshold events
if (primitive == esif_primitive_type::GET_TEMPERATURE)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Requested participant temperature from ESIF.");
message.addMessage("Temperature", esifResult);
message.setEsifPrimitive(primitive, instance);
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setEsifErrorCode(rc);
writeMessageDebug(message, MessageCategory::TemperatureThresholds);
}
#endif
throwIfNotSuccessful(FLF, rc, primitive, participantIndex, domainIndex, instance);
return esifResult;
}
void EsifServices::throwIfNotSuccessful(const std::string& fileName, UIntN lineNumber,
const std::string& executingFunctionName, eEsifError returnCode, esif_primitive_type primitive,
UIntN participantIndex, UIntN domainIndex, UInt8 instance)
{
if (returnCode == ESIF_OK)
{
return;
}
ManagerMessage message = ManagerMessage(m_dptfManager, fileName, lineNumber, executingFunctionName,
"Error returned from ESIF services interface function call");
message.setEsifPrimitive(primitive, instance);
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setEsifErrorCode(returnCode);
if ((primitive == GET_TRIP_POINT_ACTIVE) && (returnCode == ESIF_I_ACPI_TRIP_POINT_NOT_PRESENT))
{
// no message. we still throw an exception to inform the policy.
}
else
{
writeMessageWarning(message);
}
throw primitive_execution_failed(message);
}
void PolicyServicesMessageLogging::writeMessageDebug(const DptfMessage& message)
{
throwIfNotWorkItemThread();
ManagerMessage updatedMessage = ManagerMessage(getDptfManager(), message);
updatedMessage.setPolicyIndex(getPolicyIndex());
getEsifServices()->writeMessageDebug(updatedMessage);
}
void ParticipantServices::writeMessageDebug(const DptfMessage& message)
{
throwIfNotWorkItemThread();
ManagerMessage updatedMessage = ManagerMessage(m_dptfManager, message);
updatedMessage.setParticipantIndex(m_participantIndex);
m_esifServices->writeMessageDebug(updatedMessage);
}
void EsifServices::throwIfParticipantDomainCombinationInvalid(const std::string& fileName, UIntN lineNumber,
const std::string& executingFunctionName, UIntN participantIndex, UIntN domainIndex)
{
if ((participantIndex == Constants::Esif::NoParticipant) && (domainIndex != Constants::Esif::NoDomain))
{
ManagerMessage message = ManagerMessage(m_dptfManager, fileName, lineNumber, executingFunctionName,
"Domain index not valid without associated participant index");
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
writeMessageWarning(message);
throw dptf_exception(message);
}
}
void EsifServices::writeConfigurationUInt32(const std::string& elementPath, UInt32 elementValue)
{
eEsifError rc = m_esifInterface.fSetConfigFuncPtr(m_esifHandle, m_dptfManager, EsifDataString("dptf"),
EsifDataString(elementPath), EsifDataUInt32(elementValue), ESIF_SERVICE_CONFIG_PERSIST);
if (rc != ESIF_OK)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Error returned from ESIF services interface function call");
message.addMessage("Element Path", elementPath);
message.addMessage("Element Value", elementValue);
message.setEsifErrorCode(rc);
writeMessageWarning(message);
throw dptf_exception(message);
}
}
void EsifServices::throwIfNotSuccessful(const std::string& fileName, UIntN lineNumber,
const std::string& executingFunctionName, eEsifError returnCode, UIntN participantIndex, UIntN domainIndex)
{
if (returnCode == ESIF_OK)
{
return;
}
ManagerMessage message = ManagerMessage(m_dptfManager, fileName, lineNumber, executingFunctionName,
"Error returned from ESIF services interface function call");
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setEsifErrorCode(returnCode);
writeMessageWarning(message);
throw dptf_exception(message);
}
void TemperatureThresholdArbitrator::throwIfTemperatureThresholdsInvalid(UIntN policyIndex,
const TemperatureThresholds& temperatureThresholds, const Temperature& currentTemperature)
{
Temperature aux0 = temperatureThresholds.getAux0();
Temperature aux1 = temperatureThresholds.getAux1();
if ((aux0.isValid() == true && aux0 > currentTemperature) ||
(aux1.isValid() == true && aux1 < currentTemperature))
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Received invalid temperature thresholds from policy.");
message.setPolicyIndex(policyIndex);
message.addMessage("Current Temperature", currentTemperature);
message.addMessage("Requested Aux0/Aux1", aux0.toString() + "/" + aux1.toString());
m_dptfManager->getEsifServices()->writeMessageError(message, MessageCategory::TemperatureThresholds);
throw dptf_exception(message);
}
}
void ParticipantManager::destroyParticipant(UIntN participantIndex)
{
if ((participantIndex < m_participant.size()) && (m_participant[participantIndex] != nullptr))
{
try
{
m_participant[participantIndex]->destroyParticipant();
}
catch (...)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF, "Failed while trying to destroy participant.");
message.addMessage("Participant Index", participantIndex);
m_dptfManager->getEsifServices()->writeMessageError(message);
}
DELETE_MEMORY_TC(m_participant[participantIndex]);
}
}
void PolicyServicesDomainTemperature::setTemperatureThresholds(UIntN participantIndex,
UIntN domainIndex, const TemperatureThresholds& temperatureThresholds)
{
throwIfNotWorkItemThread();
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
// Added to help debug issue with missing temperature threshold events
ManagerMessage message = ManagerMessage(getDptfManager(), FLF,
"Policy is calling PolicyServicesDomainTemperature::setTemperatureThresholds().");
message.addMessage("Aux0", temperatureThresholds.getAux0());
message.addMessage("Aux1", temperatureThresholds.getAux1());
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setPolicyIndex(getPolicyIndex());
getDptfManager()->getEsifServices()->writeMessageDebug(message, MessageCategory::TemperatureThresholds);
#endif
getParticipantManager()->getParticipantPtr(participantIndex)->setTemperatureThresholds(
domainIndex, getPolicyIndex(), temperatureThresholds);
}
std::string EsifServices::readConfigurationString(const std::string& elementPath)
{
EsifDataString esifResult(Constants::DefaultBufferSize);
eEsifError rc = m_esifInterface.fGetConfigFuncPtr(m_esifHandle, m_dptfManager, EsifDataString("dptf"),
EsifDataString(elementPath), esifResult);
if (rc != ESIF_OK)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Error returned from ESIF services interface function call");
message.addMessage("Element Path", elementPath);
message.setEsifErrorCode(rc);
writeMessageWarning(message);
throw dptf_exception(message);
}
return esifResult;
}
void ParticipantManager::destroyAllParticipants(void)
{
auto participantIndexes = MapOps<UIntN, std::shared_ptr<Participant>>::getKeys(m_participants);
for (auto index = participantIndexes.begin(); index != participantIndexes.end(); ++index)
{
try
{
// Queue up a work item and wait for the return.
m_dptfManager->getDptfStatus()->clearCache();
WorkItem* workItem = new WIParticipantDestroy(m_dptfManager, *index);
m_dptfManager->getWorkItemQueueManager()->enqueueImmediateWorkItemAndWait(workItem);
}
catch (...)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF, "Failed while trying to enqueue and wait for WIParticipantDestroy.");
message.addMessage("Participant Index", *index);
m_dptfManager->getEsifServices()->writeMessageError(message);
}
}
}
void ParticipantManager::destroyAllParticipants(void)
{
for (UIntN i = 0; i < m_participant.size(); i++)
{
if (m_participant[i] != nullptr)
{
try
{
// Queue up a work item and wait for the return.
WorkItem* workItem = new WIParticipantDestroy(m_dptfManager, i);
m_dptfManager->getWorkItemQueueManager()->enqueueImmediateWorkItemAndWait(workItem);
}
catch (...)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF, "Failed while trying to enqueue and wait for WIParticipantDestroy.");
message.addMessage("Participant Index", i);
m_dptfManager->getEsifServices()->writeMessageError(message);
}
}
}
}
UIntN WorkItemQueueManager::removeIfMatches(const WorkItemMatchCriteria& matchCriteria)
{
EsifMutexHelper esifMutexHelper(&m_mutex);
esifMutexHelper.lock();
UIntN numRemovedImmediate = m_immediateQueue->removeIfMatches(matchCriteria);
UIntN numRemovedDeferred = m_deferredQueue->removeIfMatches(matchCriteria);
esifMutexHelper.unlock();
UIntN numRemoved = numRemovedImmediate + numRemovedDeferred;
if (numRemoved > 0)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF, "One or more work items have been removed from the queues.");
message.addMessage("Immediate Queue removed", numRemovedImmediate);
message.addMessage("Deferred Queue removed", numRemovedDeferred);
m_dptfManager->getEsifServices()->writeMessageDebug(message);
}
return numRemoved;
}
Bool TemperatureThresholdArbitrator::arbitrate(UIntN policyIndex, const TemperatureThresholds& temperatureThresholds,
const Temperature& currentTemperature)
{
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Temperature arbitration data is being updated for a policy request.");
message.setPolicyIndex(policyIndex);
message.addMessage("Current Temperature", currentTemperature);
message.addMessage("Requested Aux0/Aux1", temperatureThresholds.getAux0().toString() + "/" + temperatureThresholds.getAux1().toString());
addArbitrationDataToMessage(message, "Arbitration data before applying update");
#endif
throwIfTemperatureThresholdsInvalid(policyIndex, temperatureThresholds, currentTemperature);
updateTemperatureDataForPolicy(policyIndex, temperatureThresholds);
Bool result = findNewTemperatureThresholds(currentTemperature);
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
addArbitrationDataToMessage(message, "Arbitration data after applying update");
m_dptfManager->getEsifServices()->writeMessageDebug(message, MessageCategory::TemperatureThresholds);
#endif
return result;
}
void ParticipantManager::destroyParticipant(UIntN participantIndex)
{
auto requestedParticipant = m_participants.find(participantIndex);
if (requestedParticipant != m_participants.end())
{
if (requestedParticipant->second != nullptr)
{
try
{
m_dptfManager->getDptfStatus()->clearCache();
requestedParticipant->second->destroyParticipant();
}
catch (...)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF, "Failed while trying to destroy participant.");
message.addMessage("Participant Index", participantIndex);
m_dptfManager->getEsifServices()->writeMessageError(message);
}
}
m_participants.erase(requestedParticipant);
}
}
void EsifServices::unregisterEvent(FrameworkEvent::Type frameworkEvent, UIntN participantIndex, UIntN domainIndex)
{
throwIfParticipantDomainCombinationInvalid(FLF, participantIndex, domainIndex);
Guid guid = FrameworkEventInfo::instance()->getGuid(frameworkEvent);
eEsifError rc = m_esifInterface.fUnregisterEventFuncPtr(m_esifHandle, m_dptfManager,
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(participantIndex),
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(domainIndex),
EsifDataGuid(guid));
// FIXME: this should throw an exception if we get an unexpected return code. For now we will just log an
// error so we can see a list of items to correct.
if (rc != ESIF_OK)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Error returned from ESIF unregister event function call");
message.setFrameworkEvent(frameworkEvent);
message.addMessage("Guid", guid.toString());
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setEsifErrorCode(rc);
writeMessageWarning(message);
}
}
void EsifServices::primitiveExecuteSetAsTemperatureC(esif_primitive_type primitive, Temperature temperature,
UIntN participantIndex, UIntN domainIndex, UInt8 instance)
{
throwIfParticipantDomainCombinationInvalid(FLF, participantIndex, domainIndex);
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
// Added to help debug issue with missing temperature threshold events
if (primitive == esif_primitive_type::SET_TEMPERATURE_THRESHOLDS)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Setting new temperature threshold for participant.");
message.addMessage("Temperature", temperature.toString());
message.setEsifPrimitive(primitive, instance);
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
writeMessageDebug(message, MessageCategory::TemperatureThresholds);
}
#endif
eEsifError rc = m_esifInterface.fPrimitiveFuncPtr(m_esifHandle, m_dptfManager,
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(participantIndex),
(void*)m_dptfManager->getIndexContainer()->getIndexPtr(domainIndex),
EsifDataTemperature(temperature), EsifDataVoid(), primitive, instance);
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
// Added to help debug issue with missing temperature threshold events
if (primitive == esif_primitive_type::SET_TEMPERATURE_THRESHOLDS &&
rc != ESIF_OK)
{
ManagerMessage message = ManagerMessage(m_dptfManager, FLF,
"Failed to set new temperature threshold.");
message.addMessage("Temperature", temperature.toString());
message.setEsifPrimitive(primitive, instance);
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setEsifErrorCode(rc);
writeMessageError(message, MessageCategory::TemperatureThresholds);
}
#endif
throwIfNotSuccessful(FLF, rc, primitive, participantIndex, domainIndex, instance);
}
void TemperatureThresholdArbitrator::addArbitrationDataToMessage(ManagerMessage& message, const std::string& title)
{
message.addMessage(" ");
message.addMessage(title);
message.addMessage("Last known participant temperature", m_lastKnownParticipantTemperature);
message.addMessage("Arbitrated Aux0/Aux1", m_arbitratedTemperatureThresholds.getAux0().toString() +
"/" + m_arbitratedTemperatureThresholds.getAux1().toString());
message.addMessage("--Requested temperature thresholds table contents--");
for (auto thresholds = m_requestedTemperatureThresholds.begin(); thresholds != m_requestedTemperatureThresholds.end(); thresholds++)
{
message.addMessage("Policy " + StlOverride::to_string(thresholds->first), thresholds->second.getAux0().toString() +
"/" + thresholds->second.getAux1().toString());
}
}
