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
deleteAll()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
getPostCodes(uint16_t index)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>
getPostCodesWithTimeStamp(uint16_t index)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
savePostCodes(postcode_t code)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::setw(2)
123 << std::hex << std::get<0>(code);
124 postCodeDisplayFile.close();
125 }
126
127 #ifdef ENABLE_BIOS_POST_CODE_LOG
128 uint64_t usTimeOffset = tsUS - firstPostCodeUsSinceEpoch;
129 std::ostringstream hexCode;
130 hexCode << "0x" << std::setfill('0') << std::setw(2) << std::hex
131 << std::get<0>(code);
132
133 std::ostringstream timeOffsetStr;
134 // Set Fixed-Point Notation
135 timeOffsetStr << std::fixed;
136 // Set precision to 4 digits
137 timeOffsetStr << std::setprecision(4);
138 // Add double to stream
139 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000;
140
141 phosphor::logging::log<phosphor::logging::level::INFO>(
142 "BIOS POST Code",
143 phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
144 "OpenBMC.0.2.BIOSPOSTCode"),
145 phosphor::logging::entry(
146 "REDFISH_MESSAGE_ARGS=%d,%s,%s", currentBootCycleIndex,
147 timeOffsetStr.str().c_str(), hexCode.str().c_str()));
148 #endif
149
150 return;
151 }
152
serialize(const fs::path & path)153 fs::path PostCode::serialize(const fs::path& path)
154 {
155 try
156 {
157 std::ofstream osIdx(path / CurrentBootCycleIndexName, std::ios::binary);
158 cereal::BinaryOutputArchive idxArchive(osIdx);
159 idxArchive(currentBootCycleIndex);
160
161 uint16_t count = currentBootCycleCount();
162 std::ofstream osCnt(path / CurrentBootCycleCountName, std::ios::binary);
163 cereal::BinaryOutputArchive cntArchive(osCnt);
164 cntArchive(count);
165
166 std::ofstream osPostCodes(path / std::to_string(currentBootCycleIndex));
167 cereal::BinaryOutputArchive oarchivePostCodes(osPostCodes);
168 oarchivePostCodes(postCodes);
169 }
170 catch (const cereal::Exception& e)
171 {
172 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
173 return "";
174 }
175 catch (const fs::filesystem_error& e)
176 {
177 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
178 return "";
179 }
180 return path;
181 }
182
deserialize(const fs::path & path,uint16_t & index)183 bool PostCode::deserialize(const fs::path& path, uint16_t& index)
184 {
185 try
186 {
187 if (fs::exists(path))
188 {
189 std::ifstream is(path, std::ios::in | std::ios::binary);
190 cereal::BinaryInputArchive iarchive(is);
191 iarchive(index);
192 return true;
193 }
194 return false;
195 }
196 catch (const cereal::Exception& e)
197 {
198 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
199 return false;
200 }
201 catch (const fs::filesystem_error& e)
202 {
203 return false;
204 }
205
206 return false;
207 }
208
deserializePostCodes(const fs::path & path,std::map<uint64_t,postcode_t> & codes)209 bool PostCode::deserializePostCodes(const fs::path& path,
210 std::map<uint64_t, postcode_t>& codes)
211 {
212 try
213 {
214 if (fs::exists(path))
215 {
216 std::ifstream is(path, std::ios::in | std::ios::binary);
217 cereal::BinaryInputArchive iarchive(is);
218 iarchive(codes);
219 return true;
220 }
221 return false;
222 }
223 catch (const cereal::Exception& e)
224 {
225 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
226 return false;
227 }
228 catch (const fs::filesystem_error& e)
229 {
230 return false;
231 }
232 return false;
233 }
234
incrBootCycle()235 void PostCode::incrBootCycle()
236 {
237 if (currentBootCycleIndex >= maxBootCycleNum())
238 {
239 currentBootCycleIndex = 1;
240 }
241 else
242 {
243 currentBootCycleIndex++;
244 }
245 currentBootCycleCount(std::min(
246 maxBootCycleNum(), static_cast<uint16_t>(currentBootCycleCount() + 1)));
247 }
248
getBootNum(const uint16_t index) const249 uint16_t PostCode::getBootNum(const uint16_t index) const
250 {
251 // bootNum assumes the oldest archive is boot number 1
252 // and the current boot number equals bootCycleCount
253 // map bootNum back to bootIndex that was used to archive postcode
254 uint16_t bootNum = currentBootCycleIndex;
255 if (index > bootNum) // need to wrap around
256 {
257 bootNum = (maxBootCycleNum() + currentBootCycleIndex) - index + 1;
258 }
259 else
260 {
261 bootNum = currentBootCycleIndex - index + 1;
262 }
263 return bootNum;
264 }
265