1 #include "read_fru_data.hpp"
2 
3 #include "fruread.hpp"
4 #include "types.hpp"
5 #include "utils.hpp"
6 
7 #include <host-ipmid/ipmid-api.h>
8 
9 #include <map>
10 #include <phosphor-logging/elog-errors.hpp>
11 #include <sdbusplus/message/types.hpp>
12 #include <xyz/openbmc_project/Common/error.hpp>
13 
14 extern const FruMap frus;
15 namespace ipmi
16 {
17 namespace fru
18 {
19 
20 namespace variant_ns = sdbusplus::message::variant_ns;
21 
22 using namespace phosphor::logging;
23 using InternalFailure =
24     sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
25 std::unique_ptr<sdbusplus::bus::match_t> matchPtr(nullptr);
26 
27 static constexpr auto INV_INTF = "xyz.openbmc_project.Inventory.Manager";
28 static constexpr auto OBJ_PATH = "/xyz/openbmc_project/inventory";
29 static constexpr auto PROP_INTF = "org.freedesktop.DBus.Properties";
30 
31 namespace cache
32 {
33 // User initiate read FRU info area command followed by
34 // FRU read command. Also data is read in small chunks of
35 // the specified offset and count.
36 // Caching the data which will be invalidated when ever there
37 // is a change in FRU properties.
38 FRUAreaMap fruMap;
39 } // namespace cache
40 /**
41  * @brief Read all the property value's for the specified interface
42  *  from Inventory.
43  *
44  * @param[in] intf Interface
45  * @param[in] path Object path
46  * @return map of properties
47  */
48 ipmi::PropertyMap readAllProperties(const std::string& intf,
49                                     const std::string& path)
50 {
51     ipmi::PropertyMap properties;
52     sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
53     auto service = ipmi::getService(bus, INV_INTF, OBJ_PATH);
54     std::string objPath = OBJ_PATH + path;
55     auto method = bus.new_method_call(service.c_str(), objPath.c_str(),
56                                       PROP_INTF, "GetAll");
57     method.append(intf);
58     auto reply = bus.call(method);
59     if (reply.is_method_error())
60     {
61         // If property is not found simply return empty value
62         log<level::ERR>("Error in reading property values from inventory",
63                         entry("INTERFACE=%s", intf.c_str()),
64                         entry("PATH=%s", objPath.c_str()));
65         return properties;
66     }
67     reply.read(properties);
68     return properties;
69 }
70 
71 void processFruPropChange(sdbusplus::message::message& msg)
72 {
73     if (cache::fruMap.empty())
74     {
75         return;
76     }
77     std::string path = msg.get_path();
78     // trim the object base path, if found at the beginning
79     if (path.compare(0, strlen(OBJ_PATH), OBJ_PATH) == 0)
80     {
81         path.erase(0, strlen(OBJ_PATH));
82     }
83     for (auto& fru : frus)
84     {
85         bool found = false;
86         auto& instanceList = fru.second;
87         for (auto& instance : instanceList)
88         {
89             if (instance.path == path)
90             {
91                 found = true;
92                 break;
93             }
94         }
95         if (found)
96         {
97             auto& fruId = fru.first;
98 
99             cache::fruMap.erase(fruId);
100             break;
101         }
102     }
103 }
104 
105 // register for fru property change
106 int registerCallbackHandler()
107 {
108     if (matchPtr == nullptr)
109     {
110         using namespace sdbusplus::bus::match::rules;
111         sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
112         matchPtr = std::make_unique<sdbusplus::bus::match_t>(
113             bus,
114             path_namespace(OBJ_PATH) + type::signal() +
115                 member("PropertiesChanged") + interface(PROP_INTF),
116             std::bind(processFruPropChange, std::placeholders::_1));
117     }
118     return 0;
119 }
120 
121 /**
122  * @brief Read FRU property values from Inventory
123  *
124  * @param[in] fruNum  FRU id
125  * @return populate FRU Inventory data
126  */
127 FruInventoryData readDataFromInventory(const FRUId& fruNum)
128 {
129     auto iter = frus.find(fruNum);
130     if (iter == frus.end())
131     {
132         log<level::ERR>("Unsupported FRU ID ", entry("FRUID=%d", fruNum));
133         elog<InternalFailure>();
134     }
135 
136     FruInventoryData data;
137     auto& instanceList = iter->second;
138     for (auto& instance : instanceList)
139     {
140         for (auto& intf : instance.interfaces)
141         {
142             ipmi::PropertyMap allProp =
143                 readAllProperties(intf.first, instance.path);
144             for (auto& properties : intf.second)
145             {
146                 auto iter = allProp.find(properties.first);
147                 if (iter != allProp.end())
148                 {
149                     data[properties.second.section].emplace(
150                         properties.first,
151                         std::move(variant_ns::get<std::string>(
152                             allProp[properties.first])));
153                 }
154             }
155         }
156     }
157     return data;
158 }
159 
160 const FruAreaData& getFruAreaData(const FRUId& fruNum)
161 {
162     auto iter = cache::fruMap.find(fruNum);
163     if (iter != cache::fruMap.end())
164     {
165         return iter->second;
166     }
167     auto invData = readDataFromInventory(fruNum);
168 
169     // Build area info based on inventory data
170     FruAreaData newdata = buildFruAreaData(std::move(invData));
171     cache::fruMap.emplace(fruNum, std::move(newdata));
172     return cache::fruMap.at(fruNum);
173 }
174 } // namespace fru
175 } // namespace ipmi
176