| #include "pdr.hpp" |
| |
| namespace pldm |
| { |
| |
| namespace responder |
| { |
| |
| namespace pdr |
| { |
| using namespace pldm::responder::pdr_utils; |
| |
| void generate(const std::string& dir, RepoInterface& repo) |
| { |
| // A map of PDR type to a lambda that handles creation of that PDR type. |
| // The lambda essentially would parse the platform specific PDR JSONs to |
| // generate the PDR structures. This function iterates through the map to |
| // invoke all lambdas, so that all PDR types can be created. |
| std::map<Type, std::function<void(const Json& json, RepoInterface& repo)>> |
| generators = { |
| {PLDM_STATE_EFFECTER_PDR, |
| [](const auto& json, RepoInterface& repo) { |
| static const std::vector<Json> emptyList{}; |
| static const Json empty{}; |
| auto entries = json.value("entries", emptyList); |
| for (const auto& e : entries) |
| { |
| size_t pdrSize = 0; |
| auto effecters = e.value("effecters", emptyList); |
| static const Json empty{}; |
| for (const auto& effecter : effecters) |
| { |
| auto set = effecter.value("set", empty); |
| auto statesSize = set.value("size", 0); |
| if (!statesSize) |
| { |
| std::cerr << "Malformed PDR JSON return " |
| "pdrEntry;- no state set " |
| "info, TYPE=" |
| << PLDM_STATE_EFFECTER_PDR << "\n"; |
| throw InternalFailure(); |
| } |
| pdrSize += sizeof(state_effecter_possible_states) - |
| sizeof(bitfield8_t) + |
| (sizeof(bitfield8_t) * statesSize); |
| } |
| pdrSize += |
| sizeof(pldm_state_effecter_pdr) - sizeof(uint8_t); |
| |
| std::vector<uint8_t> entry{}; |
| entry.resize(pdrSize); |
| |
| pldm_state_effecter_pdr* pdr = |
| reinterpret_cast<pldm_state_effecter_pdr*>( |
| entry.data()); |
| pdr->hdr.record_handle = 0; |
| pdr->hdr.version = 1; |
| pdr->hdr.type = PLDM_STATE_EFFECTER_PDR; |
| pdr->hdr.record_change_num = 0; |
| pdr->hdr.length = pdrSize - sizeof(pldm_pdr_hdr); |
| |
| pdr->terminus_handle = 0; |
| pdr->effecter_id = effecter::nextId(); |
| pdr->entity_type = e.value("type", 0); |
| pdr->entity_instance = e.value("instance", 0); |
| pdr->container_id = e.value("container", 0); |
| pdr->effecter_semantic_id = 0; |
| pdr->effecter_init = PLDM_NO_INIT; |
| pdr->has_description_pdr = false; |
| pdr->composite_effecter_count = effecters.size(); |
| |
| using namespace effecter::dbus_mapping; |
| Paths paths{}; |
| uint8_t* start = entry.data() + |
| sizeof(pldm_state_effecter_pdr) - |
| sizeof(uint8_t); |
| for (const auto& effecter : effecters) |
| { |
| auto set = effecter.value("set", empty); |
| state_effecter_possible_states* possibleStates = |
| reinterpret_cast<state_effecter_possible_states*>( |
| start); |
| possibleStates->state_set_id = set.value("id", 0); |
| possibleStates->possible_states_size = |
| set.value("size", 0); |
| |
| start += sizeof(possibleStates->state_set_id) + |
| sizeof(possibleStates->possible_states_size); |
| static const std::vector<uint8_t> emptyStates{}; |
| auto states = set.value("states", emptyStates); |
| for (const auto& state : states) |
| { |
| auto index = state / 8; |
| auto bit = state - (index * 8); |
| bitfield8_t* bf = |
| reinterpret_cast<bitfield8_t*>(start + index); |
| bf->byte |= 1 << bit; |
| } |
| start += possibleStates->possible_states_size; |
| |
| auto dbus = effecter.value("dbus", empty); |
| paths.emplace_back(std::move(dbus)); |
| } |
| add(pdr->effecter_id, std::move(paths)); |
| PdrEntry pdrEntry{}; |
| pdrEntry.data = entry.data(); |
| pdrEntry.size = pdrSize; |
| repo.addRecord(pdrEntry); |
| } |
| }}}; |
| |
| Type pdrType{}; |
| for (const auto& dirEntry : fs::directory_iterator(dir)) |
| { |
| try |
| { |
| auto json = readJson(dirEntry.path().string()); |
| if (!json.empty()) |
| { |
| pdrType = json.value("pdrType", 0); |
| generators.at(pdrType)(json, repo); |
| } |
| } |
| catch (const InternalFailure& e) |
| { |
| std::cerr << "PDR config directory does not exist or empty, TYPE= " |
| << pdrType << "PATH= " << dirEntry |
| << " ERROR=" << e.what() << "\n"; |
| } |
| catch (const Json::exception& e) |
| { |
| std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType |
| << "PATH= " << dirEntry << " ERROR=" << e.what() << "\n"; |
| pldm::utils::reportError( |
| "xyz.openbmc_project.bmc.pldm.InternalFailure"); |
| } |
| catch (const std::exception& e) |
| { |
| std::cerr << "Failed parsing PDR JSON file, TYPE= " << pdrType |
| << " ERROR=" << e.what() << "\n"; |
| pldm::utils::reportError( |
| "xyz.openbmc_project.bmc.pldm.InternalFailure"); |
| } |
| } |
| } |
| |
| RepoInterface& getRepo(const std::string& dir) |
| { |
| static Repo repo; |
| if (repo.empty()) |
| { |
| generate(dir, repo); |
| } |
| |
| return repo; |
| } |
| |
| Repo getRepoByType(const std::string& dir, Type pdrType) |
| { |
| Repo pdrRepo; |
| RepoInterface& repo = getRepo(dir); |
| |
| uint8_t* pdrData = nullptr; |
| uint32_t pdrSize{}; |
| auto record = pldm_pdr_find_record_by_type(repo.getPdr(), pdrType, NULL, |
| &pdrData, &pdrSize); |
| while (record) |
| { |
| PdrEntry pdrEntry{}; |
| pdrEntry.data = pdrData; |
| pdrEntry.size = pdrSize; |
| pdrEntry.handle.recordHandle = repo.getRecordHandle(record); |
| pdrRepo.addRecord(pdrEntry); |
| |
| pdrData = nullptr; |
| pdrSize = 0; |
| record = pldm_pdr_find_record_by_type(repo.getPdr(), pdrType, record, |
| &pdrData, &pdrSize); |
| } |
| |
| return pdrRepo; |
| } |
| |
| const pldm_pdr_record* getRecordByHandle(RepoInterface& pdrRepo, |
| RecordHandle recordHandle, |
| PdrEntry& pdrEntry) |
| { |
| uint8_t* pdrData = nullptr; |
| auto record = |
| pldm_pdr_find_record(pdrRepo.getPdr(), recordHandle, &pdrData, |
| &pdrEntry.size, &pdrEntry.handle.nextRecordHandle); |
| if (record) |
| { |
| pdrEntry.data = pdrData; |
| } |
| |
| return record; |
| } |
| |
| } // namespace pdr |
| } // namespace responder |
| } // namespace pldm |