1 #include "settings.hpp" 2 3 #include "xyz/openbmc_project/Common/error.hpp" 4 5 #include <phosphor-logging/elog-errors.hpp> 6 #include <phosphor-logging/log.hpp> 7 #include <sdbusplus/exception.hpp> 8 9 namespace settings 10 { 11 12 using namespace phosphor::logging; 13 using namespace sdbusplus::xyz::openbmc_project::Common::Error; 14 using sdbusplus::exception::SdBusError; 15 16 constexpr auto mapperService = "xyz.openbmc_project.ObjectMapper"; 17 constexpr auto mapperPath = "/xyz/openbmc_project/object_mapper"; 18 constexpr auto mapperIntf = "xyz.openbmc_project.ObjectMapper"; 19 20 Objects::Objects(sdbusplus::bus::bus& bus) : bus(bus) 21 { 22 std::vector<std::string> settingsIntfs = {autoRebootIntf, powerRestoreIntf}; 23 auto depth = 0; 24 25 auto mapperCall = bus.new_method_call(mapperService, mapperPath, mapperIntf, 26 "GetSubTree"); 27 mapperCall.append(root); 28 mapperCall.append(depth); 29 mapperCall.append(settingsIntfs); 30 31 using Interfaces = std::vector<Interface>; 32 using MapperResponse = std::map<Path, std::map<Service, Interfaces>>; 33 MapperResponse result; 34 35 try 36 { 37 auto response = bus.call(mapperCall); 38 39 response.read(result); 40 if (result.empty()) 41 { 42 log<level::ERR>("Invalid response from mapper"); 43 elog<InternalFailure>(); 44 } 45 } 46 catch (const SdBusError& e) 47 { 48 log<level::ERR>("Error in mapper GetSubTree", 49 entry("ERROR=%s", e.what())); 50 elog<InternalFailure>(); 51 } 52 53 for (const auto& iter : result) 54 { 55 const Path& path = iter.first; 56 57 for (const auto& serviceIter : iter.second) 58 { 59 for (const auto& interface : serviceIter.second) 60 { 61 if (autoRebootIntf == interface) 62 { 63 /* There are two implementations of the AutoReboot 64 * Interface. A persistent user setting and a one-time 65 * setting which is only valid for one boot of the system. 66 * The one-time setting will have "one_time" in its 67 * object path. 68 */ 69 if (path.find("one_time") != std::string::npos) 70 { 71 autoRebootOneTime = path; 72 } 73 else 74 { 75 autoReboot = path; 76 } 77 } 78 else if (powerRestoreIntf == interface) 79 { 80 /* There are two implementations of the PowerRestorePolicy 81 * Interface. A persistent user setting and a one-time 82 * setting which is only valid for one boot of the system. 83 * The one-time setting will have "one_time" in its 84 * object path. 85 */ 86 if (path.find("one_time") != std::string::npos) 87 { 88 powerRestorePolicyOneTime = path; 89 } 90 else 91 { 92 powerRestorePolicy = path; 93 } 94 } 95 } 96 } 97 } 98 } 99 100 Service Objects::service(const Path& path, const Interface& interface) const 101 { 102 using Interfaces = std::vector<Interface>; 103 auto mapperCall = 104 bus.new_method_call(mapperService, mapperPath, mapperIntf, "GetObject"); 105 mapperCall.append(path); 106 mapperCall.append(Interfaces({interface})); 107 108 std::map<Service, Interfaces> result; 109 110 try 111 { 112 auto response = bus.call(mapperCall); 113 response.read(result); 114 } 115 catch (const SdBusError& e) 116 { 117 log<level::ERR>("Error in mapper GetObject", 118 entry("ERROR=%s", e.what())); 119 elog<InternalFailure>(); 120 } 121 122 if (result.empty()) 123 { 124 log<level::ERR>("Invalid response from mapper"); 125 elog<InternalFailure>(); 126 } 127 128 return result.begin()->first; 129 } 130 131 } // namespace settings 132