dbus_capture.cpp - openbmc/dbus-top - 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 <ncurses.h>
 #include <stdlib.h>
 #include <systemd/sd-bus.h>

 #include <unordered_map>

 bool IS_USER_BUS = false; // User bus or System bus?
 extern sd_bus* g_bus;
 extern DBusConnectionSnapshot* g_connection_snapshot;
 static std::unordered_map<uint64_t, uint64_t> in_flight_methodcalls;

 extern bool g_sensor_update_thread_active;
 extern std::string g_snapshot_update_bus_cxn;
 extern int g_snapshot_update_bus_cxn_id;
 extern int GetConnectionNumericID(const std::string& unique_name);

 namespace dbus_top_analyzer
 {
 extern DBusTopStatistics g_dbus_statistics;
 extern Histogram<float> g_mc_time_histogram;
 } // namespace dbus_top_analyzer

 static void TrackMessage([[maybe_unused]] sd_bus_message* m) {}
 // Obtain a Monitoring DBus connection
 int AcquireBus(sd_bus** ret)
 {
     int r;
     r = sd_bus_new(ret);
     if (r < 0)
     {
         printf("Could not allocate bus: %s\n", strerror(-r));
         return 0;
     }
     r = sd_bus_set_monitor(*ret, true);
     if (r < 0)
     {
         printf("Could not set monitor mode: %s\n", strerror(-r));
         return 0;
     }
     r = sd_bus_negotiate_creds(*ret, true, _SD_BUS_CREDS_ALL);
     if (r < 0)
     {
         printf("Could not enable credentials: %s\n", strerror(-r));
         return 0;
     }
     r = sd_bus_negotiate_timestamp(*ret, true);
     if (r < 0)
     {
         printf("Could not enable timestamps: %s\n", strerror(-r));
         return 0;
     }
     r = sd_bus_negotiate_fds(*ret, true);
     if (r < 0)
     {
         printf("Could not enable fds: %s\n", strerror(-r));
         return 0;
     }
     r = sd_bus_set_bus_client(*ret, true);
     if (r < 0)
     {
         printf("Could not enable bus client: %s\n", strerror(-r));
         return 0;
     }
     if (IS_USER_BUS)
     {
         r = sd_bus_set_address(*ret, "haha");
         if (r < 0)
         {
             printf("Could not set user bus: %s\n", strerror(-r));
             return 0;
         }
     }
     else
     {
         r = sd_bus_set_address(*ret, "unix:path=/run/dbus/system_bus_socket");
         if (r < 0)
         {
             printf("Could not set system bus: %s\n", strerror(-r));
             return 0;
         }
     }
     r = sd_bus_start(*ret);
     if (r < 0)
     {
         printf("Could not connect to bus: %s\n", strerror(-r));
         return 0;
     }
     return r;
 }

 void DbusCaptureThread()
 {
     int r;
     // Become Monitor
     uint32_t flags = 0;
     sd_bus_message* message;
     sd_bus_error error = SD_BUS_ERROR_NULL;
     r = sd_bus_message_new_method_call(
         g_bus, &message, "org.freedesktop.DBus", "/org/freedesktop/DBus",
         "org.freedesktop.DBus.Monitoring", "BecomeMonitor");
     if (r < 0)
     {
         printf("Could not create the BecomeMonitor function call\n");
         exit(0);
     }
     // Match conditions
     r = sd_bus_message_open_container(message, 'a', "s");
     if (r < 0)
     {
         printf("Could not open container\n");
         exit(0);
     }
     r = sd_bus_message_close_container(message);
     if (r < 0)
     {
         printf("Could not close container\n");
         exit(0);
     }
     r = sd_bus_message_append_basic(message, 'u', &flags);
     if (r < 0)
     {
         printf("Could not append flags\n");
         exit(0);
     }
     r = sd_bus_call(g_bus, message, 0, &error, nullptr);
     if (r < 0)
     {
         printf("Could not call org.freedesktop.DBus.Monitoring.BecomeMonitor "
                "%d, %s\n",
                r, strerror(-r));
         exit(0);
     }
     const char* unique_name;
     r = sd_bus_get_unique_name(g_bus, &unique_name);
     if (r < 0)
     {
         printf("Could not get unique name: %s\n", strerror(-r));
         exit(0);
     }
     // Enter packet processing loop
     while (true)
     {
         struct sd_bus_message* m = nullptr;
         r = sd_bus_process(g_bus, &m);
         if (m != nullptr)
         {
             if (r < 0)
             {
                 printf("Failed to call sd_bus_process: %s\n", strerror(-r));
             }
             uint8_t type;
             r = sd_bus_message_get_type(m, &type);
             const char* path = sd_bus_message_get_path(m);
             // const char* iface = sd_bus_message_get_interface(m);
             const char* sender = sd_bus_message_get_sender(m);
             const char* destination = sd_bus_message_get_destination(m);
             const char* interface = sd_bus_message_get_interface(m);
             const char* member = sd_bus_message_get_member(m);

             // For looking up the unique connection name for sender and
             // destination
             std::string sender_uniq, dest_uniq;
             bool should_ignore = false;

             if (g_sensor_update_thread_active &&
                 g_snapshot_update_bus_cxn != "")
             {
                 int cxn_id = -999;
                 if (sender != nullptr)
                 {
                     cxn_id = GetConnectionNumericID(std::string(sender));
                 }
                 if (destination != nullptr)
                 {
                     cxn_id = GetConnectionNumericID(std::string(destination));
                 }

                 // Reason for this: The connection may be the connection from
                 // the update thread plus 1, example: :1.10000 vs :1.10001 Not
                 // sure where the new connection comes from. FIXME
                 if (cxn_id <= 4 + g_snapshot_update_bus_cxn_id &&
                     cxn_id >= g_snapshot_update_bus_cxn_id)
                 {
                     should_ignore = true;
                 }
             }

             if (!should_ignore)
             {
                 // TODO: This is for the bottom-left window
                 TrackMessage(m);

                 if (sender != nullptr)
                 {
                     sender_uniq =
                         g_connection_snapshot->GetUniqueNameIfExists(sender);
                 }
                 if (destination != nullptr)
                 {
                     dest_uniq = g_connection_snapshot->GetUniqueNameIfExists(
                         destination);
                 }
                 // This is for the bottom-right window
                 dbus_top_analyzer::g_dbus_statistics.OnNewDBusMessage(
                     sender_uniq.c_str(), dest_uniq.c_str(), interface, path,
                     member, type, m);
             }

             sd_bus_message_unref(m);
         }
         r = sd_bus_wait(g_bus,
                         (uint64_t)(GetSummaryIntervalInMillises() * 1000));
         if (r < 0)
         {
             printf("Failed to wait on bus: %s\n", strerror(-r));
             abort();
         }
         // Perform one analysis step
         dbus_top_analyzer::Process();
     }
 }
	// 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 <ncurses.h>
	#include <stdlib.h>
	#include <systemd/sd-bus.h>

	#include <unordered_map>

	bool IS_USER_BUS = false; // User bus or System bus?
	extern sd_bus* g_bus;
	extern DBusConnectionSnapshot* g_connection_snapshot;
	static std::unordered_map<uint64_t, uint64_t> in_flight_methodcalls;

	extern bool g_sensor_update_thread_active;
	extern std::string g_snapshot_update_bus_cxn;
	extern int g_snapshot_update_bus_cxn_id;
	extern int GetConnectionNumericID(const std::string& unique_name);

	namespace dbus_top_analyzer
	{
	extern DBusTopStatistics g_dbus_statistics;
	extern Histogram<float> g_mc_time_histogram;
	} // namespace dbus_top_analyzer

	static void TrackMessage([[maybe_unused]] sd_bus_message* m) {}
	// Obtain a Monitoring DBus connection
	int AcquireBus(sd_bus** ret)
	{
	int r;
	r = sd_bus_new(ret);
	if (r < 0)
	{
	printf("Could not allocate bus: %s\n", strerror(-r));
	return 0;
	}
	r = sd_bus_set_monitor(*ret, true);
	if (r < 0)
	{
	printf("Could not set monitor mode: %s\n", strerror(-r));
	return 0;
	}
	r = sd_bus_negotiate_creds(*ret, true, _SD_BUS_CREDS_ALL);
	if (r < 0)
	{
	printf("Could not enable credentials: %s\n", strerror(-r));
	return 0;
	}
	r = sd_bus_negotiate_timestamp(*ret, true);
	if (r < 0)
	{
	printf("Could not enable timestamps: %s\n", strerror(-r));
	return 0;
	}
	r = sd_bus_negotiate_fds(*ret, true);
	if (r < 0)
	{
	printf("Could not enable fds: %s\n", strerror(-r));
	return 0;
	}
	r = sd_bus_set_bus_client(*ret, true);
	if (r < 0)
	{
	printf("Could not enable bus client: %s\n", strerror(-r));
	return 0;
	}
	if (IS_USER_BUS)
	{
	r = sd_bus_set_address(*ret, "haha");
	if (r < 0)
	{
	printf("Could not set user bus: %s\n", strerror(-r));
	return 0;
	}
	}
	else
	{
	r = sd_bus_set_address(*ret, "unix:path=/run/dbus/system_bus_socket");
	if (r < 0)
	{
	printf("Could not set system bus: %s\n", strerror(-r));
	return 0;
	}
	}
	r = sd_bus_start(*ret);
	if (r < 0)
	{
	printf("Could not connect to bus: %s\n", strerror(-r));
	return 0;
	}
	return r;
	}

	void DbusCaptureThread()
	{
	int r;
	// Become Monitor
	uint32_t flags = 0;
	sd_bus_message* message;
	sd_bus_error error = SD_BUS_ERROR_NULL;
	r = sd_bus_message_new_method_call(
	g_bus, &message, "org.freedesktop.DBus", "/org/freedesktop/DBus",
	"org.freedesktop.DBus.Monitoring", "BecomeMonitor");
	if (r < 0)
	{
	printf("Could not create the BecomeMonitor function call\n");
	exit(0);
	}
	// Match conditions
	r = sd_bus_message_open_container(message, 'a', "s");
	if (r < 0)
	{
	printf("Could not open container\n");
	exit(0);
	}
	r = sd_bus_message_close_container(message);
	if (r < 0)
	{
	printf("Could not close container\n");
	exit(0);
	}
	r = sd_bus_message_append_basic(message, 'u', &flags);
	if (r < 0)
	{
	printf("Could not append flags\n");
	exit(0);
	}
	r = sd_bus_call(g_bus, message, 0, &error, nullptr);
	if (r < 0)
	{
	printf("Could not call org.freedesktop.DBus.Monitoring.BecomeMonitor "
	"%d, %s\n",
	r, strerror(-r));
	exit(0);
	}
	const char* unique_name;
	r = sd_bus_get_unique_name(g_bus, &unique_name);
	if (r < 0)
	{
	printf("Could not get unique name: %s\n", strerror(-r));
	exit(0);
	}
	// Enter packet processing loop
	while (true)
	{
	struct sd_bus_message* m = nullptr;
	r = sd_bus_process(g_bus, &m);
	if (m != nullptr)
	{
	if (r < 0)
	{
	printf("Failed to call sd_bus_process: %s\n", strerror(-r));
	}
	uint8_t type;
	r = sd_bus_message_get_type(m, &type);
	const char* path = sd_bus_message_get_path(m);
	// const char* iface = sd_bus_message_get_interface(m);
	const char* sender = sd_bus_message_get_sender(m);
	const char* destination = sd_bus_message_get_destination(m);
	const char* interface = sd_bus_message_get_interface(m);
	const char* member = sd_bus_message_get_member(m);

	// For looking up the unique connection name for sender and
	// destination
	std::string sender_uniq, dest_uniq;
	bool should_ignore = false;

	if (g_sensor_update_thread_active &&
	g_snapshot_update_bus_cxn != "")
	{
	int cxn_id = -999;
	if (sender != nullptr)
	{
	cxn_id = GetConnectionNumericID(std::string(sender));
	}
	if (destination != nullptr)
	{
	cxn_id = GetConnectionNumericID(std::string(destination));
	}

	// Reason for this: The connection may be the connection from
	// the update thread plus 1, example: :1.10000 vs :1.10001 Not
	// sure where the new connection comes from. FIXME
	if (cxn_id <= 4 + g_snapshot_update_bus_cxn_id &&
	cxn_id >= g_snapshot_update_bus_cxn_id)
	{
	should_ignore = true;
	}
	}

	if (!should_ignore)
	{
	// TODO: This is for the bottom-left window
	TrackMessage(m);

	if (sender != nullptr)
	{
	sender_uniq =
	g_connection_snapshot->GetUniqueNameIfExists(sender);
	}
	if (destination != nullptr)
	{
	dest_uniq = g_connection_snapshot->GetUniqueNameIfExists(
	destination);
	}
	// This is for the bottom-right window
	dbus_top_analyzer::g_dbus_statistics.OnNewDBusMessage(
	sender_uniq.c_str(), dest_uniq.c_str(), interface, path,
	member, type, m);
	}

	sd_bus_message_unref(m);
	}
	r = sd_bus_wait(g_bus,
	(uint64_t)(GetSummaryIntervalInMillises() * 1000));
	if (r < 0)
	{
	printf("Failed to wait on bus: %s\n", strerror(-r));
	abort();
	}
	// Perform one analysis step
	dbus_top_analyzer::Process();
	}
	}