From b5bacf2b5e5d9e58cbe96fda0a56baf5dfa11358 Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Wed, 10 Oct 2018 20:07:37 +0100

Subject: [PATCH] device-manager: don't watch for udev events when deactivated

If a device gets added when we're already deactivated, plymouth shouldn't

process the device, since processing it effectively activates plymouth.

This commit pulls the udev monitor fd out of the event loop while

plymouth is deactivated so new events are deferred until reactivation.

Modified by Iain Lane <iain.lane@canonical.com>: Also deactivate the

timer that finds all devices known to udev after an interval, when

paused.

---

 src/libply-splash-core/ply-device-manager.c | 74 +++++++++++++++++----

 src/libply-splash-core/ply-device-manager.h |  2 +

 src/main.c                                  |  3 +

 3 files changed, 67 insertions(+), 12 deletions(-)

diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c

index b637fb8..82f0137 100644

--- a/src/libply-splash-core/ply-device-manager.c

+++ b/src/libply-splash-core/ply-device-manager.c

@@ -36,74 +36,78 @@

 #include "ply-logger.h"

 #include "ply-event-loop.h"

 #include "ply-hashtable.h"

 #include "ply-list.h"

 #include "ply-utils.h"

 #define SUBSYSTEM_DRM "drm"

 #define SUBSYSTEM_FRAME_BUFFER "graphics"

 #ifdef HAVE_UDEV

 static void create_devices_from_udev (ply_device_manager_t *manager);

 #endif

 static bool create_devices_for_terminal_and_renderer_type (ply_device_manager_t *manager,

                                                            const char           *device_path,

                                                            ply_terminal_t       *terminal,

                                                            ply_renderer_type_t   renderer_type);

 struct _ply_device_manager

 {

         ply_device_manager_flags_t flags;

         ply_event_loop_t          *loop;

         ply_hashtable_t           *terminals;

         ply_hashtable_t           *renderers;

         ply_terminal_t            *local_console_terminal;

         ply_list_t                *keyboards;

         ply_list_t                *text_displays;

         ply_list_t                *pixel_displays;

         struct udev               *udev_context;

         struct udev_monitor       *udev_monitor;

+        ply_fd_watch_t            *fd_watch;

         ply_keyboard_added_handler_t         keyboard_added_handler;

         ply_keyboard_removed_handler_t       keyboard_removed_handler;

         ply_pixel_display_added_handler_t    pixel_display_added_handler;

         ply_pixel_display_removed_handler_t  pixel_display_removed_handler;

         ply_text_display_added_handler_t     text_display_added_handler;

         ply_text_display_removed_handler_t   text_display_removed_handler;

         void                                *event_handler_data;

         uint32_t                    local_console_managed : 1;

         uint32_t                    local_console_is_text : 1;

         uint32_t                    serial_consoles_detected : 1;

         uint32_t                    renderers_activated : 1;

         uint32_t                    keyboards_activated : 1;

+

+        uint32_t                    paused : 1;

+        uint32_t                    device_timeout_elapsed : 1;

 };

 static void

 detach_from_event_loop (ply_device_manager_t *manager)

 {

         assert (manager != NULL);

         manager->loop = NULL;

 }

 static void

 attach_to_event_loop (ply_device_manager_t *manager,

                       ply_event_loop_t     *loop)

 {

         assert (manager != NULL);

         assert (loop != NULL);

         assert (manager->loop == NULL);

         manager->loop = loop;

         ply_event_loop_watch_for_exit (loop, (ply_event_loop_exit_handler_t)

                                        detach_from_event_loop,

                                        manager);

 }

 static void

 free_displays_for_renderer (ply_device_manager_t *manager,

                             ply_renderer_t       *renderer)

 {

         ply_list_node_t *node;

@@ -348,77 +352,92 @@ on_udev_event (ply_device_manager_t *manager)

                 return;

         if (strcmp (action, "add") == 0) {

                 const char *subsystem;

                 subsystem = udev_device_get_subsystem (device);

                 if (strcmp (subsystem, SUBSYSTEM_DRM) == 0) {

                         if (manager->local_console_managed && manager->local_console_is_text)

                                 ply_trace ("ignoring since we're already using text splash for local console");

                         else

                                 create_devices_for_udev_device (manager, device);

                 } else {

                         ply_trace ("ignoring since we only handle subsystem %s devices after timeout", subsystem);

                 }

         } else if (strcmp (action, "remove") == 0) {

                 free_devices_for_udev_device (manager, device);

         }

         udev_device_unref (device);

 }

 static void

 watch_for_udev_events (ply_device_manager_t *manager)

 {

         int fd;

         assert (manager != NULL);

         assert (manager->udev_monitor == NULL);

+        if (manager->fd_watch != NULL)

+                return;

+

         ply_trace ("watching for udev graphics device add and remove events");

-        manager->udev_monitor = udev_monitor_new_from_netlink (manager->udev_context, "udev");

+        if (manager->udev_monitor == NULL) {

+                manager->udev_monitor = udev_monitor_new_from_netlink (manager->udev_context, "udev");

-        udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, SUBSYSTEM_DRM, NULL);

-        udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, SUBSYSTEM_FRAME_BUFFER, NULL);

-        udev_monitor_filter_add_match_tag (manager->udev_monitor, "seat");

-        udev_monitor_enable_receiving (manager->udev_monitor);

+                udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, SUBSYSTEM_DRM, NULL);

+                udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, SUBSYSTEM_FRAME_BUFFER, NULL);

+                udev_monitor_filter_add_match_tag (manager->udev_monitor, "seat");

+                udev_monitor_enable_receiving (manager->udev_monitor);

+        }

         fd = udev_monitor_get_fd (manager->udev_monitor);

-        ply_event_loop_watch_fd (manager->loop,

-                                 fd,

-                                 PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,

-                                 (ply_event_handler_t)

-                                 on_udev_event,

-                                 NULL,

-                                 manager);

+        manager->fd_watch = ply_event_loop_watch_fd (manager->loop,

+                                                     fd,

+                                                     PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,

+                                                     (ply_event_handler_t)

+                                                     on_udev_event,

+                                                     NULL,

+                                                     manager);

+}

+

+static void

+stop_watching_for_udev_events (ply_device_manager_t *manager)

+{

+        if (manager->fd_watch == NULL)

+                return;

+

+        ply_event_loop_stop_watching_fd (manager->loop, manager->fd_watch);

+        manager->fd_watch = NULL;

 }

 #endif

 static void

 free_terminal (char                 *device,

                ply_terminal_t       *terminal,

                ply_device_manager_t *manager)

 {

         ply_hashtable_remove (manager->terminals, device);

         ply_terminal_free (terminal);

 }

 static void

 free_terminals (ply_device_manager_t *manager)

 {

         ply_hashtable_foreach (manager->terminals,

                                (ply_hashtable_foreach_func_t *)

                                free_terminal,

                                manager);

 }

 static ply_terminal_t *

 get_terminal (ply_device_manager_t *manager,

               const char           *device_name)

 {

         char *full_name = NULL;

         ply_terminal_t *terminal;

         if (strncmp (device_name, "/dev/", strlen ("/dev/")) == 0)

@@ -774,60 +793,67 @@ create_devices_from_terminals (ply_device_manager_t *manager)

         if (has_serial_consoles) {

                 ply_trace ("serial consoles detected, managing them with details forced");

                 manager->serial_consoles_detected = true;

                 ply_hashtable_foreach (manager->terminals,

                                        (ply_hashtable_foreach_func_t *)

                                        create_devices_for_terminal,

                                        manager);

                 return true;

         }

         return false;

 }

 static void

 create_non_graphical_devices (ply_device_manager_t *manager)

 {

         create_devices_for_terminal_and_renderer_type (manager,

                                                        NULL,

                                                        manager->local_console_terminal,

                                                        PLY_RENDERER_TYPE_NONE);

 }

 #ifdef HAVE_UDEV

 static void

 create_devices_from_udev (ply_device_manager_t *manager)

 {

         bool found_drm_device, found_fb_device;

+        manager->device_timeout_elapsed = true;

+

+        if (manager->paused) {

+                ply_trace ("create_devices_from_udev timeout elapsed while paused, deferring execution");

+                return;

+        }

+

         ply_trace ("Timeout elapsed, looking for devices from udev");

         found_drm_device = create_devices_for_subsystem (manager, SUBSYSTEM_DRM);

         found_fb_device = create_devices_for_subsystem (manager, SUBSYSTEM_FRAME_BUFFER);

         if (found_drm_device || found_fb_device)

                 return;

         ply_trace ("Creating non-graphical devices, since there's no suitable graphics hardware");

         create_non_graphical_devices (manager);

 }

 #endif

 static void

 create_fallback_devices (ply_device_manager_t *manager)

 {

         create_devices_for_terminal_and_renderer_type (manager,

                                                        NULL,

                                                        manager->local_console_terminal,

                                                        PLY_RENDERER_TYPE_AUTO);

 }

 void

 ply_device_manager_watch_devices (ply_device_manager_t                *manager,

                                   double                               device_timeout,

                                   ply_keyboard_added_handler_t         keyboard_added_handler,

                                   ply_keyboard_removed_handler_t       keyboard_removed_handler,

                                   ply_pixel_display_added_handler_t    pixel_display_added_handler,

                                   ply_pixel_display_removed_handler_t  pixel_display_removed_handler,

                                   ply_text_display_added_handler_t     text_display_added_handler,

@@ -965,30 +991,54 @@ ply_device_manager_activate_keyboards (ply_device_manager_t *manager)

                 ply_keyboard_watch_for_input (keyboard);

                 node = next_node;

         }

         manager->keyboards_activated = true;

 }

 void

 ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager)

 {

         ply_list_node_t *node;

         ply_trace ("deactivating keyboards");

         node = ply_list_get_first_node (manager->keyboards);

         while (node != NULL) {

                 ply_keyboard_t *keyboard;

                 ply_list_node_t *next_node;

                 keyboard = ply_list_node_get_data (node);

                 next_node = ply_list_get_next_node (manager->keyboards, node);

                 ply_keyboard_stop_watching_for_input (keyboard);

                 node = next_node;

         }

         manager->keyboards_activated = false;

 }

+

+void

+ply_device_manager_pause (ply_device_manager_t *manager)

+{

+        ply_trace ("ply_device_manager_pause() called, stopping watching for udev events");

+        manager->paused = true;

+#ifdef HAVE_UDEV

+        stop_watching_for_udev_events (manager);

+#endif

+}

+

+void

+ply_device_manager_unpause (ply_device_manager_t *manager)

+{

+        ply_trace ("ply_device_manager_unpause() called, resuming watching for udev events");

+        manager->paused = false;

+#ifdef HAVE_UDEV

+        if (manager->device_timeout_elapsed) {

+                ply_trace ("ply_device_manager_unpause(): timeout elapsed while paused, looking for udev devices");

+                create_devices_from_udev (manager);

+        }

+        watch_for_udev_events (manager);

+#endif

+}

diff --git a/src/libply-splash-core/ply-device-manager.h b/src/libply-splash-core/ply-device-manager.h

index ad05897..389b636 100644

--- a/src/libply-splash-core/ply-device-manager.h

+++ b/src/libply-splash-core/ply-device-manager.h

@@ -28,46 +28,48 @@

 #include "ply-text-display.h"

 typedef enum

 {

         PLY_DEVICE_MANAGER_FLAGS_NONE = 0,

         PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES = 1 << 0,

         PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV = 1 << 1,

         PLY_DEVICE_MANAGER_FLAGS_SKIP_RENDERERS = 1 << 2

 } ply_device_manager_flags_t;

 typedef struct _ply_device_manager ply_device_manager_t;

 typedef void (* ply_keyboard_added_handler_t) (void *, ply_keyboard_t *);

 typedef void (* ply_keyboard_removed_handler_t) (void *, ply_keyboard_t *);

 typedef void (* ply_pixel_display_added_handler_t) (void *, ply_pixel_display_t *);

 typedef void (* ply_pixel_display_removed_handler_t) (void *, ply_pixel_display_t *);

 typedef void (* ply_text_display_added_handler_t) (void *, ply_text_display_t *);

 typedef void (* ply_text_display_removed_handler_t) (void *, ply_text_display_t *);

 #ifndef PLY_HIDE_FUNCTION_DECLARATIONS

 ply_device_manager_t *ply_device_manager_new (const char                *default_tty,

                                               ply_device_manager_flags_t flags);

 void ply_device_manager_watch_devices (ply_device_manager_t                *manager,

                                        double                               device_timeout,

                                        ply_keyboard_added_handler_t         keyboard_added_handler,

                                        ply_keyboard_removed_handler_t       keyboard_removed_handler,

                                        ply_pixel_display_added_handler_t    pixel_display_added_handler,

                                        ply_pixel_display_removed_handler_t  pixel_display_removed_handler,

                                        ply_text_display_added_handler_t     text_display_added_handler,

                                        ply_text_display_removed_handler_t   text_display_removed_handler,

                                        void                                *data);

+void ply_device_manager_pause (ply_device_manager_t *manager);

+void ply_device_manager_unpause (ply_device_manager_t *manager);

 bool ply_device_manager_has_serial_consoles (ply_device_manager_t *manager);

 bool ply_device_manager_has_displays (ply_device_manager_t *manager);

 ply_list_t *ply_device_manager_get_keyboards (ply_device_manager_t *manager);

 ply_list_t *ply_device_manager_get_pixel_displays (ply_device_manager_t *manager);

 ply_list_t *ply_device_manager_get_text_displays (ply_device_manager_t *manager);

 void ply_device_manager_free (ply_device_manager_t *manager);

 void ply_device_manager_activate_keyboards (ply_device_manager_t *manager);

 void ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager);

 void ply_device_manager_activate_renderers (ply_device_manager_t *manager);

 void ply_device_manager_deactivate_renderers (ply_device_manager_t *manager);

 ply_terminal_t *ply_device_manager_get_default_terminal (ply_device_manager_t *manager);

 #endif

 #endif

 /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */

diff --git a/src/main.c b/src/main.c

index e44de7b..3253aa9 100644

--- a/src/main.c

+++ b/src/main.c

@@ -1305,94 +1305,97 @@ on_boot_splash_idle (state_t *state)

                 ply_trace ("quitting program");

                 quit_program (state);

         } else if (state->deactivate_trigger != NULL) {

                 ply_trace ("deactivating splash");

                 deactivate_splash (state);

         }

 }

 static void

 on_deactivate (state_t       *state,

                ply_trigger_t *deactivate_trigger)

 {

         if (state->is_inactive) {

                 ply_trigger_pull (deactivate_trigger, NULL);

                 return;

         }

         if (state->deactivate_trigger != NULL) {

                 ply_trigger_add_handler (state->deactivate_trigger,

                                          (ply_trigger_handler_t)

                                          ply_trigger_pull,

                                          deactivate_trigger);

                 return;

         }

         state->deactivate_trigger = deactivate_trigger;

         ply_trace ("deactivating");

         cancel_pending_delayed_show (state);

+        ply_device_manager_pause (state->device_manager);

         ply_device_manager_deactivate_keyboards (state->device_manager);

         if (state->boot_splash != NULL) {

                 ply_boot_splash_become_idle (state->boot_splash,

                                              (ply_boot_splash_on_idle_handler_t)

                                              on_boot_splash_idle,

                                              state);

         } else {

                 ply_trace ("deactivating splash");

                 deactivate_splash (state);

         }

 }

 static void

 on_reactivate (state_t *state)

 {

         if (!state->is_inactive)

                 return;

         if (state->local_console_terminal != NULL) {

                 ply_terminal_open (state->local_console_terminal);

                 ply_terminal_watch_for_vt_changes (state->local_console_terminal);

                 ply_terminal_set_unbuffered_input (state->local_console_terminal);

                 ply_terminal_ignore_mode_changes (state->local_console_terminal, false);

         }

         if ((state->session != NULL) && state->should_be_attached) {

                 ply_trace ("reactivating terminal session");

                 attach_to_running_session (state);

         }

         ply_device_manager_activate_keyboards (state->device_manager);

         ply_device_manager_activate_renderers (state->device_manager);

+        ply_device_manager_unpause (state->device_manager);

+

         state->is_inactive = false;

         update_display (state);

 }

 static void

 on_quit (state_t       *state,

          bool           retain_splash,

          ply_trigger_t *quit_trigger)

 {

         ply_trace ("quitting (retain splash: %s)", retain_splash ? "true" : "false");

         if (state->quit_trigger != NULL) {

                 ply_trace ("quit trigger already pending, so chaining to it");

                 ply_trigger_add_handler (state->quit_trigger,

                                          (ply_trigger_handler_t)

                                          ply_trigger_pull,

                                          quit_trigger);

                 return;

         }

         if (state->system_initialized) {

                 ply_trace ("system initialized so saving boot-duration file");

                 ply_create_directory (PLYMOUTH_TIME_DIRECTORY);

                 ply_progress_save_cache (state->progress,

                                          get_cache_file_for_mode (state->mode));

         } else {

                 ply_trace ("system not initialized so skipping saving boot-duration file");

         }

         state->quit_trigger = quit_trigger;

-- 

2.21.0