rpms/mutter
7
0
Fork 0
Code Issues Pull Requests Releases Activity
6ce38be1d9
mutter/0004-window-Track-workspace-per-cgroup.patch

686 lines
23 KiB
Diff
Raw Blame History

From 9befece38b28581958d87d9393ff9c788213d2fb Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Thu, 13 Jun 2024 13:47:01 -0400
Subject: [PATCH 4/6] window: Track workspace per-cgroup
If an application doesn't tell us what workspace to start on we
need to guess. Currently our guess is "currently active workspace",
but that's not really always the best choice.
This commit adds code to track the workspace other windows in the
same cgroup (~application) are running on and uses that to decide
which workspace to start on instead.
---
src/core/display-private.h | 6 ++++++
src/core/display.c | 31 +++++++++++++++++++++++++++++++
src/core/window-private.h | 1 +
src/core/window.c | 36 ++++++++++++++++++++++++++++++++----
4 files changed, 70 insertions(+), 4 deletions(-)
diff --git a/src/core/display-private.h b/src/core/display-private.h
index fb17d20a6..2b8d9e0d0 100644
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -81,60 +81,63 @@ typedef enum
} MetaTileMode;
typedef enum
{
/* Normal interaction where you're interacting with windows.
* Events go to windows normally. */
META_EVENT_ROUTE_NORMAL,
/* In a window operation like moving or resizing. All events
* goes to MetaWindow, but not to the actual client window. */
META_EVENT_ROUTE_WINDOW_OP,
/* In a compositor grab operation. All events go to the
* compositor plugin. */
META_EVENT_ROUTE_COMPOSITOR_GRAB,
/* A Wayland application has a popup open. All events go to
* the Wayland application. */
META_EVENT_ROUTE_WAYLAND_POPUP,
/* The user is clicking on a window button. */
META_EVENT_ROUTE_FRAME_BUTTON,
} MetaEventRoute;
typedef void (* MetaDisplayWindowFunc) (MetaWindow *window,
gpointer user_data);
typedef struct _MetaCGroup MetaCGroup;
struct _MetaCGroup {
GFile *path;
+ guint32 user_time;
+ MetaWorkspace *last_active_workspace;
+ gboolean has_startup_sequence;
grefcount ref_count;
};
struct _MetaDisplay
{
GObject parent_instance;
MetaX11Display *x11_display;
int clutter_event_filter;
/* Our best guess as to the "currently" focused window (that is, the
* window that we expect will be focused at the point when the X
* server processes our next request), and the serial of the request
* or event that caused this.
*/
MetaWindow *focus_window;
/* last timestamp passed to XSetInputFocus */
guint32 last_focus_time;
/* last user interaction time in any app */
guint32 last_user_time;
/* whether we're using mousenav (only relevant for sloppy&mouse focus modes;
* !mouse_mode means "keynav mode")
*/
guint mouse_mode : 1;
@@ -270,60 +273,63 @@ struct _MetaDisplayClass
gboolean meta_display_open (void);
void meta_display_manage_all_xwindows (MetaDisplay *display);
void meta_display_unmanage_windows (MetaDisplay *display,
guint32 timestamp);
/* Utility function to compare the stacking of two windows */
int meta_display_stack_cmp (const void *a,
const void *b);
/* Each MetaWindow is uniquely identified by a 64-bit "stamp"; unlike a
* a MetaWindow *, a stamp will never be recycled
*/
MetaWindow* meta_display_lookup_stamp (MetaDisplay *display,
guint64 stamp);
void meta_display_register_stamp (MetaDisplay *display,
guint64 *stampp,
MetaWindow *window);
void meta_display_unregister_stamp (MetaDisplay *display,
guint64 stamp);
void meta_display_register_cgroup (MetaDisplay *display,
MetaWindow *window,
const char *path);
void meta_display_unregister_cgroup (MetaDisplay *display,
MetaWindow *window);
MetaCGroup* meta_cgroup_ref (MetaCGroup *cgroup);
gboolean meta_cgroup_unref (MetaCGroup *cgroup);
+void meta_cgroup_update_workspace (MetaCGroup *cgroup,
+ MetaWorkspace *workspace,
+ guint32 timestamp);
/* A "stack id" is a XID or a stamp */
#define META_STACK_ID_IS_X11(id) ((id) < G_GUINT64_CONSTANT(0x100000000))
META_EXPORT_TEST
MetaWindow* meta_display_lookup_stack_id (MetaDisplay *display,
guint64 stack_id);
/* for debug logging only; returns a human-description of the stack
* ID - a small number of buffers are recycled, so the result must
* be used immediately or copied */
const char *meta_display_describe_stack_id (MetaDisplay *display,
guint64 stack_id);
void meta_display_register_wayland_window (MetaDisplay *display,
MetaWindow *window);
void meta_display_unregister_wayland_window (MetaDisplay *display,
MetaWindow *window);
void meta_display_notify_window_created (MetaDisplay *display,
MetaWindow *window);
META_EXPORT_TEST
GSList* meta_display_list_windows (MetaDisplay *display,
MetaListWindowsFlags flags);
MetaDisplay* meta_display_for_x_display (Display *xdisplay);
META_EXPORT_TEST
MetaDisplay* meta_get_display (void);
diff --git a/src/core/display.c b/src/core/display.c
index 937defd2c..f30f9a268 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -1524,94 +1524,121 @@ MetaCGroup*
meta_cgroup_new (const char *path)
{
MetaCGroup *cgroup;
cgroup = g_new0 (MetaCGroup, 1);
cgroup->path = g_file_new_for_path (path);
g_ref_count_init (&cgroup->ref_count);
return cgroup;
}
MetaCGroup*
meta_cgroup_ref (MetaCGroup *cgroup)
{
g_ref_count_inc (&cgroup->ref_count);
return cgroup;
}
gboolean
meta_cgroup_unref (MetaCGroup *cgroup)
{
if (!g_ref_count_dec (&cgroup->ref_count))
return FALSE;
g_clear_object (&cgroup->path);
g_free (cgroup);
return TRUE;
}
+void
+meta_cgroup_update_workspace (MetaCGroup *cgroup,
+ MetaWorkspace *workspace,
+ guint32 timestamp)
+{
+ if (!cgroup)
+ return;
+
+ if (!XSERVER_TIME_IS_BEFORE (cgroup->user_time, timestamp))
+ return;
+
+ cgroup->user_time = timestamp;
+
+ if (cgroup->last_active_workspace)
+ g_object_remove_weak_pointer (G_OBJECT (cgroup->last_active_workspace),
+ (gpointer *) &cgroup->last_active_workspace);
+
+ cgroup->last_active_workspace = workspace;
+
+ g_object_add_weak_pointer (G_OBJECT (workspace),
+ (gpointer *) &cgroup->last_active_workspace);
+}
+
void
meta_display_register_cgroup (MetaDisplay *display,
MetaWindow *window,
const char *path)
{
MetaCGroup *cgroup;
cgroup = g_hash_table_lookup (display->cgroups, path);
if (cgroup)
{
window->cgroup = meta_cgroup_ref (cgroup);
return;
}
cgroup = meta_cgroup_new (path);
g_hash_table_insert (display->cgroups, g_file_get_path (cgroup->path), cgroup);
}
void
meta_display_unregister_cgroup (MetaDisplay *display,
MetaWindow *window)
{
g_autofree const char *path = NULL;
MetaCGroup *cgroup = g_steal_pointer (&window->cgroup);
if (!cgroup)
return;
path = g_file_get_path (cgroup->path);
if (!meta_cgroup_unref (cgroup))
return;
+ if (cgroup->last_active_workspace)
+ g_object_remove_weak_pointer (G_OBJECT (cgroup->last_active_workspace),
+ (gpointer *) &cgroup->last_active_workspace);
+
g_hash_table_remove (display->cgroups, path);
}
MetaWindow*
meta_display_lookup_stamp (MetaDisplay *display,
guint64 stamp)
{
return g_hash_table_lookup (display->stamps, &stamp);
}
void
meta_display_register_stamp (MetaDisplay *display,
guint64 *stampp,
MetaWindow *window)
{
g_return_if_fail (g_hash_table_lookup (display->stamps, stampp) == NULL);
g_hash_table_insert (display->stamps, stampp, window);
}
void
meta_display_unregister_stamp (MetaDisplay *display,
guint64 stamp)
{
g_return_if_fail (g_hash_table_lookup (display->stamps, &stamp) != NULL);
g_hash_table_remove (display->stamps, &stamp);
}
MetaWindow*
@@ -3374,60 +3401,64 @@ meta_display_apply_startup_properties (MetaDisplay *display,
meta_startup_sequence_get_id (sequence),
window->desc);
meta_startup_sequence_complete (sequence);
}
}
/* Still no startup ID? Bail. */
if (!startup_id)
return FALSE;
/* We might get this far and not know the sequence ID (if the window
* already had a startup ID stored), so let's look for one if we don't
* already know it.
*/
if (sequence == NULL)
{
sequence =
meta_startup_notification_lookup_sequence (display->startup_notification,
startup_id);
}
if (sequence != NULL)
{
gboolean changed_something = FALSE;
meta_topic (META_DEBUG_STARTUP,
"Found startup sequence for window %s ID \"%s\"",
window->desc, startup_id);
+ meta_window_read_cgroup (window);
+ if (window->cgroup)
+ window->cgroup->has_startup_sequence = TRUE;
+
if (!window->initial_workspace_set)
{
int space = meta_startup_sequence_get_workspace (sequence);
if (space >= 0)
{
meta_topic (META_DEBUG_STARTUP,
"Setting initial window workspace to %d based on startup info",
space);
window->initial_workspace_set = TRUE;
window->initial_workspace = space;
changed_something = TRUE;
}
}
if (!window->initial_timestamp_set)
{
guint32 timestamp = meta_startup_sequence_get_timestamp (sequence);
meta_topic (META_DEBUG_STARTUP,
"Setting initial window timestamp to %u based on startup info",
timestamp);
window->initial_timestamp_set = TRUE;
window->initial_timestamp = timestamp;
changed_something = TRUE;
}
return changed_something;
}
else
diff --git a/src/core/window-private.h b/src/core/window-private.h
index 8a0aebb38..41782aa99 100644
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -860,31 +860,32 @@ void meta_window_update_resize (MetaWindow *window,
MetaEdgeResistanceFlags flags,
int x, int y,
gboolean force);
void meta_window_move_resize_internal (MetaWindow *window,
MetaMoveResizeFlags flags,
MetaGravity gravity,
MetaRectangle frame_rect);
void meta_window_grab_op_began (MetaWindow *window, MetaGrabOp op);
void meta_window_grab_op_ended (MetaWindow *window, MetaGrabOp op);
void meta_window_set_alive (MetaWindow *window, gboolean is_alive);
gboolean meta_window_has_pointer (MetaWindow *window);
void meta_window_emit_size_changed (MetaWindow *window);
MetaPlacementRule *meta_window_get_placement_rule (MetaWindow *window);
void meta_window_force_placement (MetaWindow *window,
gboolean force_move);
void meta_window_force_restore_shortcuts (MetaWindow *window,
ClutterInputDevice *source);
gboolean meta_window_shortcuts_inhibited (MetaWindow *window,
ClutterInputDevice *source);
gboolean meta_window_is_stackable (MetaWindow *window);
gboolean meta_window_is_focus_async (MetaWindow *window);
+void meta_window_read_cgroup (MetaWindow *window);
#endif
diff --git a/src/core/window.c b/src/core/window.c
index f5ecd6438..5c7b2e8cf 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -1296,79 +1296,88 @@ _meta_window_shared_new (MetaDisplay *display,
* added to all the MRU lists
*/
window->on_all_workspaces_requested = TRUE;
on_all_workspaces = TRUE;
}
else if (!on_all_workspaces)
{
meta_topic (META_DEBUG_PLACEMENT,
"Window %s is initially on space %d",
window->desc, window->initial_workspace);
workspace = meta_workspace_manager_get_workspace_by_index (workspace_manager,
window->initial_workspace);
}
/* Ignore when a window requests to be placed on a non-existent workspace
*/
if (on_all_workspaces || workspace != NULL)
set_workspace_state (window, on_all_workspaces, workspace);
}
/* override-redirect windows are subtly different from other windows
* with window->on_all_workspaces == TRUE. Other windows are part of
* some workspace (so they can return to that if the flag is turned off),
* but appear on other workspaces. override-redirect windows are part
* of no workspace.
*/
if (!window->override_redirect && window->workspace == NULL)
{
+ meta_window_read_cgroup (window);
if (window->transient_for != NULL)
{
meta_topic (META_DEBUG_PLACEMENT,
"Putting window %s on same workspace as parent %s",
window->desc, window->transient_for->desc);
g_warn_if_fail (!window->transient_for->override_redirect);
set_workspace_state (window,
window->transient_for->on_all_workspaces,
window->transient_for->workspace);
}
else if (window->on_all_workspaces)
{
meta_topic (META_DEBUG_PLACEMENT,
"Putting window %s on all workspaces",
window->desc);
set_workspace_state (window, TRUE, NULL);
}
+ else if (window->cgroup && window->cgroup->last_active_workspace != NULL &&
+ !window->cgroup->has_startup_sequence)
+ {
+ meta_topic (META_DEBUG_PLACEMENT,
+ "Putting window %s on active workspace",
+ window->desc);
+ set_workspace_state (window, FALSE, window->cgroup->last_active_workspace);
+ }
else
{
meta_topic (META_DEBUG_PLACEMENT,
"Putting window %s on active workspace",
window->desc);
set_workspace_state (window, FALSE, workspace_manager->active_workspace);
}
meta_window_update_struts (window);
}
meta_window_main_monitor_changed (window, NULL);
/* Must add window to stack before doing move/resize, since the
* window might have fullscreen size (i.e. should have been
* fullscreen'd; acrobat is one such braindead case; it withdraws
* and remaps its window whenever trying to become fullscreen...)
* and thus constraints may try to auto-fullscreen it which also
* means restacking it.
*/
if (meta_window_is_stackable (window))
meta_stack_add (window->display->stack,
window);
else if (window->override_redirect)
window->layer = META_LAYER_OVERRIDE_REDIRECT; /* otherwise set by MetaStack */
if (!window->override_redirect)
{
/* FIXME we have a tendency to set this then immediately
@@ -3736,63 +3745,71 @@ meta_window_activate_full (MetaWindow *window,
"by client type %u.",
window->desc, timestamp, source_indication);
if (window->display->last_user_time == timestamp)
{
/* Only allow workspace switches if this activation message uses the same
* timestamp as the last user interaction
*/
allow_workspace_switch = TRUE;
}
if (timestamp != 0 &&
XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time))
{
meta_topic (META_DEBUG_FOCUS,
"last_user_time (%u) is more recent; ignoring "
" _NET_ACTIVE_WINDOW message.",
window->display->last_user_time);
meta_window_set_demands_attention(window);
return;
}
if (timestamp == 0)
timestamp = meta_display_get_current_time_roundtrip (window->display);
meta_window_set_user_time (window, timestamp);
/* disable show desktop mode unless we're a desktop component */
maybe_leave_show_desktop_mode (window);
- /* Get window on current or given workspace */
- if (workspace == NULL)
- workspace = workspace_manager->active_workspace;
+ /* Get window on last active, current, or given workspace */
+ if (workspace == NULL)
+ {
+ meta_window_read_cgroup (window);
+ if (window->cgroup &&
+ window->cgroup->last_active_workspace != NULL &&
+ !window->cgroup->has_startup_sequence)
+ workspace = window->cgroup->last_active_workspace;
+ else
+ workspace = workspace_manager->active_workspace;
+ }
/* For non-transient windows, we just set up a pulsing indicator,
rather than move windows or workspaces.
See http://bugzilla.gnome.org/show_bug.cgi?id=482354 */
if (window->transient_for == NULL &&
!allow_workspace_switch &&
!meta_window_located_on_workspace (window, workspace))
{
meta_window_set_demands_attention (window);
/* We've marked it as demanding, don't need to do anything else. */
return;
}
else if (window->transient_for != NULL)
{
/* Move transients to current workspace - preference dialogs should appear over
the source window. */
meta_window_change_workspace (window, workspace);
}
if (window->shaded)
meta_window_unshade (window, timestamp);
unminimize_window_and_all_transient_parents (window);
if (meta_prefs_get_raise_on_click () ||
source_indication == META_CLIENT_TYPE_PAGER)
meta_window_raise (window);
meta_topic (META_DEBUG_FOCUS,
"Focusing window %s due to activation",
@@ -7165,60 +7182,71 @@ meta_window_set_user_time (MetaWindow *window,
g_return_if_fail (!window->override_redirect);
/* Only update the time if this timestamp is newer... */
if (window->net_wm_user_time_set &&
XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
{
meta_topic (META_DEBUG_STARTUP,
"Window %s _NET_WM_USER_TIME not updated to %u, because it "
"is less than %u",
window->desc, timestamp, window->net_wm_user_time);
}
else
{
meta_topic (META_DEBUG_STARTUP,
"Window %s has _NET_WM_USER_TIME of %u",
window->desc, timestamp);
window->net_wm_user_time_set = TRUE;
window->net_wm_user_time = timestamp;
if (XSERVER_TIME_IS_BEFORE (window->display->last_user_time, timestamp))
window->display->last_user_time = timestamp;
/* If this is a terminal, user interaction with it means the user likely
* doesn't want to have focus transferred for now due to new windows.
*/
if (meta_prefs_get_focus_new_windows () == G_DESKTOP_FOCUS_NEW_WINDOWS_STRICT &&
window_is_terminal (window))
window->display->allow_terminal_deactivation = FALSE;
g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_USER_TIME]);
}
+
+ if (!window->cgroup)
+ meta_window_read_cgroup (window);
+
+ if (window->cgroup)
+ {
+ MetaWorkspace *workspace = meta_window_get_workspace (window);
+
+ if (workspace)
+ meta_cgroup_update_workspace (window->cgroup, workspace, timestamp);
+ }
}
/**
* meta_window_get_stable_sequence:
* @window: A #MetaWindow
*
* The stable sequence number is a monotonicially increasing
* unique integer assigned to each #MetaWindow upon creation.
*
* This number can be useful for sorting windows in a stable
* fashion.
*
* Returns: Internal sequence number for this window
*/
guint32
meta_window_get_stable_sequence (MetaWindow *window)
{
g_return_val_if_fail (META_IS_WINDOW (window), 0);
return window->stable_sequence;
}
/* Sets the demands_attention hint on a window, but only
* if it's at least partially obscured (see #305882).
*/
void
meta_window_set_demands_attention (MetaWindow *window)
{
MetaWorkspaceManager *workspace_manager = window->display->workspace_manager;
MetaRectangle candidate_rect, other_rect;
@@ -7649,61 +7677,61 @@ meta_window_get_transient_for (MetaWindow *window)
else if (window->xtransient_for)
return meta_x11_display_lookup_x_window (window->display->x11_display,
window->xtransient_for);
else
return NULL;
}
/**
* meta_window_get_pid:
* @window: a #MetaWindow
*
* Returns the pid of the process that created this window, if available
* to the windowing system.
*
* Note that the value returned by this is vulnerable to spoofing attacks
* by the client.
*
* Return value: the pid, or 0 if not known.
*/
pid_t
meta_window_get_pid (MetaWindow *window)
{
g_return_val_if_fail (META_IS_WINDOW (window), 0);
if (window->client_pid == 0)
window->client_pid = META_WINDOW_GET_CLASS (window)->get_client_pid (window);
return window->client_pid;
}
-static void
+void
meta_window_read_cgroup (MetaWindow *window)
{
#ifdef HAVE_LIBSYSTEMD
g_autofree char *contents = NULL;
g_autofree char *complete_path = NULL;
g_autofree char *unit_name = NULL;
g_autofree char *unit_path = NULL;
char *unit_end;
pid_t pid;
if (window->cgroup)
return;
pid = meta_window_get_pid (window);
if (pid < 1)
return;
if (sd_pid_get_cgroup (pid, &contents) < 0)
return;
g_strstrip (contents);
complete_path = g_strdup_printf ("%s%s", "/sys/fs/cgroup", contents);
if (sd_pid_get_user_unit (pid, &unit_name) < 0)
return;
g_strstrip (unit_name);
unit_end = strstr (complete_path, unit_name) + strlen (unit_name);
*unit_end = '\0';
--
2.44.0
Reference in New Issue View Git Blame Copy Permalink