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