dbus-top/analyzer.cpp - openbmc/openbmc-tools - Gitiles

 // Copyright 2021 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "analyzer.hpp"
 #include "histogram.hpp"
 #include "main.hpp"
 #include "sensorhelper.hpp"
 #include "views.hpp"
 #include "xmlparse.hpp"

 #include <unistd.h>
 #include <atomic>
 #include <filesystem>
 #include <fstream>
 #include <functional>
 #include <iostream>
 #include <sstream>
 #include <string>

 extern SensorSnapshot* g_sensor_snapshot;
 extern DBusConnectionSnapshot* g_connection_snapshot;
 extern sd_bus* g_bus;
 extern SensorDetailView* g_sensor_detail_view;

 static std::unordered_map<uint64_t, uint64_t>
     in_flight_methodcalls; // serial => microseconds
 uint64_t Microseconds()
 {
     long us;  // usec
     time_t s; // Seconds
     struct timespec spec;
     clock_gettime(CLOCK_REALTIME, &spec);
     s = spec.tv_sec;
     us = round(spec.tv_nsec / 1000); // Convert nanoseconds to milliseconds
     if (us > 999999)
     {
         s++;
         us = 0;
     }
     return s * 1000000 + us;
 }

 int g_update_interval_millises = 2000;
 int GetSummaryIntervalInMillises()
 {
     return g_update_interval_millises;
 }

 bool DBusTopSortFieldIsNumeric(DBusTopSortField field)
 {
     switch (field)
     {
         case kSender:
         case kDestination:
         case kInterface:
         case kPath:
         case kMember:
         case kSenderCMD:
             return false;
         case kSenderPID:
         case kMsgPerSec:
         case kAverageLatency:
             return true;
     }
     return false;
 }

 namespace dbus_top_analyzer
 {
     DBusTopStatistics g_dbus_statistics;
     Histogram<float> g_mc_time_histogram;
     std::unordered_map<uint32_t, uint64_t> in_flight_methodcalls;
     std::atomic<bool> g_program_done = false;
     std::chrono::time_point<std::chrono::steady_clock> g_last_update;
     DBusTopStatisticsCallback g_callback;
     void SetDBusTopStatisticsCallback(DBusTopStatisticsCallback cb)
     {
         g_callback = cb;
     }

     int UserInputThread()
     {
         return 0;
     }

     std::string g_dbus_top_conn = " ";
     void SetDBusTopConnectionForMonitoring(const std::string& conn)
     {
         g_dbus_top_conn = conn;
     }

     // Performs one step of analysis
     void Process()
     {
         std::chrono::time_point<std::chrono::steady_clock> t =
             std::chrono::steady_clock::now();
         std::chrono::time_point<std::chrono::steady_clock> next_update =
             g_last_update + std::chrono::milliseconds(g_update_interval_millises);
         if (t >= next_update)
         {
             float seconds_since_last_sample =
                 std::chrono::duration_cast<std::chrono::microseconds>(t -
                                                                     g_last_update)
                     .count() /
                 1000000.0f;
             g_dbus_statistics.seconds_since_last_sample_ =
                 seconds_since_last_sample;
             // Update snapshot
             if (g_callback)
             {
                 g_callback(&g_dbus_statistics, &g_mc_time_histogram);
             }
             g_dbus_statistics.Reset();
             g_last_update = t;
         }
     }

     void Finish()
     {
         g_program_done = true;
     }

     std::vector<std::string> FindAllObjectPathsForService(
         const std::string& service,
         std::function<void(const std::string&, const std::vector<std::string>&)>
             on_interface_cb)
     {
         sd_bus_error err = SD_BUS_ERROR_NULL;
         sd_bus_message *m, *reply;
         std::vector<std::string> paths; // Current iteration
         std::vector<std::string>
             all_obj_paths; // All object paths under the supervision of ObjectMapper
         paths.push_back("/");
         // busctl call xyz.openbmc_project.ObjectMapper        /
         // org.freedesktop.DBus.Introspectable        Introspect
         while (!paths.empty())
         {
             // printf("%d paths to explore, total %d paths so far\n",
             // int(paths.size()), int(all_obj_paths.size()));
             std::vector<std::string> new_paths;
             for (const std::string& obj_path : paths)
             {
                 all_obj_paths.push_back(obj_path);
                 int r = sd_bus_message_new_method_call(
                     g_bus, &m, service.c_str(), obj_path.c_str(),
                     "org.freedesktop.DBus.Introspectable", "Introspect");
                 if (r < 0)
                 {
                     printf("Oh! Cannot create new method call. r=%d, strerror=%s\n",
                         r, strerror(-r));
                     continue;
                 }
                 r = sd_bus_call(g_bus, m, 0, &err, &reply);
                 if (r < 0)
                 {
                     printf("Could not execute method call, r=%d, strerror=%s\n", r,
                         strerror(-r));
                 }
                 const char* sig = sd_bus_message_get_signature(reply, 0);
                 if (!strcmp(sig, "s"))
                 {
                     const char* s;
                     int r = sd_bus_message_read(reply, "s", &s);
                     std::string s1(s);
                     if (r < 0)
                     {
                         printf("Could not read string payload, r=%d, strerror=%s\n",
                             r, strerror(-r));
                     }
                     else
                     {
                         XMLNode* t = ParseXML(s1);
                         std::vector<std::string> ch = t->GetChildNodeNames();
                         if (on_interface_cb != nullptr)
                         {
                             on_interface_cb(obj_path, t->GetInterfaceNames());
                         }
                         DeleteTree(t);
                         for (const std::string& cn : ch)
                         {
                             std::string ch_path = obj_path;
                             if (obj_path.back() == '/')
                             {}
                             else
                                 ch_path.push_back('/');
                             ch_path += cn;
                             new_paths.push_back(ch_path);
                         }
                     }
                 }
             }
             paths = new_paths;
         }
         return all_obj_paths;
     }

     void ListAllSensors()
     {
         g_connection_snapshot = new DBusConnectionSnapshot();
         printf("1. Getting names\n");
         char** names;
         int r = sd_bus_list_names(g_bus, &names, nullptr);
         std::vector<std::string> services;
         std::vector<int> pids;
         std::vector<std::string> comms;
         for (char** ptr = names; ptr && *ptr; ++ptr)
         {
             services.push_back(*ptr);
             free(*ptr);
         }
         free(names);
         printf("2. Getting creds of each name\n");
         for (int i = 0; i < static_cast<int>(services.size()); i++)
         {
             const std::string& service = services[i];
             sd_bus_creds* creds = nullptr;
             r = sd_bus_get_name_creds(g_bus, services[i].c_str(),
                                     SD_BUS_CREDS_AUGMENT | SD_BUS_CREDS_EUID |
                                         SD_BUS_CREDS_PID | SD_BUS_CREDS_COMM |
                                         SD_BUS_CREDS_UNIQUE_NAME |
                                         SD_BUS_CREDS_UNIT | SD_BUS_CREDS_SESSION |
                                         SD_BUS_CREDS_DESCRIPTION,
                                     &creds);
             // PID
             int pid = INVALID;
             if (r < 0)
             {
                 printf("Oh! Cannot get creds for %s\n", services[i].c_str());
             }
             else
             {
                 r = sd_bus_creds_get_pid(creds, &pid);
             }
             pids.push_back(pid);
             // comm
             std::string comm;
             if (pid != INVALID)
             {
                 std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
                 std::string line;
                 std::getline(ifs, line);
                 for (char c : line)
                 {
                     if (c < 32 || c >= 127)
                         c = ' ';
                     comm.push_back(c);
                 }
             }
             comms.push_back(comm);
             // unique name, also known as "Connection"
             std::string connection;
             const char* u;
             r = sd_bus_creds_get_unique_name(creds, &u);
             if (r >= 0)
             {
                 connection = u;
             }
             else
             {
                 printf("Oh! Could not get unique name for %s\n", service.c_str());
             }
             std::string unit;
             r = sd_bus_creds_get_unit(creds, &u);
             if (r >= 0)
             {
                 unit = u;
             }
             else
             {
                 printf("Oh! Could not get unit name for %s\n", unit.c_str());
             }
             printf("AddConnection    %s    %s    %s    %s    %d\n", service.c_str(),
                 connection.c_str(), comm.c_str(), unit.c_str(), pid);
             g_connection_snapshot->AddConnection(service, connection, comm, unit,
                                                 pid);
         }
         printf("There are %d DBus names.\n", int(services.size()));
         for (int i = 0; i < int(services.size()); i++)
         {
             printf("    %d: %s [%s]\n", i, services[i].c_str(), comms[i].c_str());
         }
         g_sensor_snapshot = new SensorSnapshot(g_connection_snapshot);
         // busctl call xyz.openbmc_project.ObjectMapper /
         // org.freedesktop.DBus.Introspectable Introspect
         printf("3. See which sensors are visible from Object Mapper\n");
         printf("3.1. Introspect Object Mapper for object paths\n");
         std::vector<std::string> all_obj_paths = FindAllObjectPathsForService(
             "xyz.openbmc_project.ObjectMapper", nullptr);
         sd_bus_error err = SD_BUS_ERROR_NULL;
         sd_bus_message *m, *reply;
         printf("%d paths found while introspecting ObjectMapper.\n",
             int(all_obj_paths.size()));
         printf("3.2. Call ObjectMapper's GetObject method against the sensor "
             "object paths that represent sensors\n");
         for (const std::string& p : all_obj_paths)
         {
             if (IsSensorObjectPath(p))
             {
                 err = SD_BUS_ERROR_NULL;
                 r = sd_bus_message_new_method_call(
                     g_bus, &m, "xyz.openbmc_project.ObjectMapper",
                     "/xyz/openbmc_project/object_mapper",
                     "xyz.openbmc_project.ObjectMapper", "GetObject");
                 if (r < 0)
                 {
                     printf("Cannot create new method call. r=%d, strerror=%s\n", r,
                         strerror(-r));
                     continue;
                 }
                 r = sd_bus_message_append_basic(m, 's', p.c_str());
                 if (r < 0)
                 {
                     printf("Could not append a string parameter to m\n");
                     continue;
                 }
                 // empty array
                 r = sd_bus_message_open_container(m, 'a', "s");
                 if (r < 0)
                 {
                     printf("Could not open a container for m\n");
                     continue;
                 }
                 r = sd_bus_message_close_container(m);
                 if (r < 0)
                 {
                     printf("Could not close container for m\n");
                     continue;
                 }
                 r = sd_bus_call(g_bus, m, 0, &err, &reply);
                 if (r < 0)
                 {
                     printf("Error performing dbus method call\n");
                 }
                 const char* sig = sd_bus_message_get_signature(reply, 0);
                 if (!strcmp(sig, "a{sas}"))
                 {
                     r = sd_bus_message_enter_container(reply, 'a', "{sas}");
                     if (r < 0)
                     {
                         printf("Could not enter the level 0 array container\n");
                         continue;
                     }
                     while (true)
                     {
                         r = sd_bus_message_enter_container(
                             reply, SD_BUS_TYPE_DICT_ENTRY, "sas");
                         if (r < 0)
                         {
                             // printf("Could not enter the level 1 dict
                             // container\n");
                             goto DONE;
                         }
                         else if (r == 0)
                         {}
                         else
                         {
                             // The following 2 correspond to `interface_map` in
                             // phosphor-mapper
                             const char* interface_map_first;
                             r = sd_bus_message_read_basic(reply, 's',
                                                         &interface_map_first);
                             if (r < 0)
                             {
                                 printf("Could not read interface_map_first\n");
                                 goto DONE;
                             }
                             r = sd_bus_message_enter_container(reply, 'a', "s");
                             if (r < 0)
                             {
                                 printf("Could not enter the level 2 array "
                                     "container\n");
                                 goto DONE;
                             }
                             bool has_value_interface = false;
                             while (true)
                             {
                                 const char* interface_map_second;
                                 r = sd_bus_message_read_basic(
                                     reply, 's', &interface_map_second);
                                 if (r < 0)
                                 {
                                     printf("Could not read interface_map_second\n");
                                 }
                                 else if (r == 0)
                                     break;
                                 else
                                 {
                                     // printf("    %s\n", interface_map_second);
                                     if (!strcmp(interface_map_second,
                                                 "xyz.openbmc_project.Sensor.Value"))
                                     {
                                         has_value_interface = true;
                                     }
                                 }
                             }
                             if (has_value_interface)
                             {
                                 g_sensor_snapshot->SerSensorVisibleFromObjectMapper(
                                     std::string(interface_map_first), p);
                             }
                             r = sd_bus_message_exit_container(reply);
                         }
                         r = sd_bus_message_exit_container(reply);
                     }
                     r = sd_bus_message_exit_container(reply);
                 }
             DONE:
             {}
             }
         }
         printf("4. Check Hwmon's DBus objects\n");
         for (int i = 0; i < int(comms.size()); i++)
         {
             const std::string& comm = comms[i];
             const std::string& service = services[i];
             if (comm.find("phosphor-hwmon-readd") != std::string::npos &&
                 !IsUniqueName(service))
             {
                 // printf("Should introspect %s\n", service.c_str());
                 std::vector<std::string> objpaths =
                     FindAllObjectPathsForService(service, nullptr);
                 for (const std::string& op : objpaths)
                 {
                     if (IsSensorObjectPath(op))
                     {
                         g_sensor_snapshot->SetSensorVisibleFromHwmon(service, op);
                     }
                 }
             }
         }
         // Call `ipmitool sdr list` and see which sensors exist.
         printf("5. Checking ipmitool SDR List\n");
         std::string out;
         bool skip_sdr_list = false;
         if (getenv("SKIP"))
         {
             skip_sdr_list = true;
         }
         if (!skip_sdr_list)
         {
             constexpr int MAX_BUFFER = 255;
             char buffer[MAX_BUFFER];
             FILE* stream = popen("ipmitool sdr list", "r");
             while (fgets(buffer, MAX_BUFFER, stream) != NULL)
             {
                 out.append(buffer);
             }
             pclose(stream);
         }
         std::stringstream ss(out);
         while (true)
         {
             std::string sensor_id, reading, status;
             std::getline(ss, sensor_id, '|');
             std::getline(ss, reading, '|');
             std::getline(ss, status);
             // printf("%s %s %s\n", sensor_id.c_str(), reading.c_str(),
             // status.c_str());
             if (sensor_id.size() > 0 && reading.size() > 0 && status.size() > 0)
             {
                 g_sensor_snapshot->SetSensorVisibleFromIpmitoolSdr(Trim(sensor_id));
             }
             else
                 break;
         }
         printf("=== Sensors snapshot summary: ===\n");
         g_sensor_snapshot->PrintSummary();
     }
 } // namespace dbus_top_analyzer

 void DBusTopStatistics::OnNewDBusMessage(const char* sender,
                                          const char* destination,
                                          const char* interface,
                                          const char* path, const char* member,
                                          const char type, sd_bus_message* m)
 {
     num_messages_++;
     std::vector<std::string> keys;

     std::string sender_orig = CheckAndFixNullString(sender);
     std::string dest_orig = CheckAndFixNullString(destination);
     // For method return messages, we actually want to show the sender
     // and destination of the original method call, so we swap the
     // sender and destination
     if (type == 2)
     { // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
         std::swap(sender_orig, dest_orig);
     }

     // Special case: when PID == 1 (init), the DBus unit would be systemd.
     // It seems it was not possible to obtain the connection name of systemd
     // so we manually set it here.
     const int sender_orig_pid =
         g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(
             sender_orig);

     if (sender_orig_pid == 1)
     {
         sender_orig = "systemd";
     }
     const int dest_orig_pid =
         g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(dest_orig);
     if (dest_orig_pid == 1)
     {
         dest_orig = "systemd";
     }

     for (DBusTopSortField field : fields_)
     {
         switch (field)
         {
             case kSender:
                 keys.push_back(sender_orig);
                 break;
             case kDestination:
                 keys.push_back(dest_orig);
                 break;
             case kInterface:
                 keys.push_back(CheckAndFixNullString(interface));
                 break;
             case kPath:
                 keys.push_back(CheckAndFixNullString(path));
                 break;
             case kMember:
                 keys.push_back(CheckAndFixNullString(member));
                 break;
             case kSenderPID:
             {
                 if (sender_orig_pid != INVALID)
                 {
                     keys.push_back(std::to_string(sender_orig_pid));
                 }
                 else
                 {
                     keys.push_back("(unknown)");
                 }
                 break;
             }
             case kSenderCMD:
             {
                 keys.push_back(
                     g_connection_snapshot->GetConnectionCMDFromNameOrUniqueName(
                         sender_orig));
                 break;
             }
             case kMsgPerSec:
             case kAverageLatency:
                 break; // Don't populate "keys" using these 2 fields
         }
     }
     // keys = combination of fields of user's choice

     if (stats_.count(keys) == 0)
     {
         stats_[keys] = DBusTopComputedMetrics();
     }
     // Need to update msg/s regardless
     switch (type)
     {
         case 1: // DBUS_MESSAGE_TYPE_METHOD_CALL
             stats_[keys].num_method_calls++;
             break;
         case 2: // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
             stats_[keys].num_method_returns++;
             break;
         case 3: // DBUS_MESSAGE_TYPE_ERROR
             stats_[keys].num_errors++;
             break;
         case 4: // DBUS_MESSAGE_TYPE_SIGNAL
             stats_[keys].num_signals++;
             break;
     }
     // Update global latency histogram
     // For method call latency
     if (type == 1) // DBUS_MESSAGE_TYPE_METHOD_CALL
     {
         uint64_t serial; // serial == cookie
         sd_bus_message_get_cookie(m, &serial);
         in_flight_methodcalls[serial] = Microseconds();
     }
     else if (type == 2) // DBUS_MESSAGE_TYPE_MEHOTD_RETURN
     {
         uint64_t reply_serial = 0; // serial == cookie
         sd_bus_message_get_reply_cookie(m, &reply_serial);
         if (in_flight_methodcalls.count(reply_serial) > 0)
         {
             float dt_usec =
                 Microseconds() - in_flight_methodcalls[reply_serial];
             in_flight_methodcalls.erase(reply_serial);
             dbus_top_analyzer::g_mc_time_histogram.AddSample(dt_usec);

             // Add method call count and total latency to the corresponding key
             stats_[keys].total_latency_usec += dt_usec;
         }
     }
     // For meaning of type see here
     // https://dbus.freedesktop.org/doc/api/html/group__DBusProtocol.html#ga4a9012edd7f22342f845e98150aeb858
     switch (type)
     {
         case 1:
             num_mc_++;
             break;
         case 2:
             num_mr_++;
             break;
         case 3:
             num_error_++;
             break;
         case 4:
             num_sig_++;
             break;
     }
 }
	// Copyright 2021 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "analyzer.hpp"
	#include "histogram.hpp"
	#include "main.hpp"
	#include "sensorhelper.hpp"
	#include "views.hpp"
	#include "xmlparse.hpp"

	#include <unistd.h>
	#include <atomic>
	#include <filesystem>
	#include <fstream>
	#include <functional>
	#include <iostream>
	#include <sstream>
	#include <string>

	extern SensorSnapshot* g_sensor_snapshot;
	extern DBusConnectionSnapshot* g_connection_snapshot;
	extern sd_bus* g_bus;
	extern SensorDetailView* g_sensor_detail_view;

	static std::unordered_map<uint64_t, uint64_t>
	in_flight_methodcalls; // serial => microseconds
	uint64_t Microseconds()
	{
	long us; // usec
	time_t s; // Seconds
	struct timespec spec;
	clock_gettime(CLOCK_REALTIME, &spec);
	s = spec.tv_sec;
	us = round(spec.tv_nsec / 1000); // Convert nanoseconds to milliseconds
	if (us > 999999)
	{
	s++;
	us = 0;
	}
	return s * 1000000 + us;
	}

	int g_update_interval_millises = 2000;
	int GetSummaryIntervalInMillises()
	{
	return g_update_interval_millises;
	}

	bool DBusTopSortFieldIsNumeric(DBusTopSortField field)
	{
	switch (field)
	{
	case kSender:
	case kDestination:
	case kInterface:
	case kPath:
	case kMember:
	case kSenderCMD:
	return false;
	case kSenderPID:
	case kMsgPerSec:
	case kAverageLatency:
	return true;
	}
	return false;
	}

	namespace dbus_top_analyzer
	{
	DBusTopStatistics g_dbus_statistics;
	Histogram<float> g_mc_time_histogram;
	std::unordered_map<uint32_t, uint64_t> in_flight_methodcalls;
	std::atomic<bool> g_program_done = false;
	std::chrono::time_point<std::chrono::steady_clock> g_last_update;
	DBusTopStatisticsCallback g_callback;
	void SetDBusTopStatisticsCallback(DBusTopStatisticsCallback cb)
	{
	g_callback = cb;
	}

	int UserInputThread()
	{
	return 0;
	}

	std::string g_dbus_top_conn = " ";
	void SetDBusTopConnectionForMonitoring(const std::string& conn)
	{
	g_dbus_top_conn = conn;
	}

	// Performs one step of analysis
	void Process()
	{
	std::chrono::time_point<std::chrono::steady_clock> t =
	std::chrono::steady_clock::now();
	std::chrono::time_point<std::chrono::steady_clock> next_update =
	g_last_update + std::chrono::milliseconds(g_update_interval_millises);
	if (t >= next_update)
	{
	float seconds_since_last_sample =
	std::chrono::duration_cast<std::chrono::microseconds>(t -
	g_last_update)
	.count() /
	1000000.0f;
	g_dbus_statistics.seconds_since_last_sample_ =
	seconds_since_last_sample;
	// Update snapshot
	if (g_callback)
	{
	g_callback(&g_dbus_statistics, &g_mc_time_histogram);
	}
	g_dbus_statistics.Reset();
	g_last_update = t;
	}
	}

	void Finish()
	{
	g_program_done = true;
	}

	std::vector<std::string> FindAllObjectPathsForService(
	const std::string& service,
	std::function<void(const std::string&, const std::vector<std::string>&)>
	on_interface_cb)
	{
	sd_bus_error err = SD_BUS_ERROR_NULL;
	sd_bus_message m, reply;
	std::vector<std::string> paths; // Current iteration
	std::vector<std::string>
	all_obj_paths; // All object paths under the supervision of ObjectMapper
	paths.push_back("/");
	// busctl call xyz.openbmc_project.ObjectMapper /
	// org.freedesktop.DBus.Introspectable Introspect
	while (!paths.empty())
	{
	// printf("%d paths to explore, total %d paths so far\n",
	// int(paths.size()), int(all_obj_paths.size()));
	std::vector<std::string> new_paths;
	for (const std::string& obj_path : paths)
	{
	all_obj_paths.push_back(obj_path);
	int r = sd_bus_message_new_method_call(
	g_bus, &m, service.c_str(), obj_path.c_str(),
	"org.freedesktop.DBus.Introspectable", "Introspect");
	if (r < 0)
	{
	printf("Oh! Cannot create new method call. r=%d, strerror=%s\n",
	r, strerror(-r));
	continue;
	}
	r = sd_bus_call(g_bus, m, 0, &err, &reply);
	if (r < 0)
	{
	printf("Could not execute method call, r=%d, strerror=%s\n", r,
	strerror(-r));
	}
	const char* sig = sd_bus_message_get_signature(reply, 0);
	if (!strcmp(sig, "s"))
	{
	const char* s;
	int r = sd_bus_message_read(reply, "s", &s);
	std::string s1(s);
	if (r < 0)
	{
	printf("Could not read string payload, r=%d, strerror=%s\n",
	r, strerror(-r));
	}
	else
	{
	XMLNode* t = ParseXML(s1);
	std::vector<std::string> ch = t->GetChildNodeNames();
	if (on_interface_cb != nullptr)
	{
	on_interface_cb(obj_path, t->GetInterfaceNames());
	}
	DeleteTree(t);
	for (const std::string& cn : ch)
	{
	std::string ch_path = obj_path;
	if (obj_path.back() == '/')
	{}
	else
	ch_path.push_back('/');
	ch_path += cn;
	new_paths.push_back(ch_path);
	}
	}
	}
	}
	paths = new_paths;
	}
	return all_obj_paths;
	}

	void ListAllSensors()
	{
	g_connection_snapshot = new DBusConnectionSnapshot();
	printf("1. Getting names\n");
	char** names;
	int r = sd_bus_list_names(g_bus, &names, nullptr);
	std::vector<std::string> services;
	std::vector<int> pids;
	std::vector<std::string> comms;
	for (char** ptr = names; ptr && *ptr; ++ptr)
	{
	services.push_back(*ptr);
	free(*ptr);
	}
	free(names);
	printf("2. Getting creds of each name\n");
	for (int i = 0; i < static_cast<int>(services.size()); i++)
	{
	const std::string& service = services[i];
	sd_bus_creds* creds = nullptr;
	r = sd_bus_get_name_creds(g_bus, services[i].c_str(),
	SD_BUS_CREDS_AUGMENT \| SD_BUS_CREDS_EUID \|
	SD_BUS_CREDS_PID \| SD_BUS_CREDS_COMM \|
	SD_BUS_CREDS_UNIQUE_NAME \|
	SD_BUS_CREDS_UNIT \| SD_BUS_CREDS_SESSION \|
	SD_BUS_CREDS_DESCRIPTION,
	&creds);
	// PID
	int pid = INVALID;
	if (r < 0)
	{
	printf("Oh! Cannot get creds for %s\n", services[i].c_str());
	}
	else
	{
	r = sd_bus_creds_get_pid(creds, &pid);
	}
	pids.push_back(pid);
	// comm
	std::string comm;
	if (pid != INVALID)
	{
	std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
	std::string line;
	std::getline(ifs, line);
	for (char c : line)
	{
	if (c < 32 \|\| c >= 127)
	c = ' ';
	comm.push_back(c);
	}
	}
	comms.push_back(comm);
	// unique name, also known as "Connection"
	std::string connection;
	const char* u;
	r = sd_bus_creds_get_unique_name(creds, &u);
	if (r >= 0)
	{
	connection = u;
	}
	else
	{
	printf("Oh! Could not get unique name for %s\n", service.c_str());
	}
	std::string unit;
	r = sd_bus_creds_get_unit(creds, &u);
	if (r >= 0)
	{
	unit = u;
	}
	else
	{
	printf("Oh! Could not get unit name for %s\n", unit.c_str());
	}
	printf("AddConnection %s %s %s %s %d\n", service.c_str(),
	connection.c_str(), comm.c_str(), unit.c_str(), pid);
	g_connection_snapshot->AddConnection(service, connection, comm, unit,
	pid);
	}
	printf("There are %d DBus names.\n", int(services.size()));
	for (int i = 0; i < int(services.size()); i++)
	{
	printf(" %d: %s [%s]\n", i, services[i].c_str(), comms[i].c_str());
	}
	g_sensor_snapshot = new SensorSnapshot(g_connection_snapshot);
	// busctl call xyz.openbmc_project.ObjectMapper /
	// org.freedesktop.DBus.Introspectable Introspect
	printf("3. See which sensors are visible from Object Mapper\n");
	printf("3.1. Introspect Object Mapper for object paths\n");
	std::vector<std::string> all_obj_paths = FindAllObjectPathsForService(
	"xyz.openbmc_project.ObjectMapper", nullptr);
	sd_bus_error err = SD_BUS_ERROR_NULL;
	sd_bus_message m, reply;
	printf("%d paths found while introspecting ObjectMapper.\n",
	int(all_obj_paths.size()));
	printf("3.2. Call ObjectMapper's GetObject method against the sensor "
	"object paths that represent sensors\n");
	for (const std::string& p : all_obj_paths)
	{
	if (IsSensorObjectPath(p))
	{
	err = SD_BUS_ERROR_NULL;
	r = sd_bus_message_new_method_call(
	g_bus, &m, "xyz.openbmc_project.ObjectMapper",
	"/xyz/openbmc_project/object_mapper",
	"xyz.openbmc_project.ObjectMapper", "GetObject");
	if (r < 0)
	{
	printf("Cannot create new method call. r=%d, strerror=%s\n", r,
	strerror(-r));
	continue;
	}
	r = sd_bus_message_append_basic(m, 's', p.c_str());
	if (r < 0)
	{
	printf("Could not append a string parameter to m\n");
	continue;
	}
	// empty array
	r = sd_bus_message_open_container(m, 'a', "s");
	if (r < 0)
	{
	printf("Could not open a container for m\n");
	continue;
	}
	r = sd_bus_message_close_container(m);
	if (r < 0)
	{
	printf("Could not close container for m\n");
	continue;
	}
	r = sd_bus_call(g_bus, m, 0, &err, &reply);
	if (r < 0)
	{
	printf("Error performing dbus method call\n");
	}
	const char* sig = sd_bus_message_get_signature(reply, 0);
	if (!strcmp(sig, "a{sas}"))
	{
	r = sd_bus_message_enter_container(reply, 'a', "{sas}");
	if (r < 0)
	{
	printf("Could not enter the level 0 array container\n");
	continue;
	}
	while (true)
	{
	r = sd_bus_message_enter_container(
	reply, SD_BUS_TYPE_DICT_ENTRY, "sas");
	if (r < 0)
	{
	// printf("Could not enter the level 1 dict
	// container\n");
	goto DONE;
	}
	else if (r == 0)
	{}
	else
	{
	// The following 2 correspond to `interface_map` in
	// phosphor-mapper
	const char* interface_map_first;
	r = sd_bus_message_read_basic(reply, 's',
	&interface_map_first);
	if (r < 0)
	{
	printf("Could not read interface_map_first\n");
	goto DONE;
	}
	r = sd_bus_message_enter_container(reply, 'a', "s");
	if (r < 0)
	{
	printf("Could not enter the level 2 array "
	"container\n");
	goto DONE;
	}
	bool has_value_interface = false;
	while (true)
	{
	const char* interface_map_second;
	r = sd_bus_message_read_basic(
	reply, 's', &interface_map_second);
	if (r < 0)
	{
	printf("Could not read interface_map_second\n");
	}
	else if (r == 0)
	break;
	else
	{
	// printf(" %s\n", interface_map_second);
	if (!strcmp(interface_map_second,
	"xyz.openbmc_project.Sensor.Value"))
	{
	has_value_interface = true;
	}
	}
	}
	if (has_value_interface)
	{
	g_sensor_snapshot->SerSensorVisibleFromObjectMapper(
	std::string(interface_map_first), p);
	}
	r = sd_bus_message_exit_container(reply);
	}
	r = sd_bus_message_exit_container(reply);
	}
	r = sd_bus_message_exit_container(reply);
	}
	DONE:
	{}
	}
	}
	printf("4. Check Hwmon's DBus objects\n");
	for (int i = 0; i < int(comms.size()); i++)
	{
	const std::string& comm = comms[i];
	const std::string& service = services[i];
	if (comm.find("phosphor-hwmon-readd") != std::string::npos &&
	!IsUniqueName(service))
	{
	// printf("Should introspect %s\n", service.c_str());
	std::vector<std::string> objpaths =
	FindAllObjectPathsForService(service, nullptr);
	for (const std::string& op : objpaths)
	{
	if (IsSensorObjectPath(op))
	{
	g_sensor_snapshot->SetSensorVisibleFromHwmon(service, op);
	}
	}
	}
	}
	// Call `ipmitool sdr list` and see which sensors exist.
	printf("5. Checking ipmitool SDR List\n");
	std::string out;
	bool skip_sdr_list = false;
	if (getenv("SKIP"))
	{
	skip_sdr_list = true;
	}
	if (!skip_sdr_list)
	{
	constexpr int MAX_BUFFER = 255;
	char buffer[MAX_BUFFER];
	FILE* stream = popen("ipmitool sdr list", "r");
	while (fgets(buffer, MAX_BUFFER, stream) != NULL)
	{
	out.append(buffer);
	}
	pclose(stream);
	}
	std::stringstream ss(out);
	while (true)
	{
	std::string sensor_id, reading, status;
	std::getline(ss, sensor_id, '\|');
	std::getline(ss, reading, '\|');
	std::getline(ss, status);
	// printf("%s %s %s\n", sensor_id.c_str(), reading.c_str(),
	// status.c_str());
	if (sensor_id.size() > 0 && reading.size() > 0 && status.size() > 0)
	{
	g_sensor_snapshot->SetSensorVisibleFromIpmitoolSdr(Trim(sensor_id));
	}
	else
	break;
	}
	printf("=== Sensors snapshot summary: ===\n");
	g_sensor_snapshot->PrintSummary();
	}
	} // namespace dbus_top_analyzer

	void DBusTopStatistics::OnNewDBusMessage(const char* sender,
	const char* destination,
	const char* interface,
	const char* path, const char* member,
	const char type, sd_bus_message* m)
	{
	num_messages_++;
	std::vector<std::string> keys;

	std::string sender_orig = CheckAndFixNullString(sender);
	std::string dest_orig = CheckAndFixNullString(destination);
	// For method return messages, we actually want to show the sender
	// and destination of the original method call, so we swap the
	// sender and destination
	if (type == 2)
	{ // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
	std::swap(sender_orig, dest_orig);
	}

	// Special case: when PID == 1 (init), the DBus unit would be systemd.
	// It seems it was not possible to obtain the connection name of systemd
	// so we manually set it here.
	const int sender_orig_pid =
	g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(
	sender_orig);

	if (sender_orig_pid == 1)
	{
	sender_orig = "systemd";
	}
	const int dest_orig_pid =
	g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(dest_orig);
	if (dest_orig_pid == 1)
	{
	dest_orig = "systemd";
	}

	for (DBusTopSortField field : fields_)
	{
	switch (field)
	{
	case kSender:
	keys.push_back(sender_orig);
	break;
	case kDestination:
	keys.push_back(dest_orig);
	break;
	case kInterface:
	keys.push_back(CheckAndFixNullString(interface));
	break;
	case kPath:
	keys.push_back(CheckAndFixNullString(path));
	break;
	case kMember:
	keys.push_back(CheckAndFixNullString(member));
	break;
	case kSenderPID:
	{
	if (sender_orig_pid != INVALID)
	{
	keys.push_back(std::to_string(sender_orig_pid));
	}
	else
	{
	keys.push_back("(unknown)");
	}
	break;
	}
	case kSenderCMD:
	{
	keys.push_back(
	g_connection_snapshot->GetConnectionCMDFromNameOrUniqueName(
	sender_orig));
	break;
	}
	case kMsgPerSec:
	case kAverageLatency:
	break; // Don't populate "keys" using these 2 fields
	}
	}
	// keys = combination of fields of user's choice

	if (stats_.count(keys) == 0)
	{
	stats_[keys] = DBusTopComputedMetrics();
	}
	// Need to update msg/s regardless
	switch (type)
	{
	case 1: // DBUS_MESSAGE_TYPE_METHOD_CALL
	stats_[keys].num_method_calls++;
	break;
	case 2: // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
	stats_[keys].num_method_returns++;
	break;
	case 3: // DBUS_MESSAGE_TYPE_ERROR
	stats_[keys].num_errors++;
	break;
	case 4: // DBUS_MESSAGE_TYPE_SIGNAL
	stats_[keys].num_signals++;
	break;
	}
	// Update global latency histogram
	// For method call latency
	if (type == 1) // DBUS_MESSAGE_TYPE_METHOD_CALL
	{
	uint64_t serial; // serial == cookie
	sd_bus_message_get_cookie(m, &serial);
	in_flight_methodcalls[serial] = Microseconds();
	}
	else if (type == 2) // DBUS_MESSAGE_TYPE_MEHOTD_RETURN
	{
	uint64_t reply_serial = 0; // serial == cookie
	sd_bus_message_get_reply_cookie(m, &reply_serial);
	if (in_flight_methodcalls.count(reply_serial) > 0)
	{
	float dt_usec =
	Microseconds() - in_flight_methodcalls[reply_serial];
	in_flight_methodcalls.erase(reply_serial);
	dbus_top_analyzer::g_mc_time_histogram.AddSample(dt_usec);

	// Add method call count and total latency to the corresponding key
	stats_[keys].total_latency_usec += dt_usec;
	}
	}
	// For meaning of type see here
	// https://dbus.freedesktop.org/doc/api/html/group__DBusProtocol.html#ga4a9012edd7f22342f845e98150aeb858
	switch (type)
	{
	case 1:
	num_mc_++;
	break;
	case 2:
	num_mr_++;
	break;
	case 3:
	num_error_++;
	break;
	case 4:
	num_sig_++;
	break;
	}
	}