luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-10 03:16:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '1190-debug-interface' into 'main'

Browse Source 
gdebugcontroller: Add debug controller API and D-Bus implementation

Closes #1190

See merge request GNOME/glib!2330
This commit is contained in:
Philip Withnall 2022-01-27 11:00:40 +00:00
commit 7f519624e2
13 changed files with 868 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/reference/gio/gio-docs.xml
View File

@ -232,6 +232,8 @@
<xi:include href="xml/gremoteactiongroup.xml"/>
<xi:include href="xml/gactiongroupexporter.xml"/>
<xi:include href="xml/gdbusactiongroup.xml"/>
<xi:include href="xml/gdebugcontroller.xml"/>
<xi:include href="xml/gdebugcontrollerdbus.xml"/>
<xi:include href="xml/gmemorymonitor.xml"/>
<xi:include href="xml/gmenumodel.xml"/>
<xi:include href="xml/gmenu.xml"/>

30
docs/reference/gio/gio-sections-common.txt
View File

@ -4207,6 +4207,36 @@ G_DBUS_OBJECT_MANAGER_SERVER_GET_CLASS
GDBusObjectManagerServerPrivate
</SECTION>
<SECTION>
<FILE>gdebugcontroller</FILE>
<TITLE>GDebugController</TITLE>
GDebugController
GDebugControllerInterface
G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME
g_debug_controller_dup_default
g_debug_controller_get_debug_enabled
g_debug_controller_set_debug_enabled
<SUBSECTION Standard>
g_debug_controller_get_type
G_TYPE_DEBUG_CONTROLLER
G_DEBUG_CONTROLLER
G_IS_DEBUG_CONTROLLER
G_DEBUG_CONTROLLER_GET_INTERFACE
</SECTION>
<SECTION>
<FILE>gdebugcontrollerdbus</FILE>
<TITLE>GDebugControllerDBus</TITLE>
GDebugControllerDBus
g_debug_controller_dbus_new
<SUBSECTION Standard>
g_debug_controller_dbus_get_type
G_TYPE_DEBUG_CONTROLLER_DBUS
G_DEBUG_CONTROLLER_DBUS
G_IS_DEBUG_CONTROLLER_DBUS
G_DEBUG_CONTROLLER_DBUS_GET_CLASS
</SECTION>
<SECTION>
<FILE>gmemorymonitor</FILE>
<TITLE>GMemoryMonitor</TITLE>

2
docs/reference/glib/glib-sections.txt
View File

@ -1537,6 +1537,8 @@ g_log_set_always_fatal
g_log_set_fatal_mask
g_log_default_handler
g_log_set_default_handler
g_log_get_debug_enabled
g_log_set_debug_enabled
<SUBSECTION>
g_log_structured

132
gio/gdebugcontroller.c Normal file
View File

@ -0,0 +1,132 @@
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright © 2021 Endless OS Foundation, LLC
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#include "glib.h"
#include "glibintl.h"
#include "gdebugcontroller.h"
#include "ginitable.h"
#include "giomodule-priv.h"
/**
* SECTION:gdebugcontroller
* @title: GDebugController
* @short_description: Debugging controller
* @include: gio/gio.h
*
* #GDebugController is an interface to expose control of debugging features and
* debug output.
*
* It is implemented on Linux using #GDebugControllerDBus, which exposes a D-Bus
* interface to allow authenticated peers to control debug features in this
* process.
*
* Whether debug output is enabled is exposed as
* #GDebugController:debug-enabled. This controls g_log_set_debug_enabled() by
* default. Application code may connect to the #GObject::notify signal for it
* to control other parts of its debug infrastructure as necessary.
*
* Since: 2.72
*/
G_DEFINE_INTERFACE_WITH_CODE (GDebugController, g_debug_controller, G_TYPE_OBJECT,
g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_INITABLE))
/**
* g_debug_controller_dup_default:
*
* Gets a reference to the default #GDebugController for the system.
*
* Returns: (not nullable) (transfer full): a new reference to the default #GDebugController
*
* Since: 2.72
*/
GDebugController *
g_debug_controller_dup_default (void)
{
return g_object_ref (_g_io_module_get_default (G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME,
"GIO_USE_DEBUG_CONTROLLER",
NULL));
}
static void
g_debug_controller_default_init (GDebugControllerInterface *iface)
{
/**
* GDebugController:debug-enabled:
*
* %TRUE if debug output should be exposed (for example by forwarding it to
* the journal), %FALSE otherwise.
*
* Since: 2.72
*/
g_object_interface_install_property (iface,
g_param_spec_boolean ("debug-enabled",
"Debug Enabled",
"Whether to expose debug output",
FALSE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_EXPLICIT_NOTIFY));
}
/**
* g_debug_controller_get_debug_enabled:
* @self: a #GDebugController
*
* Get the value of #GDebugController:debug-enabled.
*
* Returns: %TRUE if debug output should be exposed, %FALSE otherwise
* Since: 2.72
*/
gboolean
g_debug_controller_get_debug_enabled (GDebugController *self)
{
gboolean enabled;
g_return_val_if_fail (G_IS_DEBUG_CONTROLLER (self), FALSE);
g_object_get (G_OBJECT (self),
"debug-enabled", &enabled,
NULL);
return enabled;
}
/**
* g_debug_controller_set_debug_enabled:
* @self: a #GDebugController
* @debug_enabled: %TRUE if debug output should be exposed, %FALSE otherwise
*
* Set the value of #GDebugController:debug-enabled.
*
* Since: 2.72
*/
void
g_debug_controller_set_debug_enabled (GDebugController *self,
gboolean debug_enabled)
{
g_return_if_fail (G_IS_DEBUG_CONTROLLER (self));
g_object_set (G_OBJECT (self),
"debug-enabled", debug_enabled,
NULL);
}

82
gio/gdebugcontroller.h Normal file
View File

@ -0,0 +1,82 @@
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright © 2021 Endless OS Foundation, LLC
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#ifndef __G_DEBUG_CONTROLLER_H__
#define __G_DEBUG_CONTROLLER_H__
#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
#error "Only <gio/gio.h> can be included directly."
#endif
#include <gio/giotypes.h>
G_BEGIN_DECLS
/**
* G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME:
*
* Extension point for debug control functionality.
* See [Extending GIO][extending-gio].
*
* Since: 2.72
*/
#define G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME "gio-debug-controller"
/**
* GDebugController:
*
* #GDebugController is an interface to expose control of debugging features and
* debug output.
*
* Since: 2.72
*/
#define G_TYPE_DEBUG_CONTROLLER (g_debug_controller_get_type ())
GLIB_AVAILABLE_IN_2_72
G_DECLARE_INTERFACE(GDebugController, g_debug_controller, g, debug_controller, GObject)
#define G_DEBUG_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DEBUG_CONTROLLER, GDebugController))
#define G_IS_DEBUG_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DEBUG_CONTROLLER))
#define G_DEBUG_CONTROLLER_GET_INTERFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), G_TYPE_DEBUG_CONTROLLER, GDebugControllerInterface))
/**
* GDebugControllerInterface:
* @g_iface: The parent interface.
*
* The virtual function table for #GDebugController.
*
* Since: 2.72
*/
struct _GDebugControllerInterface {
/*< private >*/
GTypeInterface g_iface;
};
GLIB_AVAILABLE_IN_2_72
GDebugController *g_debug_controller_dup_default (void);
GLIB_AVAILABLE_IN_2_72
gboolean g_debug_controller_get_debug_enabled (GDebugController *self);
GLIB_AVAILABLE_IN_2_72
void g_debug_controller_set_debug_enabled (GDebugController *self,
gboolean debug_enabled);
G_END_DECLS
#endif /* __G_DEBUG_CONTROLLER_H__ */

490
gio/gdebugcontrollerdbus.c Normal file
View File

@ -0,0 +1,490 @@
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright © 2021 Endless OS Foundation, LLC
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#include <gio/gio.h>
#include "gdebugcontroller.h"
#include "gdebugcontrollerdbus.h"
#include "giomodule-priv.h"
#include "gi18n.h"
#include "gio/gdbusprivate.h"
#include "gio/gmarshal-internal.h"
/**
* SECTION:gdebugcontrollerdbus
* @title: GDebugControllerDBus
* @short_description: Debugging controller D-Bus implementation
* @include: gio/gio.h
*
* #GDebugControllerDBus is an implementation of #GDebugController which exposes
* debug settings as a D-Bus object.
*
* It is a #GInitable object, and will register an object at
* `/org/gtk/Debugging` on the bus given as
* #GDebugControllerDBus:connection once it’s initialized. The object will be
* unregistered when the last reference to the #GDebugControllerDBus is dropped.
*
* Since: 2.72
*/
static const gchar org_gtk_Debugging_xml[] =
"<node>"
"<interface name='org.gtk.Debugging'>"
"<property name='DebugEnabled' type='b' access='read'/>"
"<method name='SetDebugEnabled'>"
"<arg type='b' name='debug-enabled' direction='in'/>"
"</method>"
"</interface>"
"</node>";
static GDBusInterfaceInfo *org_gtk_Debugging;
#define G_DEBUG_CONTROLLER_DBUS_GET_INITABLE_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), G_TYPE_INITABLE, GInitable))
static void g_debug_controller_dbus_iface_init (GDebugControllerInterface *iface);
static void g_debug_controller_dbus_initable_iface_init (GInitableIface *iface);
static gboolean g_debug_controller_dbus_authorize_default (GDebugControllerDBus *self,
GDBusMethodInvocation *invocation);
typedef enum
{
PROP_CONNECTION = 1,
/* Overrides: */
PROP_DEBUG_ENABLED,
} GDebugControllerDBusProperty;
static GParamSpec *props[PROP_CONNECTION + 1] = { NULL, };
typedef enum
{
SIGNAL_AUTHORIZE,
} GDebugControllerDBusSignal;
static guint signals[SIGNAL_AUTHORIZE + 1] = {0};
typedef struct
{
GObject parent_instance;
GDBusConnection *connection; /* (owned) */
guint object_id;
gboolean debug_enabled;
} GDebugControllerDBusPrivate;
G_DEFINE_TYPE_WITH_CODE (GDebugControllerDBus, g_debug_controller_dbus, G_TYPE_OBJECT,
G_ADD_PRIVATE (GDebugControllerDBus)
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
g_debug_controller_dbus_initable_iface_init)
G_IMPLEMENT_INTERFACE (G_TYPE_DEBUG_CONTROLLER,
g_debug_controller_dbus_iface_init)
_g_io_modules_ensure_extension_points_registered ();
g_io_extension_point_implement (G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME,
g_define_type_id,
"dbus",
30))
static void
g_debug_controller_dbus_init (GDebugControllerDBus *dbus)
{
}
static void
set_debug_enabled (GDebugControllerDBus *self,
gboolean debug_enabled)
{
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
if (debug_enabled != priv->debug_enabled)
{
GVariantBuilder builder;
priv->debug_enabled = debug_enabled;
/* Change the default log writer’s behaviour in GLib. */
g_log_set_debug_enabled (debug_enabled);
/* Notify internally and externally of the property change. */
g_object_notify (G_OBJECT (self), "debug-enabled");
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{sv}", "DebugEnabled", g_variant_new_boolean (priv->debug_enabled));
g_dbus_connection_emit_signal (priv->connection,
NULL,
"/org/gtk/Debugging",
"org.gtk.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
"org.gtk.Debugging",
&builder,
NULL),
NULL);
g_debug ("Debug output %s", debug_enabled ? "enabled" : "disabled");
}
}
/* Called in the #GMainContext which was default when the #GDebugControllerDBus
* was initialised. */
static GVariant *
dbus_get_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GError **error,
gpointer user_data)
{
GDebugControllerDBus *self = user_data;
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
if (g_str_equal (property_name, "DebugEnabled"))
return g_variant_new_boolean (priv->debug_enabled);
g_assert_not_reached ();
return NULL;
}
/* Called in a worker thread. */
static void
authorize_task_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (source_object);
GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (task_data);
gboolean authorized = TRUE;
g_signal_emit (self, signals[SIGNAL_AUTHORIZE], 0, invocation, &authorized);
g_task_return_boolean (task, authorized);
}
/* Called in the #GMainContext which was default when the #GDebugControllerDBus
* was initialised. */
static void
authorize_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (object);
GTask *task = G_TASK (result);
GDBusMethodInvocation *invocation = g_task_get_task_data (task);
GVariant *parameters = g_dbus_method_invocation_get_parameters (invocation);
gboolean enabled = FALSE;
gboolean authorized;
authorized = g_task_propagate_boolean (task, NULL);
if (!authorized)
{
GError *local_error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED,
_("Not authorized to change debug settings"));
g_dbus_method_invocation_take_error (invocation, g_steal_pointer (&local_error));
return;
}
/* Update the property value. */
g_variant_get (parameters, "(b)", &enabled);
set_debug_enabled (self, enabled);
g_dbus_method_invocation_return_value (invocation, NULL);
}
/* Called in the #GMainContext which was default when the #GDebugControllerDBus
* was initialised. */
static void
dbus_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GDebugControllerDBus *self = user_data;
GDebugControllerDBusClass *klass = G_DEBUG_CONTROLLER_DBUS_GET_CLASS (self);
/* Only on the org.gtk.Debugging interface */
if (g_str_equal (method_name, "SetDebugEnabled"))
{
GTask *task = NULL;
task = g_task_new (self, NULL, authorize_cb, NULL);
g_task_set_source_tag (task, dbus_method_call);
g_task_set_task_data (task, g_object_ref (invocation), (GDestroyNotify) g_object_unref);
/* Check the calling peer is authorised to change the debug mode. So that
* the signal handler can block on checking polkit authorisation (which
* definitely involves D-Bus calls, and might involve user interaction),
* emit the #GDebugControllerDBus::authorize signal in a worker thread, so
* that handlers can synchronously block it. This is similar to how
* #GDBusInterfaceSkeleton::g-authorize-method works.
*
* If no signal handlers are connected, don’t bother running the worker
* thread, and just return a default value of %FALSE. Fail closed. */
if (g_signal_has_handler_pending (self, signals[SIGNAL_AUTHORIZE], 0, FALSE) ||
klass->authorize != g_debug_controller_dbus_authorize_default)
g_task_run_in_thread (task, authorize_task_cb);
else
g_task_return_boolean (task, FALSE);
g_clear_object (&task);
}
else
g_assert_not_reached ();
}
static gboolean
g_debug_controller_dbus_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (initable);
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
static const GDBusInterfaceVTable vtable = {
dbus_method_call,
dbus_get_property,
NULL /* set_property */,
{ 0 }
};
if (org_gtk_Debugging == NULL)
{
GError *local_error = NULL;
GDBusNodeInfo *info;
info = g_dbus_node_info_new_for_xml (org_gtk_Debugging_xml, &local_error);
if G_UNLIKELY (info == NULL)
g_error ("%s", local_error->message);
org_gtk_Debugging = g_dbus_node_info_lookup_interface (info, "org.gtk.Debugging");
g_assert (org_gtk_Debugging != NULL);
g_dbus_interface_info_ref (org_gtk_Debugging);
g_dbus_node_info_unref (info);
}
priv->object_id = g_dbus_connection_register_object (priv->connection,
"/org/gtk/Debugging",
org_gtk_Debugging,
&vtable, self, NULL, error);
if (priv->object_id == 0)
return FALSE;
return TRUE;
}
static void
g_debug_controller_dbus_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (object);
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
switch ((GDebugControllerDBusProperty) prop_id)
{
case PROP_CONNECTION:
g_value_set_object (value, priv->connection);
break;
case PROP_DEBUG_ENABLED:
g_value_set_boolean (value, priv->debug_enabled);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
g_debug_controller_dbus_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (object);
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
switch ((GDebugControllerDBusProperty) prop_id)
{
case PROP_CONNECTION:
/* Construct only */
g_assert (priv->connection == NULL);
priv->connection = g_value_dup_object (value);
break;
case PROP_DEBUG_ENABLED:
set_debug_enabled (self, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
g_debug_controller_dbus_dispose (GObject *object)
{
GDebugControllerDBus *self = G_DEBUG_CONTROLLER_DBUS (object);
GDebugControllerDBusPrivate *priv = g_debug_controller_dbus_get_instance_private (self);
if (priv->object_id != 0)
{
g_dbus_connection_unregister_object (priv->connection, priv->object_id);
priv->object_id = 0;
}
g_clear_object (&priv->connection);
G_OBJECT_CLASS (g_debug_controller_dbus_parent_class)->dispose (object);
}
static gboolean
g_debug_controller_dbus_authorize_default (GDebugControllerDBus *self,
GDBusMethodInvocation *invocation)
{
return TRUE;
}
static void
g_debug_controller_dbus_class_init (GDebugControllerDBusClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->get_property = g_debug_controller_dbus_get_property;
gobject_class->set_property = g_debug_controller_dbus_set_property;
gobject_class->dispose = g_debug_controller_dbus_dispose;
klass->authorize = g_debug_controller_dbus_authorize_default;
/**
* GDebugControllerDBus:connection:
*
* The D-Bus connection to expose the debugging interface on.
*
* Typically this will be the same connection (to the system or session bus)
* which the rest of the application or service’s D-Bus objects are registered
* on.
*
* Since: 2.72
*/
props[PROP_CONNECTION] =
g_param_spec_object ("connection", "D-Bus Connection",
"The D-Bus connection to expose the debugging interface on.",
G_TYPE_DBUS_CONNECTION,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (gobject_class, G_N_ELEMENTS (props), props);
g_object_class_override_property (gobject_class, PROP_DEBUG_ENABLED, "debug-enabled");
/**
* GDebugControllerDBus::authorize:
* @controller: The #GDebugControllerDBus emitting the signal.
* @invocation: A #GDBusMethodInvocation.
*
* Emitted when a D-Bus peer is trying to change the debug settings and used
* to determine if that is authorized.
*
* This signal is emitted in a dedicated worker thread, so handlers are
* allowed to perform blocking I/O. This means that, for example, it is
* appropriate to call `polkit_authority_check_authorization_sync()` to check
* authorization using polkit.
*
* If %FALSE is returned then no further handlers are run and the request to
* change the debug settings is rejected.
*
* Otherwise, if %TRUE is returned, signal emission continues. If no handlers
* return %FALSE, then the debug settings are allowed to be changed.
*
* Signal handlers must not modify @invocation, or cause it to return a value.
*
* The default class handler just returns %TRUE.
*
* Returns: %TRUE if the call is authorized, %FALSE otherwise.
*
* Since: 2.72
*/
signals[SIGNAL_AUTHORIZE] =
g_signal_new ("authorize",
G_TYPE_DEBUG_CONTROLLER_DBUS,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GDebugControllerDBusClass, authorize),
_g_signal_accumulator_false_handled,
NULL,
_g_cclosure_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN,
1,
G_TYPE_DBUS_METHOD_INVOCATION);
g_signal_set_va_marshaller (signals[SIGNAL_AUTHORIZE],
G_TYPE_FROM_CLASS (klass),
_g_cclosure_marshal_BOOLEAN__OBJECTv);
}
static void
g_debug_controller_dbus_iface_init (GDebugControllerInterface *iface)
{
}
static void
g_debug_controller_dbus_initable_iface_init (GInitableIface *iface)
{
iface->init = g_debug_controller_dbus_initable_init;
}
/**
* g_debug_controller_dbus_new:
* @connection: a #GDBusConnection to register the debug object on
* @cancellable: (nullable): a #GCancellable, or %NULL
* @error: return location for a #GError, or %NULL
*
* Create a new #GDebugControllerDBus and synchronously initialize it.
*
* Initializing the object will export the debug object on @connection. The
* object will remain registered until the last reference to the
* #GDebugControllerDBus is dropped.
*
* Initialization may fail if registering the object on @connection fails.
*
* Returns: (nullable) (transfer full): a new #GDebugControllerDBus, or %NULL
* on failure
* Since: 2.72
*/
GDebugControllerDBus *
g_debug_controller_dbus_new (GDBusConnection *connection,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
return g_initable_new (G_TYPE_DEBUG_CONTROLLER_DBUS,
cancellable,
error,
"connection", connection,
NULL);
}

66
gio/gdebugcontrollerdbus.h Normal file
View File

@ -0,0 +1,66 @@
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright © 2021 Endless OS Foundation, LLC
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#ifndef __G_DEBUG_CONTROLLER_DBUS_H__
#define __G_DEBUG_CONTROLLER_DBUS_H__
#include <glib.h>
#include <glib-object.h>
G_BEGIN_DECLS
/**
* GDebugControllerDBus:
*
* #GDebugControllerDBus is an implementation of #GDebugController over D-Bus.
*
* Since: 2.72
*/
#define G_TYPE_DEBUG_CONTROLLER_DBUS (g_debug_controller_dbus_get_type ())
GLIB_AVAILABLE_IN_2_72
G_DECLARE_DERIVABLE_TYPE (GDebugControllerDBus, g_debug_controller_dbus, G, DEBUG_CONTROLLER_DBUS, GObject)
/**
* GDebugControllerDBusClass:
* @parent_class: The parent class.
* @authorize: Default handler for the #GDebugControllerDBus::authorize signal.
*
* The virtual function table for #GDebugControllerDBus.
*
* Since: 2.72
*/
struct _GDebugControllerDBusClass
{
GObjectClass parent_class;
gboolean (*authorize) (GDebugControllerDBus *controller,
GDBusMethodInvocation *invocation);
gpointer padding[12];
};
GLIB_AVAILABLE_IN_2_72
GDebugControllerDBus *g_debug_controller_dbus_new (GDBusConnection *connection,
GCancellable *cancellable,
GError **error);
G_END_DECLS
#endif /* __G_DEBUG_CONTROLLER_DBUS_H__ */

2
gio/gio.h
View File

@ -69,6 +69,8 @@
#include <gio/gdbusproxy.h>
#include <gio/gdbusserver.h>
#include <gio/gdbusutils.h>
#include <gio/gdebugcontroller.h>
#include <gio/gdebugcontrollerdbus.h>
#include <gio/gdrive.h>
#include <gio/gdtlsclientconnection.h>
#include <gio/gdtlsconnection.h>

6
gio/giomodule.c
View File

@ -45,6 +45,8 @@
#include "gnotificationbackend.h"
#include "ginitable.h"
#include "gnetworkmonitor.h"
#include "gdebugcontroller.h"
#include "gdebugcontrollerdbus.h"
#include "gmemorymonitor.h"
#include "gmemorymonitorportal.h"
#include "gmemorymonitordbus.h"
@ -1082,6 +1084,7 @@ extern GType _g_network_monitor_netlink_get_type (void);
extern GType _g_network_monitor_nm_get_type (void);
#endif
extern GType g_debug_controller_dbus_get_type (void);
extern GType g_memory_monitor_dbus_get_type (void);
extern GType g_memory_monitor_portal_get_type (void);
extern GType g_memory_monitor_win32_get_type (void);
@ -1226,6 +1229,9 @@ _g_io_modules_ensure_extension_points_registered (void)
ep = g_io_extension_point_register (G_NOTIFICATION_BACKEND_EXTENSION_POINT_NAME);
g_io_extension_point_set_required_type (ep, G_TYPE_NOTIFICATION_BACKEND);
ep = g_io_extension_point_register (G_DEBUG_CONTROLLER_EXTENSION_POINT_NAME);
g_io_extension_point_set_required_type (ep, G_TYPE_DEBUG_CONTROLLER);
ep = g_io_extension_point_register (G_MEMORY_MONITOR_EXTENSION_POINT_NAME);
g_io_extension_point_set_required_type (ep, G_TYPE_MEMORY_MONITOR);

4
gio/meson.build
View File

@ -465,6 +465,8 @@ gio_sources = files(
'gdatagrambased.c',
'gdatainputstream.c',
'gdataoutputstream.c',
'gdebugcontroller.c',
'gdebugcontrollerdbus.c',
'gdrive.c',
'gdummyfile.c',
'gdummyproxyresolver.c',
@ -615,6 +617,8 @@ gio_headers = files(
'gdatagrambased.h',
'gdatainputstream.h',
'gdataoutputstream.h',
'gdebugcontroller.h',
'gdebugcontrollerdbus.h',
'gdrive.h',
'gemblem.h',
'gemblemedicon.h',

46
glib/gmessages.c
View File

@ -525,6 +525,7 @@ static gpointer fatal_log_data;
static GLogWriterFunc log_writer_func = g_log_writer_default;
static gpointer log_writer_user_data = NULL;
static GDestroyNotify log_writer_user_data_free = NULL;
static gboolean g_log_debug_enabled = FALSE; /* (atomic) */
/* --- functions --- */
@ -2650,7 +2651,9 @@ should_drop_message (GLogLevelFlags log_level,
gsize n_fields)
{
/* Disable debug message output unless specified in G_MESSAGES_DEBUG. */
if (!(log_level & DEFAULT_LEVELS) && !(log_level >> G_LOG_LEVEL_USER_SHIFT))
if (!(log_level & DEFAULT_LEVELS) &&
!(log_level >> G_LOG_LEVEL_USER_SHIFT) &&
!g_log_get_debug_enabled ())
{
const gchar *domains;
gsize i;
@ -2881,6 +2884,47 @@ _g_log_writer_fallback (GLogLevelFlags log_level,
return G_LOG_WRITER_HANDLED;
}
/**
* g_log_get_debug_enabled:
*
* Return whether debug output from the GLib logging system is enabled.
*
* Note that this should not be used to conditionalise calls to g_debug() or
* other logging functions; it should only be used from %GLogWriterFunc
* implementations.
*
* Note also that the value of this does not depend on `G_MESSAGES_DEBUG`, as
* it is domain-dependent.
*
* Returns: %TRUE if debug output is enabled, %FALSE otherwise
*
* Since: 2.72
*/
gboolean
g_log_get_debug_enabled (void)
{
return g_atomic_int_get (&g_log_debug_enabled);
}
/**
* g_log_set_debug_enabled:
* @enabled: %TRUE to enable debug output, %FALSE otherwise
*
* Enable or disable debug output from the GLib logging system is enabled. This
* value interacts disjunctively with `G_MESSAGES_DEBUG` — if either of them
* would allow a debug message to be outputted, it will be.
*
* Note that this should not be used from within library code to enable debug
* output — it is intended for external use.
*
* Since: 2.72
*/
void
g_log_set_debug_enabled (gboolean enabled)
{
g_atomic_int_set (&g_log_debug_enabled, enabled);
}
/**
* g_return_if_fail_warning: (skip)
* @log_domain: (nullable): log domain

6
glib/gmessages.h
View File

@ -249,6 +249,12 @@ GLIB_AVAILABLE_IN_2_68
gboolean g_log_writer_default_would_drop (GLogLevelFlags log_level,
const char *log_domain);
/* G_MESSAGES_DEBUG enablement */
GLIB_AVAILABLE_IN_2_72
gboolean g_log_get_debug_enabled (void);
GLIB_AVAILABLE_IN_2_72
void g_log_set_debug_enabled (gboolean enabled);
/**
* G_DEBUG_HERE:
*

1
po/POTFILES.in
View File

@ -39,6 +39,7 @@ gio/gdbusprivate.c
gio/gdbusproxy.c
gio/gdbusserver.c
gio/gdbus-tool.c
gio/gdebugcontrollerdbus.c
gio/gdesktopappinfo.c
gio/gdrive.c
gio/gdtlsclientconnection.c