From 6cffa8daaca920f1d57da40d93ff112f5f096ae9 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Tue, 7 Nov 2017 13:49:30 -0500
Subject: [PATCH] device-manager: fall back to text mode if graphical devices
fail
Right now we assume if we find a /dev/dri/card0 that it will work.
That may not be true. The proprietary nvidia driver, for instance,
provides /dev/dri/card0 but disables modesetting by default.
This commit makes sure we fall back to text mode if /dev/dri/card0
is insufficient for our needs.
---
src/libply-splash-core/ply-device-manager.c | 25 ++++++++++++++-----------
1 file changed, 14 insertions(+), 11 deletions(-)
diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c
index 14d7616..3a2db06 100644
--- a/src/libply-splash-core/ply-device-manager.c
+++ b/src/libply-splash-core/ply-device-manager.c
@@ -14,61 +14,61 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include "config.h"
#include "ply-device-manager.h"
#include <assert.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/inotify.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <libudev.h>
#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"
-static void create_devices_for_terminal_and_renderer_type (ply_device_manager_t *manager,
+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_queue *udev_queue;
int udev_queue_fd;
ply_fd_watch_t *udev_queue_fd_watch;
struct udev_monitor *udev_monitor;
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;
@@ -134,110 +134,112 @@ fb_device_has_drm_device (ply_device_manager_t *manager,
/* there should only ever be at most one match so we don't iterate through
* the list, but just look at the first entry */
card_entry = udev_enumerate_get_list_entry (card_matches);
if (card_entry != NULL)
{
struct udev_device *card_device = NULL;
const char *card_node;
const char *card_path;
card_path = udev_list_entry_get_name (card_entry);
card_device = udev_device_new_from_syspath (manager->udev_context, card_path);
card_node = udev_device_get_devnode (card_device);
if (card_node != NULL && drm_device_in_use (manager, card_node))
has_drm_device = true;
else
ply_trace ("no card node!");
udev_device_unref (card_device);
}
else
{
ply_trace ("no card entry!");
}
udev_enumerate_unref (card_matches);
return has_drm_device;
}
-static void
+static bool
create_devices_for_udev_device (ply_device_manager_t *manager,
struct udev_device *device)
{
const char *device_path;
+ bool created = false;
device_path = udev_device_get_devnode (device);
if (device_path != NULL)
{
const char *subsystem;
ply_renderer_type_t renderer_type = PLY_RENDERER_TYPE_NONE;
subsystem = udev_device_get_subsystem (device);
ply_trace ("device subsystem is %s", subsystem);
if (subsystem != NULL && strcmp (subsystem, SUBSYSTEM_DRM) == 0)
{
ply_trace ("found DRM device %s", device_path);
renderer_type = PLY_RENDERER_TYPE_DRM;
}
else if (strcmp (subsystem, SUBSYSTEM_FRAME_BUFFER) == 0)
{
ply_trace ("found frame buffer device %s", device_path);
if (!fb_device_has_drm_device (manager, device))
{
renderer_type = PLY_RENDERER_TYPE_FRAME_BUFFER;
}
else
{
ply_trace ("ignoring, since there's a DRM device associated with it");
}
}
if (renderer_type != PLY_RENDERER_TYPE_NONE)
{
ply_terminal_t *terminal = NULL;
if (!manager->local_console_managed)
{
terminal = manager->local_console_terminal;
}
- create_devices_for_terminal_and_renderer_type (manager,
- device_path,
- terminal,
- renderer_type);
+ created = create_devices_for_terminal_and_renderer_type (manager,
+ device_path,
+ terminal,
+ renderer_type);
}
}
+ return created;
}
static void
free_displays_for_renderer (ply_device_manager_t *manager,
ply_renderer_t *renderer)
{
ply_list_node_t *node;
node = ply_list_get_first_node (manager->pixel_displays);
while (node != NULL)
{
ply_list_node_t *next_node;
ply_pixel_display_t *display;
ply_renderer_t *display_renderer;
display = ply_list_node_get_data (node);
next_node = ply_list_get_next_node (manager->pixel_displays, node);
display_renderer = ply_pixel_display_get_renderer (display);
if (display_renderer == renderer)
{
if (manager->pixel_display_removed_handler != NULL)
manager->pixel_display_removed_handler (manager->event_handler_data, display);
ply_pixel_display_free (display);
ply_list_remove_node (manager->pixel_displays, node);
}
node = next_node;
}
@@ -300,62 +302,61 @@ create_devices_for_subsystem (ply_device_manager_t *manager,
const char *path;
path = udev_list_entry_get_name (entry);
if (path == NULL)
{
ply_trace ("path was null!");
continue;
}
ply_trace ("found device %s", path);
device = udev_device_new_from_syspath (manager->udev_context, path);
/* if device isn't fully initialized, we'll get an add event later
*/
if (udev_device_get_is_initialized (device))
{
ply_trace ("device is initialized");
/* We only care about devices assigned to a (any) seat. Floating
* devices should be ignored.
*/
if (udev_device_has_tag (device, "seat"))
{
const char *node;
node = udev_device_get_devnode (device);
if (node != NULL)
{
ply_trace ("found node %s", node);
- found_device = true;
- create_devices_for_udev_device (manager, device);
+ found_device = create_devices_for_udev_device (manager, device);
}
}
else
{
ply_trace ("device doesn't have a seat tag");
}
}
else
{
ply_trace ("it's not initialized");
}
udev_device_unref (device);
}
udev_enumerate_unref (matches);
return found_device;
}
static void
on_udev_event (ply_device_manager_t *manager)
{
struct udev_device *device;
const char *action;
device = udev_monitor_receive_device (manager->udev_monitor);
if (device == NULL)
return;
@@ -655,137 +656,139 @@ create_pixel_displays_for_renderer (ply_device_manager_t *manager,
node = next_node;
}
}
static void
create_text_displays_for_terminal (ply_device_manager_t *manager,
ply_terminal_t *terminal)
{
ply_text_display_t *display;
if (!ply_terminal_is_open (terminal))
{
if (!ply_terminal_open (terminal))
{
ply_trace ("could not add terminal %s: %m",
ply_terminal_get_name (terminal));
return;
}
}
ply_trace ("adding text display for terminal %s",
ply_terminal_get_name (terminal));
display = ply_text_display_new (terminal);
ply_list_append_data (manager->text_displays, display);
if (manager->text_display_added_handler != NULL)
manager->text_display_added_handler (manager->event_handler_data, display);
}
-static void
+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)
{
ply_renderer_t *renderer = NULL;
ply_keyboard_t *keyboard = NULL;
renderer = ply_hashtable_lookup (manager->renderers, (void *) device_path);
if (renderer != NULL)
{
ply_trace ("ignoring device %s since it's already managed",
device_path);
- return;
+ return true;
}
ply_trace ("creating devices for %s (renderer type: %u) (terminal: %s)",
device_path? : "", renderer_type, terminal? ply_terminal_get_name (terminal): "none");
if (renderer_type != PLY_RENDERER_TYPE_NONE)
{
renderer = ply_renderer_new (renderer_type, device_path, terminal);
if (!ply_renderer_open (renderer))
{
ply_trace ("could not open renderer for %s", device_path);
ply_renderer_free (renderer);
renderer = NULL;
if (renderer_type != PLY_RENDERER_TYPE_AUTO)
- return;
+ return false;
}
}
if (renderer != NULL)
{
keyboard = ply_keyboard_new_for_renderer (renderer);
ply_list_append_data (manager->keyboards, keyboard);
if (manager->keyboard_added_handler != NULL)
manager->keyboard_added_handler (manager->event_handler_data, keyboard);
ply_hashtable_insert (manager->renderers, strdup (device_path), renderer);
create_pixel_displays_for_renderer (manager, renderer);
if (manager->renderers_activated)
{
ply_trace ("activating renderer");
ply_renderer_activate (renderer);
}
}
else if (terminal != NULL)
{
keyboard = ply_keyboard_new_for_terminal (terminal);
ply_list_append_data (manager->keyboards, keyboard);
if (manager->keyboard_added_handler != NULL)
manager->keyboard_added_handler (manager->event_handler_data, keyboard);
}
if (terminal != NULL)
{
create_text_displays_for_terminal (manager, terminal);
if (terminal == manager->local_console_terminal)
{
manager->local_console_is_text = renderer == NULL;
manager->local_console_managed = true;
}
}
if (keyboard != NULL && manager->keyboards_activated)
{
ply_trace ("activating keyboards");
ply_keyboard_watch_for_input (keyboard);
}
+
+ return true;
}
static void
create_devices_for_terminal (const char *device_path,
ply_terminal_t *terminal,
ply_device_manager_t *manager)
{
create_devices_for_terminal_and_renderer_type (manager,
device_path,
terminal,
PLY_RENDERER_TYPE_NONE);
}
static bool
create_devices_from_terminals (ply_device_manager_t *manager)
{
bool has_serial_consoles;
ply_trace ("checking for consoles");
if (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES)
{
has_serial_consoles = false;
ply_trace ("ignoring all consoles but default console because explicitly told to.");
}
else
{
has_serial_consoles = add_consoles_from_file (manager, "/sys/class/tty/console/active");
}
if (has_serial_consoles)
--
2.14.3