1 /* 2 // Copyright (c) 2019 Intel Corporation 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 */ 16 #include "post_code.hpp" 17 18 #include <cereal/access.hpp> 19 #include <cereal/archives/binary.hpp> 20 #include <cereal/cereal.hpp> 21 #include <cereal/types/map.hpp> 22 #include <cereal/types/tuple.hpp> 23 #include <cereal/types/vector.hpp> 24 25 #include <iomanip> 26 27 const static constexpr auto timeoutMicroSeconds = 1000000; 28 29 void PostCode::deleteAll() 30 { 31 std::uintmax_t n = fs::remove_all(postCodeListPath); 32 std::cerr << "clearPostCodes deleted " << n << " files in " 33 << postCodeListPath << std::endl; 34 fs::create_directories(postCodeListPath); 35 postCodes.clear(); 36 currentBootCycleIndex = 0; 37 currentBootCycleCount(0); 38 } 39 40 std::vector<postcode_t> PostCode::getPostCodes(uint16_t index) 41 { 42 std::vector<postcode_t> codesVec; 43 if (1 == index && !postCodes.empty()) 44 { 45 std::transform(postCodes.begin(), postCodes.end(), 46 std::back_inserter(codesVec), 47 [](const auto& kv) { return kv.second; }); 48 } 49 else 50 { 51 uint16_t bootNum = getBootNum(index); 52 53 decltype(postCodes) codes; 54 deserializePostCodes(postCodeListPath / std::to_string(bootNum), codes); 55 std::transform(codes.begin(), codes.end(), std::back_inserter(codesVec), 56 [](const auto& kv) { return kv.second; }); 57 } 58 return codesVec; 59 } 60 61 std::map<uint64_t, postcode_t> 62 PostCode::getPostCodesWithTimeStamp(uint16_t index) 63 { 64 if (1 == index && !postCodes.empty()) 65 { 66 return postCodes; 67 } 68 69 uint16_t bootNum = getBootNum(index); 70 decltype(postCodes) codes; 71 deserializePostCodes(postCodeListPath / std::to_string(bootNum), codes); 72 return codes; 73 } 74 75 void PostCode::savePostCodes(postcode_t code) 76 { 77 if (!timer) 78 { 79 timer = std::make_unique<sdbusplus::Timer>(event.get(), [this]() { 80 serialize(postCodeListPath); 81 }); 82 } 83 84 // steady_clock is a monotonic clock that is guaranteed to never be adjusted 85 auto postCodeTimeSteady = std::chrono::steady_clock::now(); 86 uint64_t tsUS = std::chrono::duration_cast<std::chrono::microseconds>( 87 std::chrono::system_clock::now().time_since_epoch()) 88 .count(); 89 90 if (postCodes.empty()) 91 { 92 firstPostCodeTimeSteady = postCodeTimeSteady; 93 firstPostCodeUsSinceEpoch = tsUS; // uS since epoch for 1st post code 94 incrBootCycle(); 95 } 96 else 97 { 98 // calculating tsUS so it is monotonic within the same boot 99 tsUS = firstPostCodeUsSinceEpoch + 100 std::chrono::duration_cast<std::chrono::microseconds>( 101 postCodeTimeSteady - firstPostCodeTimeSteady) 102 .count(); 103 } 104 105 postCodes.insert(std::make_pair(tsUS, code)); 106 if (postCodes.size() > MAX_POST_CODE_SIZE_PER_CYCLE) 107 { 108 postCodes.erase(postCodes.begin()); 109 } 110 111 if (!timer->isRunning()) 112 { 113 timer->start(std::chrono::microseconds(timeoutMicroSeconds)); 114 } 115 116 if (strlen(POSTCODE_DISPLAY_PATH) > 0) 117 { 118 std::string postCodeDisplayPath = 119 POSTCODE_DISPLAY_PATH + std::to_string(node); 120 121 std::ofstream postCodeDisplayFile(postCodeDisplayPath); 122 postCodeDisplayFile << "0x" << std::setfill('0') << std::hex; 123 for (const auto& byte : std::get<0>(code)) 124 { 125 postCodeDisplayFile << std::setw(2) << static_cast<int>(byte); 126 } 127 postCodeDisplayFile.close(); 128 } 129 130 #ifdef ENABLE_BIOS_POST_CODE_LOG 131 uint64_t usTimeOffset = tsUS - firstPostCodeUsSinceEpoch; 132 std::ostringstream hexCode; 133 hexCode << "0x" << std::setfill('0') << std::hex; 134 for (const auto& byte : std::get<0>(code)) 135 { 136 hexCode << std::setw(2) << static_cast<int>(byte); 137 } 138 139 std::ostringstream timeOffsetStr; 140 // Set Fixed-Point Notation 141 timeOffsetStr << std::fixed; 142 // Set precision to 4 digits 143 timeOffsetStr << std::setprecision(4); 144 // Add double to stream 145 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000; 146 147 phosphor::logging::log<phosphor::logging::level::INFO>( 148 "BIOS POST Code", 149 phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", 150 "OpenBMC.0.2.BIOSPOSTCode"), 151 phosphor::logging::entry( 152 "REDFISH_MESSAGE_ARGS=%d,%s,%s", currentBootCycleIndex, 153 timeOffsetStr.str().c_str(), hexCode.str().c_str())); 154 #endif 155 156 return; 157 } 158 159 fs::path PostCode::serialize(const fs::path& path) 160 { 161 try 162 { 163 std::ofstream osIdx(path / CurrentBootCycleIndexName, std::ios::binary); 164 cereal::BinaryOutputArchive idxArchive(osIdx); 165 idxArchive(currentBootCycleIndex); 166 167 uint16_t count = currentBootCycleCount(); 168 std::ofstream osCnt(path / CurrentBootCycleCountName, std::ios::binary); 169 cereal::BinaryOutputArchive cntArchive(osCnt); 170 cntArchive(count); 171 172 std::ofstream osPostCodes(path / std::to_string(currentBootCycleIndex)); 173 cereal::BinaryOutputArchive oarchivePostCodes(osPostCodes); 174 oarchivePostCodes(postCodes); 175 } 176 catch (const cereal::Exception& e) 177 { 178 phosphor::logging::log<phosphor::logging::level::ERR>(e.what()); 179 return ""; 180 } 181 catch (const fs::filesystem_error& e) 182 { 183 phosphor::logging::log<phosphor::logging::level::ERR>(e.what()); 184 return ""; 185 } 186 return path; 187 } 188 189 bool PostCode::deserialize(const fs::path& path, uint16_t& index) 190 { 191 try 192 { 193 if (fs::exists(path)) 194 { 195 std::ifstream is(path, std::ios::in | std::ios::binary); 196 cereal::BinaryInputArchive iarchive(is); 197 iarchive(index); 198 return true; 199 } 200 return false; 201 } 202 catch (const cereal::Exception& e) 203 { 204 phosphor::logging::log<phosphor::logging::level::ERR>(e.what()); 205 return false; 206 } 207 catch (const fs::filesystem_error& e) 208 { 209 return false; 210 } 211 212 return false; 213 } 214 215 bool PostCode::deserializePostCodes(const fs::path& path, 216 std::map<uint64_t, postcode_t>& codes) 217 { 218 try 219 { 220 if (fs::exists(path)) 221 { 222 std::ifstream is(path, std::ios::in | std::ios::binary); 223 cereal::BinaryInputArchive iarchive(is); 224 iarchive(codes); 225 return true; 226 } 227 return false; 228 } 229 catch (const cereal::Exception& e) 230 { 231 phosphor::logging::log<phosphor::logging::level::ERR>(e.what()); 232 return false; 233 } 234 catch (const fs::filesystem_error& e) 235 { 236 return false; 237 } 238 return false; 239 } 240 241 void PostCode::incrBootCycle() 242 { 243 if (currentBootCycleIndex >= maxBootCycleNum()) 244 { 245 currentBootCycleIndex = 1; 246 } 247 else 248 { 249 currentBootCycleIndex++; 250 } 251 currentBootCycleCount(std::min( 252 maxBootCycleNum(), static_cast<uint16_t>(currentBootCycleCount() + 1))); 253 } 254 255 uint16_t PostCode::getBootNum(const uint16_t index) const 256 { 257 // bootNum assumes the oldest archive is boot number 1 258 // and the current boot number equals bootCycleCount 259 // map bootNum back to bootIndex that was used to archive postcode 260 uint16_t bootNum = currentBootCycleIndex; 261 if (index > bootNum) // need to wrap around 262 { 263 bootNum = (maxBootCycleNum() + currentBootCycleIndex) - index + 1; 264 } 265 else 266 { 267 bootNum = currentBootCycleIndex - index + 1; 268 } 269 return bootNum; 270 } 271