xref: /openbmc/phosphor-objmgr/src/main.cpp (revision 2ec9157f) 
1 #include "associations.hpp"
2 #include "handler.hpp"
3 #include "processing.hpp"
4 #include "types.hpp"
5 
6 #include <tinyxml2.h>
7 
8 #include <boost/asio/io_context.hpp>
9 #include <boost/asio/signal_set.hpp>
10 #include <boost/container/flat_map.hpp>
11 #include <sdbusplus/asio/connection.hpp>
12 #include <sdbusplus/asio/object_server.hpp>
13 #include <xyz/openbmc_project/Common/error.hpp>
14 
15 #include <atomic>
16 #include <chrono>
17 #include <exception>
18 #include <iomanip>
19 #include <iostream>
20 #include <string>
21 #include <string_view>
22 #include <utility>
23 
24 AssociationMaps associationMaps;
25 
26 void updateOwners(sdbusplus::asio::connection* conn,
27                   boost::container::flat_map<std::string, std::string>& owners,
28                   const std::string& newObject)
29 {
30     if (newObject.starts_with(":"))
31     {
32         return;
33     }
34     conn->async_method_call(
35         [&, newObject](const boost::system::error_code ec,
36                        const std::string& nameOwner) {
37             if (ec)
38             {
39                 std::cerr << "Error getting owner of " << newObject << " : "
40                           << ec << "\n";
41                 return;
42             }
43             owners[nameOwner] = newObject;
44         },
45         "org.freedesktop.DBus", "/", "org.freedesktop.DBus", "GetNameOwner",
46         newObject);
47 }
48 
49 void sendIntrospectionCompleteSignal(sdbusplus::asio::connection* systemBus,
50                                      const std::string& processName)
51 {
52     // TODO(ed) This signal doesn't get exposed properly in the
53     // introspect right now.  Find out how to register signals in
54     // sdbusplus
55     sdbusplus::message_t m = systemBus->new_signal(
56         "/xyz/openbmc_project/object_mapper",
57         "xyz.openbmc_project.ObjectMapper.Private", "IntrospectionComplete");
58     m.append(processName);
59     m.signal_send();
60 }
61 
62 struct InProgressIntrospect
63 {
64     InProgressIntrospect() = delete;
65     InProgressIntrospect(const InProgressIntrospect&) = delete;
66     InProgressIntrospect(InProgressIntrospect&&) = delete;
67     InProgressIntrospect& operator=(const InProgressIntrospect&) = delete;
68     InProgressIntrospect& operator=(InProgressIntrospect&&) = delete;
69     InProgressIntrospect(
70         sdbusplus::asio::connection* systemBus, boost::asio::io_context& io,
71         const std::string& processName, AssociationMaps& am
72 #ifdef MAPPER_ENABLE_DEBUG
73         ,
74         std::shared_ptr<std::chrono::time_point<std::chrono::steady_clock>>
75             globalStartTime
76 #endif
77         ) :
78         systemBus(systemBus),
79         io(io), processName(processName), assocMaps(am)
80 #ifdef MAPPER_ENABLE_DEBUG
81         ,
82         globalStartTime(std::move(globalStartTime)),
83         processStartTime(std::chrono::steady_clock::now())
84 #endif
85     {}
86     ~InProgressIntrospect()
87     {
88         try
89         {
90             sendIntrospectionCompleteSignal(systemBus, processName);
91 #ifdef MAPPER_ENABLE_DEBUG
92             std::chrono::duration<float> diff =
93                 std::chrono::steady_clock::now() - processStartTime;
94             std::cout << std::setw(50) << processName << " scan took "
95                       << diff.count() << " seconds\n";
96 
97             // If we're the last outstanding caller globally, calculate the
98             // time it took
99             if (globalStartTime != nullptr && globalStartTime.use_count() == 1)
100             {
101                 diff = std::chrono::steady_clock::now() - *globalStartTime;
102                 std::cout << "Total scan took " << diff.count()
103                           << " seconds to complete\n";
104             }
105 #endif
106         }
107         catch (const std::exception& e)
108         {
109             std::cerr
110                 << "Terminating, unhandled exception while introspecting: "
111                 << e.what() << "\n";
112             std::terminate();
113         }
114         catch (...)
115         {
116             std::cerr
117                 << "Terminating, unhandled exception while introspecting\n";
118             std::terminate();
119         }
120     }
121     sdbusplus::asio::connection* systemBus;
122     boost::asio::io_context& io;
123     std::string processName;
124     AssociationMaps& assocMaps;
125 #ifdef MAPPER_ENABLE_DEBUG
126     std::shared_ptr<std::chrono::time_point<std::chrono::steady_clock>>
127         globalStartTime;
128     std::chrono::time_point<std::chrono::steady_clock> processStartTime;
129 #endif
130 };
131 
132 void doAssociations(boost::asio::io_context& io,
133                     sdbusplus::asio::connection* systemBus,
134                     InterfaceMapType& interfaceMap,
135                     sdbusplus::asio::object_server& objectServer,
136                     const std::string& processName, const std::string& path,
137                     int timeoutRetries = 0)
138 {
139     constexpr int maxTimeoutRetries = 3;
140     systemBus->async_method_call(
141         [&io, &objectServer, path, processName, &interfaceMap, systemBus,
142          timeoutRetries](
143             const boost::system::error_code ec,
144             const std::variant<std::vector<Association>>& variantAssociations) {
145             if (ec)
146             {
147                 if (ec.value() == boost::system::errc::timed_out &&
148                     timeoutRetries < maxTimeoutRetries)
149                 {
150                     doAssociations(io, systemBus, interfaceMap, objectServer,
151                                    processName, path, timeoutRetries + 1);
152                     return;
153                 }
154                 std::cerr << "Error getting associations from " << path << "\n";
155             }
156             std::vector<Association> associations =
157                 std::get<std::vector<Association>>(variantAssociations);
158             associationChanged(io, objectServer, associations, path,
159                                processName, interfaceMap, associationMaps);
160         },
161         processName, path, "org.freedesktop.DBus.Properties", "Get",
162         assocDefsInterface, assocDefsProperty);
163 }
164 
165 void doIntrospect(boost::asio::io_context& io,
166                   sdbusplus::asio::connection* systemBus,
167                   const std::shared_ptr<InProgressIntrospect>& transaction,
168                   InterfaceMapType& interfaceMap,
169                   sdbusplus::asio::object_server& objectServer,
170                   const std::string& path, int timeoutRetries = 0)
171 {
172     constexpr int maxTimeoutRetries = 3;
173     systemBus->async_method_call(
174         [&io, &interfaceMap, &objectServer, transaction, path, systemBus,
175          timeoutRetries](const boost::system::error_code ec,
176                          const std::string& introspectXml) {
177             if (ec)
178             {
179                 if (ec.value() == boost::system::errc::timed_out &&
180                     timeoutRetries < maxTimeoutRetries)
181                 {
182                     doIntrospect(io, systemBus, transaction, interfaceMap,
183                                  objectServer, path, timeoutRetries + 1);
184                     return;
185                 }
186                 std::cerr << "Introspect call failed with error: " << ec << ", "
187                           << ec.message()
188                           << " on process: " << transaction->processName
189                           << " path: " << path << "\n";
190                 return;
191             }
192 
193             tinyxml2::XMLDocument doc;
194 
195             tinyxml2::XMLError e = doc.Parse(introspectXml.c_str());
196             if (e != tinyxml2::XMLError::XML_SUCCESS)
197             {
198                 std::cerr << "XML parsing failed\n";
199                 return;
200             }
201 
202             tinyxml2::XMLNode* pRoot = doc.FirstChildElement("node");
203             if (pRoot == nullptr)
204             {
205                 std::cerr << "XML document did not contain any data\n";
206                 return;
207             }
208             auto& thisPathMap = interfaceMap[path];
209             tinyxml2::XMLElement* pElement =
210                 pRoot->FirstChildElement("interface");
211             while (pElement != nullptr)
212             {
213                 const char* ifaceName = pElement->Attribute("name");
214                 if (ifaceName == nullptr)
215                 {
216                     continue;
217                 }
218 
219                 thisPathMap[transaction->processName].emplace(ifaceName);
220 
221                 if (std::strcmp(ifaceName, assocDefsInterface) == 0)
222                 {
223                     doAssociations(io, systemBus, interfaceMap, objectServer,
224                                    transaction->processName, path);
225                 }
226 
227                 pElement = pElement->NextSiblingElement("interface");
228             }
229 
230             // Check if this new path has a pending association that can
231             // now be completed.
232             checkIfPendingAssociation(io, path, interfaceMap,
233                                       transaction->assocMaps, objectServer);
234 
235             pElement = pRoot->FirstChildElement("node");
236             while (pElement != nullptr)
237             {
238                 const char* childPath = pElement->Attribute("name");
239                 if (childPath != nullptr)
240                 {
241                     std::string parentPath(path);
242                     if (parentPath == "/")
243                     {
244                         parentPath.clear();
245                     }
246 
247                     doIntrospect(io, systemBus, transaction, interfaceMap,
248                                  objectServer, parentPath + "/" + childPath);
249                 }
250                 pElement = pElement->NextSiblingElement("node");
251             }
252         },
253         transaction->processName, path, "org.freedesktop.DBus.Introspectable",
254         "Introspect");
255 }
256 
257 void startNewIntrospect(
258     sdbusplus::asio::connection* systemBus, boost::asio::io_context& io,
259     InterfaceMapType& interfaceMap, const std::string& processName,
260     AssociationMaps& assocMaps,
261 #ifdef MAPPER_ENABLE_DEBUG
262     std::shared_ptr<std::chrono::time_point<std::chrono::steady_clock>>
263         globalStartTime,
264 #endif
265     sdbusplus::asio::object_server& objectServer)
266 {
267     if (needToIntrospect(processName))
268     {
269         std::shared_ptr<InProgressIntrospect> transaction =
270             std::make_shared<InProgressIntrospect>(systemBus, io, processName,
271                                                    assocMaps
272 #ifdef MAPPER_ENABLE_DEBUG
273                                                    ,
274                                                    globalStartTime
275 #endif
276             );
277 
278         doIntrospect(io, systemBus, transaction, interfaceMap, objectServer,
279                      "/");
280     }
281 }
282 
283 void doListNames(
284     boost::asio::io_context& io, InterfaceMapType& interfaceMap,
285     sdbusplus::asio::connection* systemBus,
286     boost::container::flat_map<std::string, std::string>& nameOwners,
287     AssociationMaps& assocMaps, sdbusplus::asio::object_server& objectServer)
288 {
289     systemBus->async_method_call(
290         [&io, &interfaceMap, &nameOwners, &objectServer, systemBus,
291          &assocMaps](const boost::system::error_code ec,
292                      std::vector<std::string> processNames) {
293             if (ec)
294             {
295                 std::cerr << "Error getting names: " << ec << "\n";
296                 std::exit(EXIT_FAILURE);
297                 return;
298             }
299             // Try to make startup consistent
300             std::sort(processNames.begin(), processNames.end());
301 #ifdef MAPPER_ENABLE_DEBUG
302             std::shared_ptr<std::chrono::time_point<std::chrono::steady_clock>>
303                 globalStartTime = std::make_shared<
304                     std::chrono::time_point<std::chrono::steady_clock>>(
305                     std::chrono::steady_clock::now());
306 #endif
307             for (const std::string& processName : processNames)
308             {
309                 if (needToIntrospect(processName))
310                 {
311                     startNewIntrospect(systemBus, io, interfaceMap, processName,
312                                        assocMaps,
313 #ifdef MAPPER_ENABLE_DEBUG
314                                        globalStartTime,
315 #endif
316                                        objectServer);
317                     updateOwners(systemBus, nameOwners, processName);
318                 }
319             }
320         },
321         "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus",
322         "ListNames");
323 }
324 
325 // Remove parents of the passed in path that:
326 // 1) Only have the 3 default interfaces on them
327 //    - Means D-Bus created these, not application code,
328 //      with the Properties, Introspectable, and Peer ifaces
329 // 2) Have no other child for this owner
330 void removeUnneededParents(const std::string& objectPath,
331                            const std::string& owner,
332                            InterfaceMapType& interfaceMap)
333 {
334     auto parent = objectPath;
335 
336     while (true)
337     {
338         auto pos = parent.find_last_of('/');
339         if ((pos == std::string::npos) || (pos == 0))
340         {
341             break;
342         }
343         parent = parent.substr(0, pos);
344 
345         auto parentIt = interfaceMap.find(parent);
346         if (parentIt == interfaceMap.end())
347         {
348             break;
349         }
350 
351         auto ifacesIt = parentIt->second.find(owner);
352         if (ifacesIt == parentIt->second.end())
353         {
354             break;
355         }
356 
357         if (ifacesIt->second.size() != 3)
358         {
359             break;
360         }
361 
362         auto childPath = parent + '/';
363 
364         // Remove this parent if there isn't a remaining child on this owner
365         auto child = std::find_if(
366             interfaceMap.begin(), interfaceMap.end(),
367             [&owner, &childPath](const auto& entry) {
368                 return entry.first.starts_with(childPath) &&
369                        (entry.second.find(owner) != entry.second.end());
370             });
371 
372         if (child == interfaceMap.end())
373         {
374             parentIt->second.erase(ifacesIt);
375             if (parentIt->second.empty())
376             {
377                 interfaceMap.erase(parentIt);
378             }
379         }
380         else
381         {
382             break;
383         }
384     }
385 }
386 
387 int main()
388 {
389     boost::asio::io_context io;
390     std::shared_ptr<sdbusplus::asio::connection> systemBus =
391         std::make_shared<sdbusplus::asio::connection>(io);
392 
393     sdbusplus::asio::object_server server(systemBus);
394 
395     // Construct a signal set registered for process termination.
396     boost::asio::signal_set signals(io, SIGINT, SIGTERM);
397     signals.async_wait(
398         [&io](const boost::system::error_code&, int) { io.stop(); });
399 
400     InterfaceMapType interfaceMap;
401     boost::container::flat_map<std::string, std::string> nameOwners;
402 
403     auto nameChangeHandler = [&interfaceMap, &io, &nameOwners, &server,
404                               systemBus](sdbusplus::message_t& message) {
405         std::string name;     // well-known
406         std::string oldOwner; // unique-name
407         std::string newOwner; // unique-name
408 
409         message.read(name, oldOwner, newOwner);
410 
411         if (name.starts_with(':'))
412         {
413             // We should do nothing with unique-name connections.
414             return;
415         }
416 
417         if (!oldOwner.empty())
418         {
419             processNameChangeDelete(io, nameOwners, name, oldOwner,
420                                     interfaceMap, associationMaps, server);
421         }
422 
423         if (!newOwner.empty())
424         {
425 #ifdef MAPPER_ENABLE_DEBUG
426             auto transaction = std::make_shared<
427                 std::chrono::time_point<std::chrono::steady_clock>>(
428                 std::chrono::steady_clock::now());
429 #endif
430             // New daemon added
431             if (needToIntrospect(name))
432             {
433                 nameOwners[newOwner] = name;
434                 startNewIntrospect(systemBus.get(), io, interfaceMap, name,
435                                    associationMaps,
436 #ifdef MAPPER_ENABLE_DEBUG
437                                    transaction,
438 #endif
439                                    server);
440             }
441         }
442     };
443 
444     sdbusplus::bus::match_t nameOwnerChanged(
445         static_cast<sdbusplus::bus_t&>(*systemBus),
446         sdbusplus::bus::match::rules::nameOwnerChanged(),
447         std::move(nameChangeHandler));
448 
449     auto interfacesAddedHandler = [&io, &interfaceMap, &nameOwners,
450                                    &server](sdbusplus::message_t& message) {
451         sdbusplus::message::object_path objPath;
452         InterfacesAdded interfacesAdded;
453         message.read(objPath, interfacesAdded);
454         std::string wellKnown;
455         if (!getWellKnown(nameOwners, message.get_sender(), wellKnown))
456         {
457             return; // only introspect well-known
458         }
459         if (needToIntrospect(wellKnown))
460         {
461             processInterfaceAdded(io, interfaceMap, objPath, interfacesAdded,
462                                   wellKnown, associationMaps, server);
463         }
464     };
465 
466     sdbusplus::bus::match_t interfacesAdded(
467         static_cast<sdbusplus::bus_t&>(*systemBus),
468         sdbusplus::bus::match::rules::interfacesAdded(),
469         std::move(interfacesAddedHandler));
470 
471     auto interfacesRemovedHandler = [&io, &interfaceMap, &nameOwners,
472                                      &server](sdbusplus::message_t& message) {
473         sdbusplus::message::object_path objPath;
474         std::vector<std::string> interfacesRemoved;
475         message.read(objPath, interfacesRemoved);
476         auto connectionMap = interfaceMap.find(objPath.str);
477         if (connectionMap == interfaceMap.end())
478         {
479             return;
480         }
481 
482         std::string sender;
483         if (!getWellKnown(nameOwners, message.get_sender(), sender))
484         {
485             return;
486         }
487         for (const std::string& interface : interfacesRemoved)
488         {
489             auto interfaceSet = connectionMap->second.find(sender);
490             if (interfaceSet == connectionMap->second.end())
491             {
492                 continue;
493             }
494 
495             if (interface == assocDefsInterface)
496             {
497                 removeAssociation(io, objPath.str, sender, server,
498                                   associationMaps);
499             }
500 
501             interfaceSet->second.erase(interface);
502 
503             if (interfaceSet->second.empty())
504             {
505                 // If this was the last interface on this connection,
506                 // erase the connection
507                 connectionMap->second.erase(interfaceSet);
508 
509                 // Instead of checking if every single path is the endpoint
510                 // of an association that needs to be moved to pending,
511                 // only check when the only remaining owner of this path is
512                 // ourself, which would be because we still own the
513                 // association path.
514                 if ((connectionMap->second.size() == 1) &&
515                     (connectionMap->second.begin()->first ==
516                      "xyz.openbmc_project.ObjectMapper"))
517                 {
518                     // Remove the 2 association D-Bus paths and move the
519                     // association to pending.
520                     moveAssociationToPending(io, objPath.str, associationMaps,
521                                              server);
522                 }
523             }
524         }
525         // If this was the last connection on this object path,
526         // erase the object path
527         if (connectionMap->second.empty())
528         {
529             interfaceMap.erase(connectionMap);
530         }
531 
532         removeUnneededParents(objPath.str, sender, interfaceMap);
533     };
534 
535     sdbusplus::bus::match_t interfacesRemoved(
536         static_cast<sdbusplus::bus_t&>(*systemBus),
537         sdbusplus::bus::match::rules::interfacesRemoved(),
538         std::move(interfacesRemovedHandler));
539 
540     auto associationChangedHandler = [&io, &server, &nameOwners, &interfaceMap](
541                                          sdbusplus::message_t& message) {
542         std::string objectName;
543         boost::container::flat_map<std::string,
544                                    std::variant<std::vector<Association>>>
545             values;
546         message.read(objectName, values);
547         auto prop = values.find(assocDefsProperty);
548         if (prop != values.end())
549         {
550             std::vector<Association> associations =
551                 std::get<std::vector<Association>>(prop->second);
552 
553             std::string wellKnown;
554             if (!getWellKnown(nameOwners, message.get_sender(), wellKnown))
555             {
556                 return;
557             }
558             associationChanged(io, server, associations, message.get_path(),
559                                wellKnown, interfaceMap, associationMaps);
560         }
561     };
562     sdbusplus::bus::match_t assocChangedMatch(
563         static_cast<sdbusplus::bus_t&>(*systemBus),
564         sdbusplus::bus::match::rules::interface(
565             "org.freedesktop.DBus.Properties") +
566             sdbusplus::bus::match::rules::member("PropertiesChanged") +
567             sdbusplus::bus::match::rules::argN(0, assocDefsInterface),
568         std::move(associationChangedHandler));
569 
570     std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
571         server.add_interface("/xyz/openbmc_project/object_mapper",
572                              "xyz.openbmc_project.ObjectMapper");
573 
574     iface->register_method(
575         "GetAncestors", [&interfaceMap](std::string& reqPath,
576                                         std::vector<std::string>& interfaces) {
577             return getAncestors(interfaceMap, reqPath, interfaces);
578         });
579 
580     iface->register_method(
581         "GetObject", [&interfaceMap](const std::string& path,
582                                      std::vector<std::string>& interfaces) {
583             return getObject(interfaceMap, path, interfaces);
584         });
585 
586     iface->register_method(
587         "GetSubTree", [&interfaceMap](std::string& reqPath, int32_t depth,
588                                       std::vector<std::string>& interfaces) {
589             return getSubTree(interfaceMap, reqPath, depth, interfaces);
590         });
591 
592     iface->register_method(
593         "GetSubTreePaths",
594         [&interfaceMap](std::string& reqPath, int32_t depth,
595                         std::vector<std::string>& interfaces) {
596             return getSubTreePaths(interfaceMap, reqPath, depth, interfaces);
597         });
598 
599     iface->register_method(
600         "GetAssociatedSubTree",
601         [&interfaceMap](const sdbusplus::message::object_path& associationPath,
602                         const sdbusplus::message::object_path& reqPath,
603                         int32_t depth, std::vector<std::string>& interfaces) {
604             return getAssociatedSubTree(interfaceMap, associationMaps,
605                                         associationPath, reqPath, depth,
606                                         interfaces);
607         });
608 
609     iface->register_method(
610         "GetAssociatedSubTreePaths",
611         [&interfaceMap](const sdbusplus::message::object_path& associationPath,
612                         const sdbusplus::message::object_path& reqPath,
613                         int32_t depth, std::vector<std::string>& interfaces) {
614             return getAssociatedSubTreePaths(interfaceMap, associationMaps,
615                                              associationPath, reqPath, depth,
616                                              interfaces);
617         });
618 
619     iface->initialize();
620 
621     io.post([&]() {
622         doListNames(io, interfaceMap, systemBus.get(), nameOwners,
623                     associationMaps, server);
624     });
625 
626     systemBus->request_name("xyz.openbmc_project.ObjectMapper");
627 
628     io.run();
629 }
630