1 /** 2 * Copyright © 2022 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 "event.hpp" 20 #include "group.hpp" 21 #include "json_config.hpp" 22 #include "power_state.hpp" 23 #include "profile.hpp" 24 #include "sdbusplus.hpp" 25 #include "utils/flight_recorder.hpp" 26 #include "zone.hpp" 27 28 #include <nlohmann/json.hpp> 29 #include <phosphor-logging/log.hpp> 30 #include <sdbusplus/bus.hpp> 31 #include <sdbusplus/server/manager.hpp> 32 #include <sdeventplus/event.hpp> 33 #include <sdeventplus/source/event.hpp> 34 #include <sdeventplus/utility/timer.hpp> 35 36 #include <chrono> 37 #include <format> 38 #include <map> 39 #include <memory> 40 #include <optional> 41 #include <tuple> 42 #include <utility> 43 #include <vector> 44 45 namespace phosphor::fan::control::json 46 { 47 48 using json = nlohmann::json; 49 using namespace phosphor::logging; 50 51 /* Application name to be appended to the path for loading a JSON config file */ 52 constexpr auto confAppName = "control"; 53 54 /* Type of timers supported */ 55 enum class TimerType 56 { 57 oneshot, 58 repeating, 59 }; 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 = 96 std::function<bool(sdbusplus::message_t&, 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 explicit 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 dumpDebugData(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 = fan::JsonConfig::getConfFile( 207 confAppName, T::confFileName, isOptional); 208 209 if (!confFile.empty()) 210 { 211 FlightRecorder::instance().log( 212 "main", std::format("Loading configuration from {}", 213 confFile.string())); 214 for (const auto& entry : fan::JsonConfig::load(confFile)) 215 { 216 if (entry.contains("profiles")) 217 { 218 std::vector<std::string> profiles; 219 for (const auto& profile : entry["profiles"]) 220 { 221 profiles.emplace_back( 222 profile.template get<std::string>()); 223 } 224 // Do not create the object if its profiles are not in the 225 // list of active profiles 226 if (!profiles.empty() && 227 !std::any_of(profiles.begin(), profiles.end(), 228 [](const auto& name) { 229 return std::find(getActiveProfiles().begin(), 230 getActiveProfiles().end(), 231 name) != getActiveProfiles().end(); 232 })) 233 { 234 continue; 235 } 236 } 237 auto obj = std::make_unique<T>(entry, 238 std::forward<Args>(args)...); 239 config.emplace( 240 std::make_pair(obj->getName(), obj->getProfiles()), 241 std::move(obj)); 242 } 243 log<level::INFO>( 244 std::format("Configuration({}) loaded successfully", 245 T::confFileName) 246 .c_str()); 247 FlightRecorder::instance().log( 248 "main", std::format("Configuration({}) loaded successfully", 249 T::confFileName)); 250 } 251 return config; 252 } 253 254 /** 255 * @brief Check if the given input configuration key matches with another 256 * configuration key that it's to be included in 257 * 258 * @param[in] input - Config key to be included in another config object 259 * @param[in] comp - Config key of the config object to compare with 260 * 261 * @return Whether the configuration object should be included 262 */ 263 static bool inConfig(const configKey& input, const configKey& comp); 264 265 /** 266 * @brief Check if the given path and inteface is owned by a dbus service 267 * 268 * @param[in] path - Dbus object path 269 * @param[in] intf - Dbus object interface 270 * 271 * @return - Whether the service has an owner for the given object path and 272 * interface 273 */ 274 static bool hasOwner(const std::string& path, const std::string& intf); 275 276 /** 277 * @brief Sets the dbus service owner state for all entries in the _servTree 278 * cache and removes associated objects from the _objects cache 279 * 280 * @param[in] serv - Dbus service name 281 * @param[in] hasOwner - Dbus service owner state 282 */ 283 void setOwner(const std::string& serv, bool hasOwner); 284 285 /** 286 * @brief Sets the dbus service owner state of a given object 287 * 288 * @param[in] path - Dbus object path 289 * @param[in] serv - Dbus service name 290 * @param[in] intf - Dbus object interface 291 * @param[in] isOwned - Dbus service owner state 292 */ 293 void setOwner(const std::string& path, const std::string& serv, 294 const std::string& intf, bool isOwned); 295 296 /** 297 * @brief Add a set of services for a path and interface by retrieving all 298 * the path subtrees to the given depth from root for the interface 299 * 300 * @param[in] intf - Interface to add services for 301 * @param[in] depth - Depth of tree traversal from root path 302 * 303 * @throws - DBusMethodError 304 * Throws a DBusMethodError when the `getSubTree` method call fails 305 */ 306 static void addServices(const std::string& intf, int32_t depth); 307 308 /** 309 * @brief Get the service for a given path and interface from cached 310 * dataset and attempt to add all the services for the given path/interface 311 * when it's not found 312 * 313 * @param[in] path - Path to get service for 314 * @param[in] intf - Interface to get service for 315 * 316 * @return - The now cached service name 317 * 318 * @throws - DBusMethodError 319 * Ripples up a DBusMethodError exception from calling addServices 320 */ 321 static const std::string& getService(const std::string& path, 322 const std::string& intf); 323 324 /** 325 * @brief Get all the object paths for a given service and interface from 326 * the cached dataset and try to add all the services for the given 327 * interface when no paths are found and then attempt to get all the object 328 * paths again 329 * 330 * @param[in] serv - Service name to get paths for 331 * @param[in] intf - Interface to get paths for 332 * 333 * @return The cached object paths 334 */ 335 std::vector<std::string> getPaths(const std::string& serv, 336 const std::string& intf); 337 338 /** 339 * @brief Add objects to the cached dataset by first using 340 * `getManagedObjects` for the same service providing the given path and 341 * interface or just add the single object of the given path, interface, and 342 * property if that fails. 343 * 344 * @param[in] path - Dbus object's path 345 * @param[in] intf - Dbus object's interface 346 * @param[in] prop - Dbus object's property 347 * 348 * @throws - DBusMethodError 349 * Throws a DBusMethodError when the the service is failed to be found or 350 * when the `getManagedObjects` method call fails 351 */ 352 void addObjects(const std::string& path, const std::string& intf, 353 const std::string& prop) 354 { 355 addObjects(path, intf, prop, std::string{}); 356 } 357 358 /** 359 * @copydoc Manager::addObjects() 360 * 361 * If the service is known, then it can be used to add all objects 362 * in that service with the interface passed in to the cache instead of 363 * having to look it up. This is done so objects can still be 364 * added even when the D-Bus path passed in doesn't exist so it 365 * can't be used to get a service name. 366 * 367 * @param[in] path - Dbus object's path 368 * @param[in] intf - Dbus object's interface 369 * @param[in] prop - Dbus object's property 370 * @param[in] serviceName - The service of the path/intf/prop if known 371 */ 372 void addObjects(const std::string& path, const std::string& intf, 373 const std::string& prop, const std::string& serviceName); 374 375 /** 376 * @brief Get an object's property value 377 * 378 * @param[in] path - Dbus object's path 379 * @param[in] intf - Dbus object's interface 380 * @param[in] prop - Dbus object's property 381 */ 382 const std::optional<PropertyVariantType> 383 getProperty(const std::string& path, const std::string& intf, 384 const std::string& prop); 385 386 /** 387 * @brief Set/update an object's property value 388 * 389 * @param[in] path - Dbus object's path 390 * @param[in] intf - Dbus object's interface 391 * @param[in] prop - Dbus object's property 392 * @param[in] value - Dbus object's property value 393 */ 394 void setProperty(const std::string& path, const std::string& intf, 395 const std::string& prop, PropertyVariantType value); 396 397 /** 398 * @brief Remove an object's interface 399 * 400 * @param[in] path - Dbus object's path 401 * @param[in] intf - Dbus object's interface 402 */ 403 inline void removeInterface(const std::string& path, 404 const std::string& intf) 405 { 406 auto itPath = _objects.find(path); 407 if (itPath != std::end(_objects)) 408 { 409 _objects[path].erase(intf); 410 } 411 } 412 413 /** 414 * @brief Get the object's property value as a variant 415 * 416 * @param[in] path - Path of the object containing the property 417 * @param[in] intf - Interface name containing the property 418 * @param[in] prop - Name of property 419 * 420 * @return - The object's property value as a variant 421 */ 422 static inline auto getObjValueVariant(const std::string& path, 423 const std::string& intf, 424 const std::string& prop) 425 { 426 return _objects.at(path).at(intf).at(prop); 427 }; 428 429 /** 430 * @brief Add a dbus timer 431 * 432 * @param[in] type - Type of timer 433 * @param[in] interval - Timer interval in microseconds 434 * @param[in] pkg - Packaged data for when timer expires 435 */ 436 void addTimer(const TimerType type, 437 const std::chrono::microseconds interval, 438 std::unique_ptr<TimerPkg> pkg); 439 440 /** 441 * @brief Callback when a timer expires 442 * 443 * @param[in] data - Data to be used when the timer expired 444 */ 445 void timerExpired(TimerData& data); 446 447 /** 448 * @brief Get the signal data for a given match string 449 * 450 * @param[in] sigMatch - Signal match string 451 * 452 * @return - Reference to the signal data for the given match string 453 */ 454 std::vector<SignalData>& getSignal(const std::string& sigMatch) 455 { 456 return _signals[sigMatch]; 457 } 458 459 /** 460 * @brief Handle receiving signals 461 * 462 * @param[in] msg - Signal message containing the signal's data 463 * @param[in] pkgs - Signal packages associated to the signal being handled 464 */ 465 void handleSignal(sdbusplus::message_t& msg, 466 const std::vector<SignalPkg>* pkgs); 467 468 /** 469 * @brief Get the sdbusplus bus object 470 */ 471 inline auto& getBus() 472 { 473 return _bus; 474 } 475 476 /** 477 * @brief Is the power state on 478 * 479 * @return Current power state of the system 480 */ 481 inline bool isPowerOn() const 482 { 483 return _powerState->isPowerOn(); 484 } 485 486 /** 487 * @brief Load all the fan control JSON configuration files 488 * 489 * This is where all the fan control JSON configuration files are parsed and 490 * loaded into their associated objects. Anything that needs to be done when 491 * the Manager object is constructed or handling a SIGHUP to reload the 492 * configurations needs to be done here. 493 */ 494 void load(); 495 496 /** 497 * @brief Sets a value in the parameter map. 498 * 499 * If it's a std::nullopt, it will be deleted instead. 500 * 501 * @param[in] name - The parameter name 502 * @param[in] value - The parameter value 503 */ 504 static void setParameter(const std::string& name, 505 const std::optional<PropertyVariantType>& value) 506 { 507 if (value) 508 { 509 auto it = _parameters.find(name); 510 auto changed = (it == _parameters.end()) || 511 ((it != _parameters.end()) && it->second != *value); 512 _parameters[name] = *value; 513 514 if (changed) 515 { 516 runParameterActions(name); 517 } 518 } 519 else 520 { 521 size_t deleted = _parameters.erase(name); 522 523 if (deleted) 524 { 525 runParameterActions(name); 526 } 527 } 528 } 529 530 /** 531 * @brief Returns a value from the parameter map 532 * 533 * @param[in] name - The parameter name 534 * 535 * @return The parameter value, or std::nullopt if not found 536 */ 537 static std::optional<PropertyVariantType> 538 getParameter(const std::string& name) 539 { 540 auto it = _parameters.find(name); 541 if (it != _parameters.end()) 542 { 543 return it->second; 544 } 545 546 return std::nullopt; 547 } 548 549 /** 550 * @brief Runs the actions registered to a parameter 551 * trigger with this name. 552 * 553 * @param[in] name - The parameter name 554 */ 555 static void runParameterActions(const std::string& name); 556 557 /** 558 * @brief Adds a parameter trigger 559 * 560 * @param[in] name - The parameter name 561 * @param[in] actions - The actions to run on the trigger 562 */ 563 static void 564 addParameterTrigger(const std::string& name, 565 std::vector<std::unique_ptr<ActionBase>>& actions); 566 567 /* The name of the dump file */ 568 static const std::string dumpFile; 569 570 private: 571 /** 572 * @brief Helper to detect when a property's double contains a NaN 573 * (not-a-number) value. 574 * 575 * @param[in] value - The property to test 576 */ 577 static bool PropertyContainsNan(const PropertyVariantType& value) 578 { 579 return (std::holds_alternative<double>(value) && 580 std::isnan(std::get<double>(value))); 581 } 582 583 /** 584 * @brief Insert managed objects into cache, but filter out properties 585 * containing unwanted NaN (not-a-number) values and properties that 586 * are on D-Bus paths that aren't in an existing Group object. 587 * 588 * @param[in] ref - The map of ManagedObjects to insert into cache 589 */ 590 void insertFilteredObjects(ManagedObjects& ref); 591 592 /* The sdbusplus bus object to use */ 593 sdbusplus::bus_t& _bus; 594 595 /* The sdeventplus even loop to use */ 596 sdeventplus::Event _event; 597 598 /* The sdbusplus manager object to set the ObjectManager interface */ 599 sdbusplus::server::manager_t _mgr; 600 601 /* Whether loading the config files is allowed or not */ 602 bool _loadAllowed; 603 604 /* The system's power state determination object */ 605 std::unique_ptr<PowerState> _powerState; 606 607 /* List of profiles configured */ 608 std::map<configKey, std::unique_ptr<Profile>> _profiles; 609 610 /* List of active profiles */ 611 static std::vector<std::string> _activeProfiles; 612 613 /* Subtree map of paths to services of interfaces(with ownership state) */ 614 static std::map< 615 std::string, 616 std::map<std::string, std::pair<bool, std::vector<std::string>>>> 617 _servTree; 618 619 /* Object map of paths to interfaces of properties and their values */ 620 static std::map< 621 std::string, 622 std::map<std::string, std::map<std::string, PropertyVariantType>>> 623 _objects; 624 625 /* List of timers and their data to be processed when expired */ 626 std::vector<std::pair<std::unique_ptr<TimerData>, Timer>> _timers; 627 628 /* Map of signal match strings to a list of signal handler data */ 629 std::unordered_map<std::string, std::vector<SignalData>> _signals; 630 631 /* List of zones configured */ 632 std::map<configKey, std::unique_ptr<Zone>> _zones; 633 634 /* List of events configured */ 635 std::map<configKey, std::unique_ptr<Event>> _events; 636 637 /** 638 * @brief A map of parameter names and values that are something 639 * other than just D-Bus property values that other actions 640 * can set and use. 641 */ 642 static std::unordered_map<std::string, PropertyVariantType> _parameters; 643 644 /** 645 * @brief Map of parameter names to the actions to run when their 646 * values change. 647 */ 648 static std::unordered_map<std::string, TriggerActions> _parameterTriggers; 649 650 /** 651 * @brief Callback for power state changes 652 * 653 * @param[in] powerStateOn - Whether the power state is on or not 654 * 655 * Callback function bound to the PowerState object instance to handle each 656 * time the power state changes. 657 */ 658 void powerStateChanged(bool powerStateOn); 659 660 /** 661 * @brief Find the service name for a given path and interface from the 662 * cached dataset 663 * 664 * @param[in] path - Path to get service for 665 * @param[in] intf - Interface to get service for 666 * 667 * @return - The cached service name 668 */ 669 static const std::string& findService(const std::string& path, 670 const std::string& intf); 671 672 /** 673 * @brief Find all the paths for a given service and interface from the 674 * cached dataset 675 * 676 * @param[in] serv - Service name to get paths for 677 * @param[in] intf - Interface to get paths for 678 * 679 * @return - The cached object paths 680 */ 681 std::vector<std::string> findPaths(const std::string& serv, 682 const std::string& intf); 683 684 /** 685 * @brief Parse and set the configured profiles from the profiles JSON file 686 * 687 * Retrieves the optional profiles JSON configuration file, parses it, and 688 * creates a list of configured profiles available to the other 689 * configuration files. These profiles can be used to remove or include 690 * entries within the other configuration files. 691 */ 692 void setProfiles(); 693 694 /** 695 * @brief Dump the _objects, _servTree, and _parameters maps to JSON 696 * 697 * @param[out] data - The JSON that will be filled in 698 */ 699 void dumpCache(json& data); 700 701 /** 702 * @brief Add a list of groups to the cache dataset. 703 * 704 * @param[in] groups - The groups to add 705 */ 706 void addGroups(const std::vector<Group>& groups); 707 }; 708 709 } // namespace phosphor::fan::control::json 710