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::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 
serialize(const fs::path & path)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 
deserialize(const fs::path & path,uint16_t & index)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 
deserializePostCodes(const fs::path & path,std::map<uint64_t,postcode_t> & codes)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 
incrBootCycle()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 
getBootNum(const uint16_t index) const255 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