1 /** 2 * Copyright © 2020 IBM 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 #pragma once 17 18 #include "action.hpp" 19 #include "config_base.hpp" 20 #include "event.hpp" 21 #include "group.hpp" 22 #include "json_config.hpp" 23 #include "power_state.hpp" 24 #include "profile.hpp" 25 #include "sdbusplus.hpp" 26 #include "zone.hpp" 27 28 #include <fmt/format.h> 29 30 #include <nlohmann/json.hpp> 31 #include <phosphor-logging/log.hpp> 32 #include <sdbusplus/bus.hpp> 33 #include <sdbusplus/server/manager.hpp> 34 #include <sdeventplus/event.hpp> 35 #include <sdeventplus/source/event.hpp> 36 #include <sdeventplus/utility/timer.hpp> 37 38 #include <chrono> 39 #include <map> 40 #include <memory> 41 #include <optional> 42 #include <tuple> 43 #include <utility> 44 #include <vector> 45 46 namespace phosphor::fan::control::json 47 { 48 49 using json = nlohmann::json; 50 using namespace phosphor::logging; 51 52 /* Application name to be appended to the path for loading a JSON config file */ 53 constexpr auto confAppName = "control"; 54 55 /* Type of timers supported */ 56 enum class TimerType 57 { 58 oneshot, 59 repeating, 60 }; 61 /** 62 * Package of data required when a timer expires 63 * Tuple constructed of: 64 * std::string = Timer package unique identifier 65 * std::vector<std::unique_ptr<ActionBase>> = List of pointers to actions 66 * that run when the timer expires 67 * const std::vector<Group> = List of groups 68 * bool = If groups should be preloaded before actions are run 69 */ 70 using TimerPkg = 71 std::tuple<std::string, std::vector<std::unique_ptr<ActionBase>>&, 72 const std::vector<Group>&, bool>; 73 /** 74 * Data associated with a running timer that's used when it expires 75 * Pair constructed of: 76 * TimerType = Type of timer to manage expired timer instances 77 * TimerPkg = Package of data required when the timer expires 78 */ 79 using TimerData = std::pair<TimerType, TimerPkg>; 80 /* Dbus event timer */ 81 using Timer = sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>; 82 83 /* Dbus signal object */ 84 constexpr auto Path = 0; 85 constexpr auto Intf = 1; 86 constexpr auto Prop = 2; 87 using SignalObject = std::tuple<std::string, std::string, std::string>; 88 /* Dbus signal actions */ 89 using TriggerActions = 90 std::vector<std::reference_wrapper<std::unique_ptr<ActionBase>>>; 91 /** 92 * Signal handler function that handles parsing a signal's message for a 93 * particular signal object and stores the results in the manager 94 */ 95 using SignalHandler = std::function<bool(sdbusplus::message::message&, 96 const SignalObject&, Manager&)>; 97 /** 98 * Package of data required when a signal is received 99 * Tuple constructed of: 100 * SignalHandler = Signal handler function 101 * SignalObject = Dbus signal object 102 * TriggerActions = List of actions that are run when the signal is received 103 */ 104 using SignalPkg = std::tuple<SignalHandler, SignalObject, TriggerActions>; 105 /** 106 * Data associated to a subscribed signal 107 * Tuple constructed of: 108 * std::unique_ptr<std::vector<SignalPkg>> = 109 * Pointer to list of the signal's packages 110 * std::unique_ptr<sdbusplus::bus::match_t> = 111 * Pointer to match holding the subscription to a signal 112 */ 113 using SignalData = std::tuple<std::unique_ptr<std::vector<SignalPkg>>, 114 std::unique_ptr<sdbusplus::bus::match_t>>; 115 116 /** 117 * Package of data from a D-Bus call to get managed objects 118 * Tuple constructed of: 119 * std::map<Path, // D-Bus Path 120 * std::map<Intf, // D-Bus Interface 121 * std::map<Property, // D-Bus Property 122 * std::variant>>> // Variant value of that property 123 */ 124 using Path_v = sdbusplus::message::object_path; 125 using Intf_v = std::string; 126 using Prop_v = std::string; 127 using ManagedObjects = 128 std::map<Path_v, std::map<Intf_v, std::map<Prop_v, PropertyVariantType>>>; 129 130 /** 131 * Actions to run when a parameter trigger runs. 132 */ 133 using ParamTriggerData = std::vector< 134 std::reference_wrapper<const std::vector<std::unique_ptr<ActionBase>>>>; 135 136 /** 137 * @class Manager - Represents the fan control manager's configuration 138 * 139 * A fan control manager configuration is optional, therefore the "manager.json" 140 * file is also optional. The manager configuration is used to populate 141 * fan control's manager parameters which are used in how the application 142 * operates, not in how the fans are controlled. 143 * 144 * When no manager configuration exists, the fan control application starts, 145 * processes any configured events and then begins controlling fans according 146 * to those events. 147 */ 148 class Manager 149 { 150 public: 151 Manager() = delete; 152 Manager(const Manager&) = delete; 153 Manager(Manager&&) = delete; 154 Manager& operator=(const Manager&) = delete; 155 Manager& operator=(Manager&&) = delete; 156 ~Manager() = default; 157 158 /** 159 * Constructor 160 * Parses and populates the fan control manager attributes from a json file 161 * 162 * @param[in] event - sdeventplus event loop 163 */ 164 Manager(const sdeventplus::Event& event); 165 166 /** 167 * @brief Callback function to handle receiving a HUP signal to reload the 168 * JSON configurations. 169 */ 170 void sighupHandler(sdeventplus::source::Signal&, 171 const struct signalfd_siginfo*); 172 173 /** 174 * @brief Callback function to handle receiving a USR1 signal to dump 175 * the flight recorder. 176 */ 177 void sigUsr1Handler(sdeventplus::source::Signal&, 178 const struct signalfd_siginfo*); 179 180 /** 181 * @brief Get the active profiles of the system where an empty list 182 * represents that only configuration entries without a profile defined will 183 * be loaded. 184 * 185 * @return - The list of active profiles 186 */ 187 static const std::vector<std::string>& getActiveProfiles(); 188 189 /** 190 * @brief Load the configuration of a given JSON class object based on the 191 * active profiles 192 * 193 * @param[in] isOptional - JSON configuration file is optional or not 194 * @param[in] args - Arguments to be forwarded to each instance of `T` 195 * (*Note that a sdbusplus bus object is required as the first argument) 196 * 197 * @return Map of configuration entries 198 * Map of configuration keys to their corresponding configuration object 199 */ 200 template <typename T, typename... Args> 201 static std::map<configKey, std::unique_ptr<T>> getConfig(bool isOptional, 202 Args&&... args) 203 { 204 std::map<configKey, std::unique_ptr<T>> config; 205 206 auto confFile = 207 fan::JsonConfig::getConfFile(util::SDBusPlus::getBus(), confAppName, 208 T::confFileName, isOptional); 209 if (!confFile.empty()) 210 { 211 for (const auto& entry : fan::JsonConfig::load(confFile)) 212 { 213 if (entry.contains("profiles")) 214 { 215 std::vector<std::string> profiles; 216 for (const auto& profile : entry["profiles"]) 217 { 218 profiles.emplace_back( 219 profile.template get<std::string>()); 220 } 221 // Do not create the object if its profiles are not in the 222 // list of active profiles 223 if (!profiles.empty() && 224 !std::any_of(profiles.begin(), profiles.end(), 225 [](const auto& name) { 226 return std::find( 227 getActiveProfiles().begin(), 228 getActiveProfiles().end(), 229 name) != 230 getActiveProfiles().end(); 231 })) 232 { 233 continue; 234 } 235 } 236 auto obj = 237 std::make_unique<T>(entry, std::forward<Args>(args)...); 238 config.emplace( 239 std::make_pair(obj->getName(), obj->getProfiles()), 240 std::move(obj)); 241 } 242 log<level::INFO>( 243 fmt::format("Configuration({}) loaded successfully", 244 T::confFileName) 245 .c_str()); 246 } 247 return config; 248 } 249 250 /** 251 * @brief Check if the given input configuration key matches with another 252 * configuration key that it's to be included in 253 * 254 * @param[in] input - Config key to be included in another config object 255 * @param[in] comp - Config key of the config object to compare with 256 * 257 * @return Whether the configuration object should be included 258 */ 259 static bool inConfig(const configKey& input, const configKey& comp); 260 261 /** 262 * @brief Check if the given path and inteface is owned by a dbus service 263 * 264 * @param[in] path - Dbus object path 265 * @param[in] intf - Dbus object interface 266 * 267 * @return - Whether the service has an owner for the given object path and 268 * interface 269 */ 270 static bool hasOwner(const std::string& path, const std::string& intf); 271 272 /** 273 * @brief Sets the dbus service owner state of a given object 274 * 275 * @param[in] path - Dbus object path 276 * @param[in] serv - Dbus service name 277 * @param[in] intf - Dbus object interface 278 * @param[in] isOwned - Dbus service owner state 279 */ 280 void setOwner(const std::string& path, const std::string& serv, 281 const std::string& intf, bool isOwned); 282 283 /** 284 * @brief Add a set of services for a path and interface by retrieving all 285 * the path subtrees to the given depth from root for the interface 286 * 287 * @param[in] intf - Interface to add services for 288 * @param[in] depth - Depth of tree traversal from root path 289 * 290 * @throws - DBusMethodError 291 * Throws a DBusMethodError when the `getSubTree` method call fails 292 */ 293 static void addServices(const std::string& intf, int32_t depth); 294 295 /** 296 * @brief Get the service for a given path and interface from cached 297 * dataset and attempt to add all the services for the given path/interface 298 * when it's not found 299 * 300 * @param[in] path - Path to get service for 301 * @param[in] intf - Interface to get service for 302 * 303 * @return - The now cached service name 304 * 305 * @throws - DBusMethodError 306 * Ripples up a DBusMethodError exception from calling addServices 307 */ 308 static const std::string& getService(const std::string& path, 309 const std::string& intf); 310 311 /** 312 * @brief Get all the object paths for a given service and interface from 313 * the cached dataset and try to add all the services for the given 314 * interface when no paths are found and then attempt to get all the object 315 * paths again 316 * 317 * @param[in] serv - Service name to get paths for 318 * @param[in] intf - Interface to get paths for 319 * 320 * @return The cached object paths 321 */ 322 std::vector<std::string> getPaths(const std::string& serv, 323 const std::string& intf); 324 325 /** 326 * @brief Add objects to the cached dataset by first using 327 * `getManagedObjects` for the same service providing the given path and 328 * interface or just add the single object of the given path, interface, and 329 * property if that fails. 330 * 331 * @param[in] path - Dbus object's path 332 * @param[in] intf - Dbus object's interface 333 * @param[in] prop - Dbus object's property 334 * 335 * @throws - DBusMethodError 336 * Throws a DBusMethodError when the the service is failed to be found or 337 * when the `getManagedObjects` method call fails 338 */ 339 void addObjects(const std::string& path, const std::string& intf, 340 const std::string& prop); 341 342 /** 343 * @brief Get an object's property value 344 * 345 * @param[in] path - Dbus object's path 346 * @param[in] intf - Dbus object's interface 347 * @param[in] prop - Dbus object's property 348 */ 349 const std::optional<PropertyVariantType> 350 getProperty(const std::string& path, const std::string& intf, 351 const std::string& prop); 352 353 /** 354 * @brief Set/update an object's property value 355 * 356 * @param[in] path - Dbus object's path 357 * @param[in] intf - Dbus object's interface 358 * @param[in] prop - Dbus object's property 359 * @param[in] value - Dbus object's property value 360 */ 361 void setProperty(const std::string& path, const std::string& intf, 362 const std::string& prop, PropertyVariantType value); 363 364 /** 365 * @brief Remove an object's interface 366 * 367 * @param[in] path - Dbus object's path 368 * @param[in] intf - Dbus object's interface 369 */ 370 inline void removeInterface(const std::string& path, 371 const std::string& intf) 372 { 373 auto itPath = _objects.find(path); 374 if (itPath != std::end(_objects)) 375 { 376 _objects[path].erase(intf); 377 } 378 } 379 380 /** 381 * @brief Get the object's property value as a variant 382 * 383 * @param[in] path - Path of the object containing the property 384 * @param[in] intf - Interface name containing the property 385 * @param[in] prop - Name of property 386 * 387 * @return - The object's property value as a variant 388 */ 389 static inline auto getObjValueVariant(const std::string& path, 390 const std::string& intf, 391 const std::string& prop) 392 { 393 return _objects.at(path).at(intf).at(prop); 394 }; 395 396 /** 397 * @brief Add a dbus timer 398 * 399 * @param[in] type - Type of timer 400 * @param[in] interval - Timer interval in microseconds 401 * @param[in] pkg - Packaged data for when timer expires 402 */ 403 void addTimer(const TimerType type, 404 const std::chrono::microseconds interval, 405 std::unique_ptr<TimerPkg> pkg); 406 407 /** 408 * @brief Callback when a timer expires 409 * 410 * @param[in] data - Data to be used when the timer expired 411 */ 412 void timerExpired(TimerData& data); 413 414 /** 415 * @brief Get the signal data for a given match string 416 * 417 * @param[in] sigMatch - Signal match string 418 * 419 * @return - Reference to the signal data for the given match string 420 */ 421 std::vector<SignalData>& getSignal(const std::string& sigMatch) 422 { 423 return _signals[sigMatch]; 424 } 425 426 /** 427 * @brief Handle receiving signals 428 * 429 * @param[in] msg - Signal message containing the signal's data 430 * @param[in] pkgs - Signal packages associated to the signal being handled 431 */ 432 void handleSignal(sdbusplus::message::message& msg, 433 const std::vector<SignalPkg>* pkgs); 434 435 /** 436 * @brief Get the sdbusplus bus object 437 */ 438 inline auto& getBus() 439 { 440 return _bus; 441 } 442 443 /** 444 * @brief Is the power state on 445 * 446 * @return Current power state of the system 447 */ 448 inline bool isPowerOn() const 449 { 450 return _powerState->isPowerOn(); 451 } 452 453 /** 454 * @brief Load all the fan control JSON configuration files 455 * 456 * This is where all the fan control JSON configuration files are parsed and 457 * loaded into their associated objects. Anything that needs to be done when 458 * the Manager object is constructed or handling a SIGHUP to reload the 459 * configurations needs to be done here. 460 */ 461 void load(); 462 463 /** 464 * @brief Sets a value in the parameter map. 465 * 466 * @param[in] name - The parameter name 467 * @param[in] value - The parameter value 468 */ 469 static void setParameter(const std::string& name, 470 const PropertyVariantType& value) 471 { 472 auto it = _parameters.find(name); 473 auto changed = (it == _parameters.end()) || 474 ((it != _parameters.end()) && it->second != value); 475 _parameters[name] = value; 476 477 if (changed) 478 { 479 runParameterActions(name); 480 } 481 } 482 483 /** 484 * @brief Returns a value from the parameter map 485 * 486 * @param[in] name - The parameter name 487 * 488 * @return The parameter value, or std::nullopt if not found 489 */ 490 static std::optional<PropertyVariantType> 491 getParameter(const std::string& name) 492 { 493 auto it = _parameters.find(name); 494 if (it != _parameters.end()) 495 { 496 return it->second; 497 } 498 499 return std::nullopt; 500 } 501 502 /** 503 * @brief Deletes a parameter from the parameter map 504 * 505 * @param[in] name - The parameter name 506 */ 507 static void deleteParameter(const std::string& name) 508 { 509 size_t deleted = _parameters.erase(name); 510 511 if (deleted) 512 { 513 runParameterActions(name); 514 } 515 } 516 517 /** 518 * @brief Runs the actions registered to a parameter 519 * trigger with this name. 520 * 521 * @param[in] name - The parameter name 522 */ 523 static void runParameterActions(const std::string& name); 524 525 /** 526 * @brief Adds a parameter trigger 527 * 528 * @param[in] name - The parameter name 529 * @param[in] actions - The actions to run on the trigger 530 */ 531 static void 532 addParameterTrigger(const std::string& name, 533 std::vector<std::unique_ptr<ActionBase>>& actions); 534 535 /* The name of the dump file */ 536 static const std::string dumpFile; 537 538 private: 539 /** 540 * @brief Helper to detect when a property's double contains a NaN 541 * (not-a-number) value. 542 * 543 * @param[in] value - The property to test 544 */ 545 static bool PropertyContainsNan(const PropertyVariantType& value) 546 { 547 return (std::holds_alternative<double>(value) && 548 std::isnan(std::get<double>(value))); 549 } 550 551 /** 552 * @brief Insert managed objects into cache, but filter out properties 553 * containing unwanted NaN (not-a-number) values. 554 * 555 * @param[in] ref - The map of ManagedObjects to insert into cache 556 */ 557 void insertFilteredObjects(ManagedObjects& ref); 558 559 /* The sdbusplus bus object to use */ 560 sdbusplus::bus::bus& _bus; 561 562 /* The sdeventplus even loop to use */ 563 sdeventplus::Event _event; 564 565 /* The sdbusplus manager object to set the ObjectManager interface */ 566 sdbusplus::server::manager::manager _mgr; 567 568 /* Whether loading the config files is allowed or not */ 569 bool _loadAllowed; 570 571 /* The system's power state determination object */ 572 std::unique_ptr<PowerState> _powerState; 573 574 /* List of profiles configured */ 575 std::map<configKey, std::unique_ptr<Profile>> _profiles; 576 577 /* List of active profiles */ 578 static std::vector<std::string> _activeProfiles; 579 580 /* Subtree map of paths to services of interfaces(with ownership state) */ 581 static std::map< 582 std::string, 583 std::map<std::string, std::pair<bool, std::vector<std::string>>>> 584 _servTree; 585 586 /* Object map of paths to interfaces of properties and their values */ 587 static std::map< 588 std::string, 589 std::map<std::string, std::map<std::string, PropertyVariantType>>> 590 _objects; 591 592 /* List of timers and their data to be processed when expired */ 593 std::vector<std::pair<std::unique_ptr<TimerData>, Timer>> _timers; 594 595 /* Map of signal match strings to a list of signal handler data */ 596 std::unordered_map<std::string, std::vector<SignalData>> _signals; 597 598 /* List of zones configured */ 599 std::map<configKey, std::unique_ptr<Zone>> _zones; 600 601 /* List of events configured */ 602 std::map<configKey, std::unique_ptr<Event>> _events; 603 604 /* The sdeventplus wrapper around sd_event_add_defer to dump debug 605 * data from the event loop after the USR1 signal. */ 606 std::unique_ptr<sdeventplus::source::Defer> debugDumpEventSource; 607 608 /** 609 * @brief A map of parameter names and values that are something 610 * other than just D-Bus property values that other actions 611 * can set and use. 612 */ 613 static std::unordered_map<std::string, PropertyVariantType> _parameters; 614 615 /** 616 * @brief Map of parameter names to the actions to run when their 617 * values change. 618 */ 619 static std::unordered_map<std::string, TriggerActions> _parameterTriggers; 620 621 /** 622 * @brief Callback for power state changes 623 * 624 * @param[in] powerStateOn - Whether the power state is on or not 625 * 626 * Callback function bound to the PowerState object instance to handle each 627 * time the power state changes. 628 */ 629 void powerStateChanged(bool powerStateOn); 630 631 /** 632 * @brief Find the service name for a given path and interface from the 633 * cached dataset 634 * 635 * @param[in] path - Path to get service for 636 * @param[in] intf - Interface to get service for 637 * 638 * @return - The cached service name 639 */ 640 static const std::string& findService(const std::string& path, 641 const std::string& intf); 642 643 /** 644 * @brief Find all the paths for a given service and interface from the 645 * cached dataset 646 * 647 * @param[in] serv - Service name to get paths for 648 * @param[in] intf - Interface to get paths for 649 * 650 * @return - The cached object paths 651 */ 652 std::vector<std::string> findPaths(const std::string& serv, 653 const std::string& intf); 654 655 /** 656 * @brief Parse and set the configured profiles from the profiles JSON file 657 * 658 * Retrieves the optional profiles JSON configuration file, parses it, and 659 * creates a list of configured profiles available to the other 660 * configuration files. These profiles can be used to remove or include 661 * entries within the other configuration files. 662 */ 663 void setProfiles(); 664 665 /** 666 * @brief Callback from debugDumpEventSource to dump debug data 667 */ 668 void dumpDebugData(sdeventplus::source::EventBase&); 669 670 /** 671 * @brief Dump the _objects, _servTree, and _parameters maps to JSON 672 * 673 * @param[out] data - The JSON that will be filled in 674 */ 675 void dumpCache(json& data); 676 677 /** 678 * @brief Add a group to the cache dataset. 679 * 680 * @param[in] group - The group to add 681 */ 682 void addGroup(const Group& group); 683 }; 684 685 } // namespace phosphor::fan::control::json 686