blob: 24fb11dc5a68300fc72e35f3f97fa7fe1767680f [file] [log] [blame]
Jonathan Doman94c94bf2020-10-05 23:25:45 -07001// Copyright (c) 2020 Intel Corporation
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#include "speed_select.hpp"
16
17#include "cpuinfo.hpp"
Jonathan Doman703a1852020-11-11 13:04:02 -080018#include "cpuinfo_utils.hpp"
Jonathan Doman94c94bf2020-10-05 23:25:45 -070019
20#include <peci.h>
21
Jonathan Doman49ea8302022-05-26 14:29:46 -070022#include <boost/asio/error.hpp>
Jonathan Doman94c94bf2020-10-05 23:25:45 -070023#include <boost/asio/steady_timer.hpp>
Jonathan Doman703a1852020-11-11 13:04:02 -080024#include <xyz/openbmc_project/Common/Device/error.hpp>
Jonathan Doman94c94bf2020-10-05 23:25:45 -070025#include <xyz/openbmc_project/Common/error.hpp>
26#include <xyz/openbmc_project/Control/Processor/CurrentOperatingConfig/server.hpp>
27#include <xyz/openbmc_project/Inventory/Item/Cpu/OperatingConfig/server.hpp>
28
Jonathan Doman16a2ced2021-11-01 11:13:22 -070029#include <algorithm>
Jonathan Doman94c94bf2020-10-05 23:25:45 -070030#include <iostream>
31#include <memory>
Jonathan Doman16a2ced2021-11-01 11:13:22 -070032#include <stdexcept>
Jonathan Doman94c94bf2020-10-05 23:25:45 -070033#include <string>
34
35namespace cpu_info
36{
37namespace sst
38{
39
Jonathan Doman16a2ced2021-11-01 11:13:22 -070040// Specialize char to print the integer value instead of ascii. We basically
41// never want to print a single ascii char.
42std::ostream& operator<<(std::ostream& os, uint8_t value)
Jonathan Doman94c94bf2020-10-05 23:25:45 -070043{
Jonathan Doman16a2ced2021-11-01 11:13:22 -070044 return os << static_cast<int>(value);
Jonathan Doman94c94bf2020-10-05 23:25:45 -070045}
46
Jonathan Doman16a2ced2021-11-01 11:13:22 -070047bool checkPECIStatus(EPECIStatus libStatus, uint8_t completionCode)
Jonathan Doman94c94bf2020-10-05 23:25:45 -070048{
49 if (libStatus != PECI_CC_SUCCESS || completionCode != PECI_DEV_CC_SUCCESS)
50 {
51 std::cerr << "PECI command failed."
52 << " Driver Status = " << libStatus << ","
Jonathan Doman16a2ced2021-11-01 11:13:22 -070053 << " Completion Code = " << completionCode << '\n';
Jonathan Doman94c94bf2020-10-05 23:25:45 -070054 return false;
55 }
56 return true;
57}
58
Jonathan Doman49ea8302022-05-26 14:29:46 -070059std::vector<uint32_t> convertMaskToList(std::bitset<64> mask)
60{
61 std::vector<uint32_t> bitList;
62 for (size_t i = 0; i < mask.size(); ++i)
63 {
64 if (mask.test(i))
65 {
66 bitList.push_back(i);
67 }
68 }
69 return bitList;
70}
71
Jonathan Doman16a2ced2021-11-01 11:13:22 -070072static std::vector<BackendProvider>& getProviders()
Jonathan Doman94c94bf2020-10-05 23:25:45 -070073{
Jonathan Doman16a2ced2021-11-01 11:13:22 -070074 static auto* providers = new std::vector<BackendProvider>;
75 return *providers;
76}
Jonathan Doman94c94bf2020-10-05 23:25:45 -070077
Jonathan Doman16a2ced2021-11-01 11:13:22 -070078void registerBackend(BackendProvider providerFn)
79{
80 getProviders().push_back(providerFn);
81}
Jonathan Doman94c94bf2020-10-05 23:25:45 -070082
Jonathan Doman16a2ced2021-11-01 11:13:22 -070083std::unique_ptr<SSTInterface> getInstance(uint8_t address, CPUModel model)
84{
85 DEBUG_PRINT << "Searching for provider for " << address << ", model "
86 << std::hex << model << '\n';
87 for (const auto& provider : getProviders())
Jonathan Doman94c94bf2020-10-05 23:25:45 -070088 {
Jonathan Doman94c94bf2020-10-05 23:25:45 -070089 try
90 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -070091 auto interface = provider(address, model);
92 DEBUG_PRINT << "returned " << interface << '\n';
93 if (interface)
Jonathan Doman94c94bf2020-10-05 23:25:45 -070094 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -070095 return interface;
Jonathan Doman94c94bf2020-10-05 23:25:45 -070096 }
97 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -070098 catch (...)
Jonathan Doman94c94bf2020-10-05 23:25:45 -070099 {}
100 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700101 DEBUG_PRINT << "No supported backends found\n";
102 return nullptr;
103}
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700104
105using BaseCurrentOperatingConfig =
106 sdbusplus::server::object_t<sdbusplus::xyz::openbmc_project::Control::
107 Processor::server::CurrentOperatingConfig>;
108
109using BaseOperatingConfig =
110 sdbusplus::server::object_t<sdbusplus::xyz::openbmc_project::Inventory::
111 Item::Cpu::server::OperatingConfig>;
112
113class OperatingConfig : public BaseOperatingConfig
114{
115 public:
116 std::string path;
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700117 unsigned int level;
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700118
119 public:
120 using BaseOperatingConfig::BaseOperatingConfig;
Patrick Williams77b9c472022-07-22 19:26:57 -0500121 OperatingConfig(sdbusplus::bus_t& bus, unsigned int level_,
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700122 std::string path_) :
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700123 BaseOperatingConfig(bus, path_.c_str(), action::defer_emit),
124 path(std::move(path_)), level(level_)
125 {}
126};
127
128class CPUConfig : public BaseCurrentOperatingConfig
129{
130 private:
131 /** Objects describing all available SST configs - not modifiable. */
132 std::vector<std::unique_ptr<OperatingConfig>> availConfigs;
Patrick Williams77b9c472022-07-22 19:26:57 -0500133 sdbusplus::bus_t& bus;
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700134 const uint8_t peciAddress;
Jonathan Doman703a1852020-11-11 13:04:02 -0800135 const std::string path; ///< D-Bus path of CPU object
136 const CPUModel cpuModel;
Jonathan Doman703a1852020-11-11 13:04:02 -0800137
138 // Keep mutable copies of the properties so we can cache values that we
139 // retrieve in the getters. We don't want to throw an error on a D-Bus
140 // get-property call (extra error handling in clients), so by caching we can
141 // hide any temporary hiccup in PECI communication.
142 // These values can be changed by in-band software so we have to do a full
143 // PECI read on every get-property, and can't assume that values will change
144 // only when set-property is done.
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700145 mutable unsigned int currentLevel;
Jonathan Doman703a1852020-11-11 13:04:02 -0800146 mutable bool bfEnabled;
Jonathan Doman703a1852020-11-11 13:04:02 -0800147
148 /**
149 * Enforce common pre-conditions for D-Bus set property handlers.
150 */
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700151 void setPropertyCheckOrThrow(SSTInterface& sst)
Jonathan Doman703a1852020-11-11 13:04:02 -0800152 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700153 if (!sst.supportsControl())
Jonathan Doman703a1852020-11-11 13:04:02 -0800154 {
155 throw sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed();
156 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700157 if (hostState != HostState::postComplete || !sst.ready())
Jonathan Doman703a1852020-11-11 13:04:02 -0800158 {
159 throw sdbusplus::xyz::openbmc_project::Common::Error::Unavailable();
160 }
161 }
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700162
163 public:
Patrick Williams77b9c472022-07-22 19:26:57 -0500164 CPUConfig(sdbusplus::bus_t& bus_, uint8_t index, CPUModel model) :
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700165 BaseCurrentOperatingConfig(bus_, generatePath(index).c_str(),
166 action::defer_emit),
Jonathan Doman703a1852020-11-11 13:04:02 -0800167 bus(bus_), peciAddress(index + MIN_CLIENT_ADDR),
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700168 path(generatePath(index)), cpuModel(model), currentLevel(0),
169 bfEnabled(false)
Jonathan Doman703a1852020-11-11 13:04:02 -0800170 {}
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700171
172 //
173 // D-Bus Property Overrides
174 //
175
176 sdbusplus::message::object_path appliedConfig() const override
177 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700178 DEBUG_PRINT << "Reading AppliedConfig\n";
Jonathan Doman703a1852020-11-11 13:04:02 -0800179 // If CPU is powered off, return power-up default value of Level 0.
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700180 unsigned int level = 0;
Jonathan Doman703a1852020-11-11 13:04:02 -0800181 if (hostState != HostState::off)
182 {
183 // Otherwise, try to read current state
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700184 auto sst = getInstance(peciAddress, cpuModel);
185 if (!sst)
Jonathan Doman703a1852020-11-11 13:04:02 -0800186 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700187 std::cerr << __func__
188 << ": Failed to get SST provider instance\n";
Jonathan Doman703a1852020-11-11 13:04:02 -0800189 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700190 else
Jonathan Doman703a1852020-11-11 13:04:02 -0800191 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700192 try
193 {
194 currentLevel = sst->currentLevel();
195 }
196 catch (const PECIError& error)
197 {
198 std::cerr << "Failed to get SST-PP level: " << error.what()
199 << "\n";
200 }
Jonathan Doman703a1852020-11-11 13:04:02 -0800201 }
202 level = currentLevel;
203 }
204 return generateConfigPath(level);
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700205 }
206
207 bool baseSpeedPriorityEnabled() const override
208 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700209 DEBUG_PRINT << "Reading BaseSpeedPriorityEnabled\n";
Jonathan Doman703a1852020-11-11 13:04:02 -0800210 bool enabled = false;
211 if (hostState != HostState::off)
212 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700213 auto sst = getInstance(peciAddress, cpuModel);
214 if (!sst)
Jonathan Doman703a1852020-11-11 13:04:02 -0800215 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700216 std::cerr << __func__
217 << ": Failed to get SST provider instance\n";
Jonathan Doman703a1852020-11-11 13:04:02 -0800218 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700219 else
Jonathan Doman703a1852020-11-11 13:04:02 -0800220 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700221 try
222 {
223 bfEnabled = sst->bfEnabled(currentLevel);
224 }
225 catch (const PECIError& error)
226 {
227 std::cerr << "Failed to get SST-BF status: " << error.what()
228 << "\n";
229 }
Jonathan Doman703a1852020-11-11 13:04:02 -0800230 }
231 enabled = bfEnabled;
232 }
233 return enabled;
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700234 }
235
236 sdbusplus::message::object_path
Jonathan Doman703a1852020-11-11 13:04:02 -0800237 appliedConfig(sdbusplus::message::object_path value) override
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700238 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700239 DEBUG_PRINT << "Writing AppliedConfig\n";
Jonathan Doman703a1852020-11-11 13:04:02 -0800240 const OperatingConfig* newConfig = nullptr;
241 for (const auto& config : availConfigs)
242 {
243 if (config->path == value.str)
244 {
245 newConfig = config.get();
246 }
247 }
248
249 if (newConfig == nullptr)
250 {
251 throw sdbusplus::xyz::openbmc_project::Common::Error::
252 InvalidArgument();
253 }
254
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700255 auto sst = getInstance(peciAddress, cpuModel);
256 if (!sst)
257 {
258 std::cerr << __func__ << ": Failed to get SST provider instance\n";
259 return sdbusplus::message::object_path();
260 }
261 setPropertyCheckOrThrow(*sst);
Jonathan Doman703a1852020-11-11 13:04:02 -0800262 try
263 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700264 sst->setCurrentLevel(newConfig->level);
Jonathan Doman703a1852020-11-11 13:04:02 -0800265 currentLevel = newConfig->level;
266 }
267 catch (const PECIError& error)
268 {
269 std::cerr << "Failed to set new SST-PP level: " << error.what()
270 << "\n";
271 throw sdbusplus::xyz::openbmc_project::Common::Device::Error::
272 WriteFailure();
273 }
274
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700275 // return value not used
276 return sdbusplus::message::object_path();
277 }
278
Jonathan Doman06639632022-06-13 22:00:45 -0700279 bool baseSpeedPriorityEnabled(bool /* value */) override
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700280 {
Jonathan Doman06639632022-06-13 22:00:45 -0700281 DEBUG_PRINT << "Writing BaseSpeedPriorityEnabled not allowed\n";
282 throw sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed();
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700283 // return value not used
284 return false;
285 }
286
287 //
288 // Additions
289 //
290
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700291 OperatingConfig& newConfig(unsigned int level)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700292 {
293 availConfigs.emplace_back(std::make_unique<OperatingConfig>(
294 bus, level, generateConfigPath(level)));
295 return *availConfigs.back();
296 }
297
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700298 std::string generateConfigPath(unsigned int level) const
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700299 {
300 return path + "/config" + std::to_string(level);
301 }
302
303 /**
304 * Emit the interface added signals which were deferred. This is required
Jonathan Doman703a1852020-11-11 13:04:02 -0800305 * for ObjectMapper to pick up the objects, if we initially defered the
306 * signal emitting.
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700307 */
308 void finalize()
309 {
310 emit_added();
311 for (auto& config : availConfigs)
312 {
313 config->emit_added();
314 }
315 }
316
317 static std::string generatePath(int index)
318 {
Jonathan Doman0a385372021-03-08 17:04:13 -0800319 return cpuPath + std::to_string(index);
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700320 }
321};
322
323/**
324 * Retrieve the SST parameters for a single config and fill the values into the
325 * properties on the D-Bus interface.
326 *
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700327 * @param[in,out] sst Interface to SST backend.
328 * @param[in] level Config TDP level to retrieve.
329 * @param[out] config D-Bus interface to update.
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700330 */
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700331static void getSingleConfig(SSTInterface& sst, unsigned int level,
332 OperatingConfig& config)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700333{
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700334 config.powerLimit(sst.tdp(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700335
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700336 config.availableCoreCount(sst.coreCount(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700337
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700338 config.baseSpeed(sst.p1Freq(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700339
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700340 config.maxSpeed(sst.p0Freq(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700341
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700342 config.maxJunctionTemperature(sst.prochotTemp(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700343
344 // Construct BaseSpeedPrioritySettings
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700345 std::vector<std::tuple<uint32_t, std::vector<uint32_t>>> baseSpeeds;
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700346 if (sst.bfSupported(level))
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700347 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700348 std::vector<uint32_t> totalCoreList, loFreqCoreList, hiFreqCoreList;
349 totalCoreList = sst.enabledCoreList(level);
350 hiFreqCoreList = sst.bfHighPriorityCoreList(level);
351 std::set_difference(
352 totalCoreList.begin(), totalCoreList.end(), hiFreqCoreList.begin(),
353 hiFreqCoreList.end(),
354 std::inserter(loFreqCoreList, loFreqCoreList.begin()));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700355
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700356 baseSpeeds = {{sst.bfHighPriorityFreq(level), hiFreqCoreList},
357 {sst.bfLowPriorityFreq(level), loFreqCoreList}};
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700358 }
359 config.baseSpeedPrioritySettings(baseSpeeds);
360
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700361 config.turboProfile(sst.sseTurboProfile(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700362}
363
364/**
365 * Retrieve all SST configuration info for all discoverable CPUs, and publish
366 * the info on new D-Bus objects on the given bus connection.
367 *
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700368 * @param[in,out] ioc ASIO context.
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700369 * @param[in,out] conn D-Bus ASIO connection.
370 *
Jonathan Doman703a1852020-11-11 13:04:02 -0800371 * @return Whether discovery was successfully finished.
372 *
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700373 * @throw PECIError A PECI command failed on a CPU which had previously
374 * responded to a command.
375 */
Jonathan Doman49ea8302022-05-26 14:29:46 -0700376static bool discoverCPUsAndConfigs(boost::asio::io_context& ioc,
377 sdbusplus::asio::connection& conn)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700378{
Jonathan Doman49ea8302022-05-26 14:29:46 -0700379 // Persistent list - only populated after complete/successful discovery
380 static std::vector<std::unique_ptr<CPUConfig>> cpus;
381 cpus.clear();
382
383 // Temporary staging list. In case there is any failure, these temporary
384 // objects will get dropped to avoid presenting incomplete info until the
385 // next discovery attempt.
386 std::vector<std::unique_ptr<CPUConfig>> cpuList;
387
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700388 for (uint8_t i = MIN_CLIENT_ADDR; i <= MAX_CLIENT_ADDR; ++i)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700389 {
Jonathan Doman703a1852020-11-11 13:04:02 -0800390 // Let the event handler run any waiting tasks. If there is a lot of
391 // PECI contention, SST discovery could take a long time. This lets us
392 // get updates to hostState and handle any D-Bus requests.
393 ioc.poll();
394
395 if (hostState == HostState::off)
396 {
397 return false;
398 }
399
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700400 unsigned int cpuIndex = i - MIN_CLIENT_ADDR;
401 DEBUG_PRINT << "Discovering CPU " << cpuIndex << '\n';
402
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700403 // We could possibly check D-Bus for CPU presence and model, but PECI is
404 // 10x faster and so much simpler.
405 uint8_t cc, stepping;
406 CPUModel cpuModel;
407 EPECIStatus status = peci_GetCPUID(i, &cpuModel, &stepping, &cc);
Jonathan Doman703a1852020-11-11 13:04:02 -0800408 if (status == PECI_CC_TIMEOUT)
409 {
410 // Timing out indicates the CPU is present but PCS services not
411 // working yet. Try again later.
412 throw PECIError("Get CPUID timed out");
413 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700414 if (status == PECI_CC_CPU_NOT_PRESENT)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700415 {
416 continue;
417 }
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700418 if (status != PECI_CC_SUCCESS || cc != PECI_DEV_CC_SUCCESS)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700419 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700420 std::cerr << "GetCPUID returned status " << status
421 << ", cc = " << cc << '\n';
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700422 continue;
423 }
424
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700425 std::unique_ptr<SSTInterface> sst = getInstance(i, cpuModel);
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700426
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700427 if (!sst)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700428 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700429 // No supported backend for this CPU.
430 continue;
431 }
432
433 if (!sst->ready())
434 {
435 // Supported CPU but it can't be queried yet. Try again later.
436 std::cerr << "sst not ready yet\n";
437 return false;
438 }
439
440 if (!sst->ppEnabled())
441 {
442 // Supported CPU but the specific SKU doesn't support SST-PP.
443 std::cerr << "CPU doesn't support SST-PP\n";
444 continue;
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700445 }
446
447 // Create the per-CPU configuration object
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700448 cpuList.emplace_back(
449 std::make_unique<CPUConfig>(conn, cpuIndex, cpuModel));
450 CPUConfig& cpu = *cpuList.back();
451
452 bool foundCurrentLevel = false;
453
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700454 for (unsigned int level = 0; level <= sst->numLevels(); ++level)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700455 {
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700456 // levels 1 and 2 were legacy/deprecated, originally used for AVX
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700457 // license pre-granting. They may be reused for more levels in
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700458 // future generations. So we need to check for discontinuities.
459 if (!sst->levelSupported(level))
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700460 {
461 continue;
462 }
463
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700464 getSingleConfig(*sst, level, cpu.newConfig(level));
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700465
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700466 if (level == sst->currentLevel())
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700467 {
468 foundCurrentLevel = true;
469 }
470 }
471
472 if (!foundCurrentLevel)
473 {
474 // In case we didn't encounter a PECI error, but also didn't find
475 // the config which is supposedly applied, we won't be able to
476 // populate the CurrentOperatingConfig so we have to remove this CPU
477 // from consideration.
478 std::cerr << "CPU " << cpuIndex
479 << " claimed SST support but invalid configs\n";
480 cpuList.pop_back();
481 continue;
482 }
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700483 }
Jonathan Doman703a1852020-11-11 13:04:02 -0800484
Jonathan Doman49ea8302022-05-26 14:29:46 -0700485 cpuList.swap(cpus);
486 std::for_each(cpus.begin(), cpus.end(), [](auto& cpu) { cpu->finalize(); });
Jonathan Doman703a1852020-11-11 13:04:02 -0800487 return true;
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700488}
489
Jonathan Doman49ea8302022-05-26 14:29:46 -0700490/**
491 * Attempt discovery process, and if it fails, wait for 10 seconds to try again.
492 */
493static void discoverOrWait()
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700494{
Jonathan Doman49ea8302022-05-26 14:29:46 -0700495 static boost::asio::steady_timer peciRetryTimer(dbus::getIOContext());
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700496 static int peciErrorCount = 0;
Jonathan Doman703a1852020-11-11 13:04:02 -0800497 bool finished = false;
Jonathan Doman49ea8302022-05-26 14:29:46 -0700498
499 // This function may be called from hostStateHandler or by retrying itself.
500 // In case those overlap, cancel any outstanding retry timer.
501 peciRetryTimer.cancel();
502
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700503 try
504 {
Jonathan Doman703a1852020-11-11 13:04:02 -0800505 DEBUG_PRINT << "Starting discovery\n";
Jonathan Doman49ea8302022-05-26 14:29:46 -0700506 finished = discoverCPUsAndConfigs(dbus::getIOContext(),
507 *dbus::getConnection());
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700508 }
509 catch (const PECIError& err)
510 {
511 std::cerr << "PECI Error: " << err.what() << '\n';
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700512
513 // In case of repeated failure to finish discovery, turn off this
514 // feature altogether. Possible cause is that the CPU model does not
Jonathan Doman16a2ced2021-11-01 11:13:22 -0700515 // actually support the necessary commands.
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700516 if (++peciErrorCount >= 50)
517 {
518 std::cerr << "Aborting SST discovery\n";
519 return;
520 }
521
522 std::cerr << "Retrying SST discovery later\n";
523 }
524
Jonathan Doman703a1852020-11-11 13:04:02 -0800525 DEBUG_PRINT << "Finished discovery attempt: " << finished << '\n';
526
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700527 // Retry later if no CPUs were available, or there was a PECI error.
Jonathan Doman703a1852020-11-11 13:04:02 -0800528 if (!finished)
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700529 {
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700530 peciRetryTimer.expires_after(std::chrono::seconds(10));
Jonathan Doman49ea8302022-05-26 14:29:46 -0700531 peciRetryTimer.async_wait([](boost::system::error_code ec) {
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700532 if (ec)
533 {
Jonathan Doman49ea8302022-05-26 14:29:46 -0700534 if (ec != boost::asio::error::operation_aborted)
535 {
536 std::cerr << "SST PECI Retry Timer failed: " << ec << '\n';
537 }
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700538 return;
539 }
Jonathan Doman49ea8302022-05-26 14:29:46 -0700540 discoverOrWait();
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700541 });
542 }
543}
544
Jonathan Doman49ea8302022-05-26 14:29:46 -0700545static void hostStateHandler(HostState prevState, HostState)
546{
547 if (prevState == HostState::off)
548 {
549 // Start or re-start discovery any time the host moves out of the
550 // powered off state.
551 discoverOrWait();
552 }
553}
554
555void init()
556{
557 addHostStateCallback(hostStateHandler);
558}
559
Jonathan Doman94c94bf2020-10-05 23:25:45 -0700560} // namespace sst
561} // namespace cpu_info