blob: 738b4af8f05c86588c9af84423aed65ee0a1f882 [file] [log] [blame]
#include "device_updater.hpp"
#include "activation.hpp"
#include "update_manager.hpp"
#include <libpldm/firmware_update.h>
#include <phosphor-logging/lg2.hpp>
#include <functional>
PHOSPHOR_LOG2_USING;
namespace pldm
{
namespace fw_update
{
void DeviceUpdater::startFwUpdateFlow()
{
auto instanceId = updateManager->instanceIdDb.next(eid);
// NumberOfComponents
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
// PackageDataLength
const auto& fwDevicePkgData =
std::get<FirmwareDevicePackageData>(fwDeviceIDRecord);
// ComponentImageSetVersionString
const auto& compImageSetVersion =
std::get<ComponentImageSetVersion>(fwDeviceIDRecord);
variable_field compImgSetVerStrInfo{};
compImgSetVerStrInfo.ptr =
reinterpret_cast<const uint8_t*>(compImageSetVersion.data());
compImgSetVerStrInfo.length =
static_cast<uint8_t>(compImageSetVersion.size());
Request request(sizeof(pldm_msg_hdr) +
sizeof(struct pldm_request_update_req) +
compImgSetVerStrInfo.length);
auto requestMsg = reinterpret_cast<pldm_msg*>(request.data());
auto rc = encode_request_update_req(
instanceId, maxTransferSize, applicableComponents.size(),
PLDM_FWUP_MIN_OUTSTANDING_REQ, fwDevicePkgData.size(),
PLDM_STR_TYPE_ASCII, compImgSetVerStrInfo.length, &compImgSetVerStrInfo,
requestMsg,
sizeof(struct pldm_request_update_req) + compImgSetVerStrInfo.length);
if (rc)
{
// Handle error scenario
updateManager->instanceIdDb.free(eid, instanceId);
error(
"Failed to encode request update request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
rc = updateManager->handler.registerRequest(
eid, instanceId, PLDM_FWUP, PLDM_REQUEST_UPDATE, std::move(request),
std::move(std::bind_front(&DeviceUpdater::requestUpdate, this)));
if (rc)
{
// Handle error scenario
error(
"Failed to send request update for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
}
void DeviceUpdater::requestUpdate(mctp_eid_t eid, const pldm_msg* response,
size_t respMsgLen)
{
if (response == nullptr || !respMsgLen)
{
// Handle error scenario
error("No response received for request update for endpoint ID '{EID}'",
"EID", unsigned(eid));
return;
}
uint8_t completionCode = 0;
uint16_t fdMetaDataLen = 0;
uint8_t fdWillSendPkgData = 0;
auto rc = decode_request_update_resp(response, respMsgLen, &completionCode,
&fdMetaDataLen, &fdWillSendPkgData);
if (rc)
{
error(
"Failed to decode request update response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return;
}
if (completionCode)
{
error(
"Failure in request update response for endpoint ID '{EID}', completion code '{CC}'",
"EID", unsigned(eid), "CC", unsigned(completionCode));
return;
}
// Optional fields DeviceMetaData and GetPackageData not handled
pldmRequest = std::make_unique<sdeventplus::source::Defer>(
updateManager->event,
std::bind(&DeviceUpdater::sendPassCompTableRequest, this,
componentIndex));
}
void DeviceUpdater::sendPassCompTableRequest(size_t offset)
{
pldmRequest.reset();
auto instanceId = updateManager->instanceIdDb.next(eid);
// TransferFlag
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
uint8_t transferFlag = 0;
if (applicableComponents.size() == 1)
{
transferFlag = PLDM_START_AND_END;
}
else if (offset == 0)
{
transferFlag = PLDM_START;
}
else if (offset == applicableComponents.size() - 1)
{
transferFlag = PLDM_END;
}
else
{
transferFlag = PLDM_MIDDLE;
}
const auto& comp = compImageInfos[applicableComponents[offset]];
// ComponentClassification
CompClassification compClassification = std::get<static_cast<size_t>(
ComponentImageInfoPos::CompClassificationPos)>(comp);
// ComponentIdentifier
CompIdentifier compIdentifier =
std::get<static_cast<size_t>(ComponentImageInfoPos::CompIdentifierPos)>(
comp);
// ComponentClassificationIndex
CompClassificationIndex compClassificationIndex{};
auto compKey = std::make_pair(compClassification, compIdentifier);
if (compInfo.contains(compKey))
{
auto search = compInfo.find(compKey);
compClassificationIndex = search->second;
}
else
{
// Handle error scenario
error(
"Failed to find component classification '{CLASSIFICATION}' and identifier '{IDENTIFIER}'",
"CLASSIFICATION", compClassification, "IDENTIFIER", compIdentifier);
}
// ComponentComparisonStamp
CompComparisonStamp compComparisonStamp = std::get<static_cast<size_t>(
ComponentImageInfoPos::CompComparisonStampPos)>(comp);
// ComponentVersionString
const auto& compVersion =
std::get<static_cast<size_t>(ComponentImageInfoPos::CompVersionPos)>(
comp);
variable_field compVerStrInfo{};
compVerStrInfo.ptr = reinterpret_cast<const uint8_t*>(compVersion.data());
compVerStrInfo.length = static_cast<uint8_t>(compVersion.size());
Request request(sizeof(pldm_msg_hdr) +
sizeof(struct pldm_pass_component_table_req) +
compVerStrInfo.length);
auto requestMsg = reinterpret_cast<pldm_msg*>(request.data());
auto rc = encode_pass_component_table_req(
instanceId, transferFlag, compClassification, compIdentifier,
compClassificationIndex, compComparisonStamp, PLDM_STR_TYPE_ASCII,
compVerStrInfo.length, &compVerStrInfo, requestMsg,
sizeof(pldm_pass_component_table_req) + compVerStrInfo.length);
if (rc)
{
// Handle error scenario
updateManager->instanceIdDb.free(eid, instanceId);
error(
"Failed to encode pass component table req for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
rc = updateManager->handler.registerRequest(
eid, instanceId, PLDM_FWUP, PLDM_PASS_COMPONENT_TABLE,
std::move(request),
std::move(std::bind_front(&DeviceUpdater::passCompTable, this)));
if (rc)
{
// Handle error scenario
error(
"Failed to send pass component table request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
}
void DeviceUpdater::passCompTable(mctp_eid_t eid, const pldm_msg* response,
size_t respMsgLen)
{
if (response == nullptr || !respMsgLen)
{
// Handle error scenario
error(
"No response received for pass component table for endpoint ID '{EID}'",
"EID", unsigned(eid));
return;
}
uint8_t completionCode = 0;
uint8_t compResponse = 0;
uint8_t compResponseCode = 0;
auto rc = decode_pass_component_table_resp(response, respMsgLen,
&completionCode, &compResponse,
&compResponseCode);
if (rc)
{
// Handle error scenario
error(
"Failed to decode pass component table response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return;
}
if (completionCode)
{
// Handle error scenario
error(
"Failed to pass component table response for endpoint ID '{EID}', completion code '{CC}'",
"EID", unsigned(eid), "CC", unsigned(completionCode));
return;
}
// Handle ComponentResponseCode
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
if (componentIndex == applicableComponents.size() - 1)
{
componentIndex = 0;
pldmRequest = std::make_unique<sdeventplus::source::Defer>(
updateManager->event,
std::bind(&DeviceUpdater::sendUpdateComponentRequest, this,
componentIndex));
}
else
{
componentIndex++;
pldmRequest = std::make_unique<sdeventplus::source::Defer>(
updateManager->event,
std::bind(&DeviceUpdater::sendPassCompTableRequest, this,
componentIndex));
}
}
void DeviceUpdater::sendUpdateComponentRequest(size_t offset)
{
pldmRequest.reset();
auto instanceId = updateManager->instanceIdDb.next(eid);
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
const auto& comp = compImageInfos[applicableComponents[offset]];
// ComponentClassification
CompClassification compClassification = std::get<static_cast<size_t>(
ComponentImageInfoPos::CompClassificationPos)>(comp);
// ComponentIdentifier
CompIdentifier compIdentifier =
std::get<static_cast<size_t>(ComponentImageInfoPos::CompIdentifierPos)>(
comp);
// ComponentClassificationIndex
CompClassificationIndex compClassificationIndex{};
auto compKey = std::make_pair(compClassification, compIdentifier);
if (compInfo.contains(compKey))
{
auto search = compInfo.find(compKey);
compClassificationIndex = search->second;
}
else
{
// Handle error scenario
error(
"Failed to find component classification '{CLASSIFICATION}' and identifier '{IDENTIFIER}'",
"CLASSIFICATION", compClassification, "IDENTIFIER", compIdentifier);
}
// UpdateOptionFlags
bitfield32_t updateOptionFlags;
updateOptionFlags.bits.bit0 = std::get<3>(comp)[0];
// ComponentVersion
const auto& compVersion = std::get<7>(comp);
variable_field compVerStrInfo{};
compVerStrInfo.ptr = reinterpret_cast<const uint8_t*>(compVersion.data());
compVerStrInfo.length = static_cast<uint8_t>(compVersion.size());
Request request(sizeof(pldm_msg_hdr) +
sizeof(struct pldm_update_component_req) +
compVerStrInfo.length);
auto requestMsg = reinterpret_cast<pldm_msg*>(request.data());
auto rc = encode_update_component_req(
instanceId, compClassification, compIdentifier, compClassificationIndex,
std::get<static_cast<size_t>(
ComponentImageInfoPos::CompComparisonStampPos)>(comp),
std::get<static_cast<size_t>(ComponentImageInfoPos::CompSizePos)>(comp),
updateOptionFlags, PLDM_STR_TYPE_ASCII, compVerStrInfo.length,
&compVerStrInfo, requestMsg,
sizeof(pldm_update_component_req) + compVerStrInfo.length);
if (rc)
{
// Handle error scenario
updateManager->instanceIdDb.free(eid, instanceId);
error(
"Failed to encode update component req for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
rc = updateManager->handler.registerRequest(
eid, instanceId, PLDM_FWUP, PLDM_UPDATE_COMPONENT, std::move(request),
std::move(std::bind_front(&DeviceUpdater::updateComponent, this)));
if (rc)
{
// Handle error scenario
error(
"Failed to send update request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
}
void DeviceUpdater::updateComponent(mctp_eid_t eid, const pldm_msg* response,
size_t respMsgLen)
{
if (response == nullptr || !respMsgLen)
{
// Handle error scenario
error(
"No response received for update component with endpoint ID {EID}",
"EID", unsigned(eid));
return;
}
uint8_t completionCode = 0;
uint8_t compCompatibilityResp = 0;
uint8_t compCompatibilityRespCode = 0;
bitfield32_t updateOptionFlagsEnabled{};
uint16_t timeBeforeReqFWData = 0;
auto rc = decode_update_component_resp(
response, respMsgLen, &completionCode, &compCompatibilityResp,
&compCompatibilityRespCode, &updateOptionFlagsEnabled,
&timeBeforeReqFWData);
if (rc)
{
error(
"Failed to decode update request response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return;
}
if (completionCode)
{
error(
"Failed to update request response for endpoint ID '{EID}', completion code '{CC}'",
"EID", unsigned(eid), "CC", unsigned(completionCode));
return;
}
}
Response DeviceUpdater::requestFwData(const pldm_msg* request,
size_t payloadLength)
{
uint8_t completionCode = PLDM_SUCCESS;
uint32_t offset = 0;
uint32_t length = 0;
Response response(sizeof(pldm_msg_hdr) + sizeof(completionCode), 0);
auto responseMsg = reinterpret_cast<pldm_msg*>(response.data());
auto rc = decode_request_firmware_data_req(request, payloadLength, &offset,
&length);
if (rc)
{
error(
"Failed to decode request firmware date request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
rc = encode_request_firmware_data_resp(
request->hdr.instance_id, PLDM_ERROR_INVALID_DATA, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode request firmware date response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
const auto& comp = compImageInfos[applicableComponents[componentIndex]];
auto compOffset = std::get<5>(comp);
auto compSize = std::get<6>(comp);
info("Decoded fw request data at offset '{OFFSET}' and length '{LENGTH}' ",
"OFFSET", unsigned(offset), "LENGTH", unsigned(length));
if (length < PLDM_FWUP_BASELINE_TRANSFER_SIZE || length > maxTransferSize)
{
rc = encode_request_firmware_data_resp(
request->hdr.instance_id, PLDM_FWUP_INVALID_TRANSFER_LENGTH,
responseMsg, sizeof(completionCode));
if (rc)
{
error(
"Failed to encode request firmware date response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
if (offset + length > compSize + PLDM_FWUP_BASELINE_TRANSFER_SIZE)
{
rc = encode_request_firmware_data_resp(
request->hdr.instance_id, PLDM_FWUP_DATA_OUT_OF_RANGE, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode request firmware date response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
size_t padBytes = 0;
if (offset + length > compSize)
{
padBytes = offset + length - compSize;
}
response.resize(sizeof(pldm_msg_hdr) + sizeof(completionCode) + length);
responseMsg = reinterpret_cast<pldm_msg*>(response.data());
package.seekg(compOffset + offset);
package.read(reinterpret_cast<char*>(response.data() +
sizeof(pldm_msg_hdr) +
sizeof(completionCode)),
length - padBytes);
rc = encode_request_firmware_data_resp(request->hdr.instance_id,
completionCode, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode request firmware date response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return response;
}
return response;
}
Response DeviceUpdater::transferComplete(const pldm_msg* request,
size_t payloadLength)
{
uint8_t completionCode = PLDM_SUCCESS;
Response response(sizeof(pldm_msg_hdr) + sizeof(completionCode), 0);
auto responseMsg = reinterpret_cast<pldm_msg*>(response.data());
uint8_t transferResult = 0;
auto rc = decode_transfer_complete_req(request, payloadLength,
&transferResult);
if (rc)
{
error(
"Failed to decode TransferComplete request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
rc = encode_transfer_complete_resp(request->hdr.instance_id,
PLDM_ERROR_INVALID_DATA, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode TransferComplete response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
const auto& comp = compImageInfos[applicableComponents[componentIndex]];
const auto& compVersion = std::get<7>(comp);
if (transferResult == PLDM_FWUP_TRANSFER_SUCCESS)
{
info(
"Component endpoint ID '{EID}' and version '{COMPONENT_VERSION}' transfer complete.",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion);
}
else
{
error(
"Failure in transfer of the component endpoint ID '{EID}' and version '{COMPONENT_VERSION}' with transfer result - {RESULT}",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion, "RESULT",
unsigned(transferResult));
}
rc = encode_transfer_complete_resp(request->hdr.instance_id, completionCode,
responseMsg, sizeof(completionCode));
if (rc)
{
error(
"Failed to encode transfer complete response of endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return response;
}
return response;
}
Response DeviceUpdater::verifyComplete(const pldm_msg* request,
size_t payloadLength)
{
uint8_t completionCode = PLDM_SUCCESS;
Response response(sizeof(pldm_msg_hdr) + sizeof(completionCode), 0);
auto responseMsg = reinterpret_cast<pldm_msg*>(response.data());
uint8_t verifyResult = 0;
auto rc = decode_verify_complete_req(request, payloadLength, &verifyResult);
if (rc)
{
error(
"Failed to decode verify complete request of endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
rc = encode_verify_complete_resp(request->hdr.instance_id,
PLDM_ERROR_INVALID_DATA, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode verify complete response of endpoint ID '{EID}', response code '{RC}'.",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
const auto& comp = compImageInfos[applicableComponents[componentIndex]];
const auto& compVersion = std::get<7>(comp);
if (verifyResult == PLDM_FWUP_VERIFY_SUCCESS)
{
info(
"Component endpoint ID '{EID}' and version '{COMPONENT_VERSION}' verification complete.",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion);
}
else
{
error(
"Failed to verify component endpoint ID '{EID}' and version '{COMPONENT_VERSION}' with transfer result - '{RESULT}'",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion, "RESULT",
unsigned(verifyResult));
}
rc = encode_verify_complete_resp(request->hdr.instance_id, completionCode,
responseMsg, sizeof(completionCode));
if (rc)
{
error(
"Failed to encode verify complete response for endpoint ID '{EID}', response code - {RC}",
"EID", unsigned(eid), "RC", rc);
return response;
}
return response;
}
Response DeviceUpdater::applyComplete(const pldm_msg* request,
size_t payloadLength)
{
uint8_t completionCode = PLDM_SUCCESS;
Response response(sizeof(pldm_msg_hdr) + sizeof(completionCode), 0);
auto responseMsg = reinterpret_cast<pldm_msg*>(response.data());
uint8_t applyResult = 0;
bitfield16_t compActivationModification{};
auto rc = decode_apply_complete_req(request, payloadLength, &applyResult,
&compActivationModification);
if (rc)
{
error(
"Failed to decode apply complete request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
rc = encode_apply_complete_resp(request->hdr.instance_id,
PLDM_ERROR_INVALID_DATA, responseMsg,
sizeof(completionCode));
if (rc)
{
error(
"Failed to encode apply complete response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
return response;
}
const auto& applicableComponents =
std::get<ApplicableComponents>(fwDeviceIDRecord);
const auto& comp = compImageInfos[applicableComponents[componentIndex]];
const auto& compVersion = std::get<7>(comp);
if (applyResult == PLDM_FWUP_APPLY_SUCCESS ||
applyResult == PLDM_FWUP_APPLY_SUCCESS_WITH_ACTIVATION_METHOD)
{
info(
"Component endpoint ID '{EID}' with '{COMPONENT_VERSION}' apply complete.",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion);
updateManager->updateActivationProgress();
}
else
{
error(
"Failed to apply component endpoint ID '{EID}' and version '{COMPONENT_VERSION}', error - {ERROR}",
"EID", unsigned(eid), "COMPONENT_VERSION", compVersion, "ERROR",
unsigned(applyResult));
}
rc = encode_apply_complete_resp(request->hdr.instance_id, completionCode,
responseMsg, sizeof(completionCode));
if (rc)
{
error(
"Failed to encode apply complete response for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
return response;
}
if (componentIndex == applicableComponents.size() - 1)
{
componentIndex = 0;
pldmRequest = std::make_unique<sdeventplus::source::Defer>(
updateManager->event,
std::bind(&DeviceUpdater::sendActivateFirmwareRequest, this));
}
else
{
componentIndex++;
pldmRequest = std::make_unique<sdeventplus::source::Defer>(
updateManager->event,
std::bind(&DeviceUpdater::sendUpdateComponentRequest, this,
componentIndex));
}
return response;
}
void DeviceUpdater::sendActivateFirmwareRequest()
{
pldmRequest.reset();
auto instanceId = updateManager->instanceIdDb.next(eid);
Request request(sizeof(pldm_msg_hdr) +
sizeof(struct pldm_activate_firmware_req));
auto requestMsg = reinterpret_cast<pldm_msg*>(request.data());
auto rc = encode_activate_firmware_req(
instanceId, PLDM_NOT_ACTIVATE_SELF_CONTAINED_COMPONENTS, requestMsg,
sizeof(pldm_activate_firmware_req));
if (rc)
{
updateManager->instanceIdDb.free(eid, instanceId);
error(
"Failed to encode activate firmware req for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
rc = updateManager->handler.registerRequest(
eid, instanceId, PLDM_FWUP, PLDM_ACTIVATE_FIRMWARE, std::move(request),
std::move(std::bind_front(&DeviceUpdater::activateFirmware, this)));
if (rc)
{
error(
"Failed to send activate firmware request for endpoint ID '{EID}', response code '{RC}'",
"EID", unsigned(eid), "RC", rc);
}
}
void DeviceUpdater::activateFirmware(mctp_eid_t eid, const pldm_msg* response,
size_t respMsgLen)
{
if (response == nullptr || !respMsgLen)
{
// Handle error scenario
error(
"No response received for activate firmware for endpoint ID '{EID}'",
"EID", eid);
return;
}
uint8_t completionCode = 0;
uint16_t estimatedTimeForActivation = 0;
auto rc = decode_activate_firmware_resp(
response, respMsgLen, &completionCode, &estimatedTimeForActivation);
if (rc)
{
// Handle error scenario
error(
"Failed to decode activate firmware response for endpoint ID '{EID}', response code '{RC}'",
"EID", eid, "RC", rc);
return;
}
if (completionCode)
{
// Handle error scenario
error(
"Failed to activate firmware response for endpoint ID '{EID}', completion code '{CC}'",
"EID", eid, "CC", completionCode);
return;
}
updateManager->updateDeviceCompletion(eid, true);
}
} // namespace fw_update
} // namespace pldm