From a54df38f86a534b28c1b664bc283e9b8d17be8a1 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Thu, 16 Jan 2014 15:44:50 -0500
Subject: [PATCH 1/2] main: don't rely on show_trigger to cancel show delay
We're going to be getting rid of show_trigger in a subsequent
commit, so this commit changes the code to use the is_shown
flag instead.
---
src/main.c | 29 ++++++++++++++++-------------
1 file changed, 16 insertions(+), 13 deletions(-)
diff --git a/src/main.c b/src/main.c
index bbd74f9..d9032a5 100644
--- a/src/main.c
+++ b/src/main.c
@@ -482,74 +482,77 @@ show_default_splash (state_t *state)
static void
cancel_pending_delayed_show (state_t *state)
{
bool has_open_seats;
if (isnan (state->splash_delay))
return;
ply_event_loop_stop_watching_for_timeout (state->loop,
(ply_event_loop_timeout_handler_t)
show_splash,
state);
state->splash_delay = NAN;
has_open_seats = ply_device_manager_has_open_seats (state->device_manager);
if (state->is_shown && has_open_seats)
{
ply_trace ("splash delay cancelled, showing splash immediately");
show_splash (state);
}
}
static void
on_ask_for_password (state_t *state,
const char *prompt,
ply_trigger_t *answer)
{
ply_entry_trigger_t *entry_trigger;
- /* Waiting to be shown, boot splash will
- * arrive shortly so just sit tight
- */
- if (state->show_trigger != NULL)
- {
- ply_trace ("splash still coming up, waiting a bit");
- cancel_pending_delayed_show (state);
- }
- else if (state->boot_splash == NULL)
+ if (state->boot_splash == NULL)
{
- /* No splash, client will have to get password */
- ply_trace ("no splash loaded, replying immediately with no password");
- ply_trigger_pull (answer, NULL);
- return;
+ /* Waiting to be shown, boot splash will
+ * arrive shortly so just sit tight
+ */
+ if (state->is_shown)
+ {
+ ply_trace ("splash still coming up, waiting a bit");
+ cancel_pending_delayed_show (state);
+ }
+ else
+ {
+ /* No splash, client will have to get password */
+ ply_trace ("no splash loaded, replying immediately with no password");
+ ply_trigger_pull (answer, NULL);
+ return;
+ }
}
entry_trigger = calloc (1, sizeof (ply_entry_trigger_t));
entry_trigger->type = PLY_ENTRY_TRIGGER_TYPE_PASSWORD;
entry_trigger->prompt = prompt;
entry_trigger->trigger = answer;
ply_trace ("queuing password request with boot splash");
ply_list_append_data (state->entry_triggers, entry_trigger);
update_display (state);
}
static void
on_ask_question (state_t *state,
const char *prompt,
ply_trigger_t *answer)
{
ply_entry_trigger_t *entry_trigger;
entry_trigger = calloc (1, sizeof (ply_entry_trigger_t));
entry_trigger->type = PLY_ENTRY_TRIGGER_TYPE_QUESTION;
entry_trigger->prompt = prompt;
entry_trigger->trigger = answer;
ply_trace ("queuing question with boot splash");
ply_list_append_data (state->entry_triggers, entry_trigger);
update_display (state);
}
static void
on_display_message (state_t *state,
const char *message)
--
1.8.3.1
From cdff09d1a2297501f294141182d8d8efcaf6fff3 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Thu, 16 Jan 2014 15:38:05 -0500
Subject: [PATCH 2/2] Revert "boot-server: defer show-splash reply until splash
shown"
This reverts commit 126345af8704a9b10481657d79d66cbea93e1647.
If plymouth show-splash blocks until the splash screen is shown,
then systemd-ask-for-password-plymouth will block for 5 seconds
before asking for the password (which would have canceled the 5
second delay if it weren't for the dependency on plymouth-start.service)
---
src/main.c | 12 +-----------
src/ply-boot-server.c | 28 +---------------------------
src/ply-boot-server.h | 1 -
3 files changed, 2 insertions(+), 39 deletions(-)
diff --git a/src/main.c b/src/main.c
index d9032a5..db1fd0a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -74,61 +74,60 @@ typedef struct
const char *keys;
ply_trigger_t *trigger;
} ply_keystroke_watch_t;
typedef struct
{
enum {PLY_ENTRY_TRIGGER_TYPE_PASSWORD,
PLY_ENTRY_TRIGGER_TYPE_QUESTION}
type;
const char *prompt;
ply_trigger_t *trigger;
} ply_entry_trigger_t;
typedef struct
{
ply_event_loop_t *loop;
ply_boot_server_t *boot_server;
ply_boot_splash_t *boot_splash;
ply_terminal_session_t *session;
ply_buffer_t *boot_buffer;
ply_progress_t *progress;
ply_list_t *keystroke_triggers;
ply_list_t *entry_triggers;
ply_buffer_t *entry_buffer;
ply_list_t *messages;
ply_command_parser_t *command_parser;
ply_mode_t mode;
ply_terminal_t *local_console_terminal;
ply_device_manager_t *device_manager;
- ply_trigger_t *show_trigger;
ply_trigger_t *deactivate_trigger;
ply_trigger_t *quit_trigger;
double start_time;
double splash_delay;
char kernel_command_line[PLY_MAX_COMMAND_LINE_SIZE];
uint32_t kernel_command_line_is_set : 1;
uint32_t no_boot_log : 1;
uint32_t showing_details : 1;
uint32_t system_initialized : 1;
uint32_t is_redirected : 1;
uint32_t is_attached : 1;
uint32_t should_be_attached : 1;
uint32_t should_retain_splash : 1;
uint32_t is_inactive : 1;
uint32_t is_shown : 1;
uint32_t should_force_details : 1;
char *override_splash_path;
char *system_default_splash_path;
char *distribution_default_splash_path;
const char *default_tty;
int number_of_errors;
} state_t;
static void show_splash (state_t *state);
static ply_boot_splash_t *load_built_in_theme (state_t *state);
static ply_boot_splash_t *load_theme (state_t *state,
@@ -848,85 +847,83 @@ plymouth_should_show_default_splash (state_t *state)
if (command_line_has_argument (state->kernel_command_line, "splash=verbose"))
{
ply_trace ("no default splash because kernel command line has option \"splash=verbose\"");
return false;
}
if (command_line_has_argument (state->kernel_command_line, "rhgb"))
{
ply_trace ("using default splash because kernel command line has option \"rhgb\"");
return true;
}
if (command_line_has_argument (state->kernel_command_line, "splash"))
{
ply_trace ("using default splash because kernel command line has option \"splash\"");
return true;
}
if (command_line_has_argument (state->kernel_command_line, "splash=silent"))
{
ply_trace ("using default splash because kernel command line has option \"splash=slient\"");
return true;
}
ply_trace ("no default splash because kernel command line lacks \"splash\" or \"rhgb\"");
return false;
}
static void
-on_show_splash (state_t *state,
- ply_trigger_t *show_trigger)
+on_show_splash (state_t *state)
{
bool has_open_seats;
if (state->is_shown)
{
ply_trace ("show splash called while already shown");
return;
}
if (state->is_inactive)
{
ply_trace ("show splash called while inactive");
return;
}
if (plymouth_should_ignore_show_splash_calls (state))
{
ply_trace ("show splash called while ignoring show splash calls");
dump_details_and_quit_splash (state);
return;
}
- state->show_trigger = show_trigger;
state->is_shown = true;
has_open_seats = ply_device_manager_has_open_seats (state->device_manager);
if (!state->is_attached && state->should_be_attached && has_open_seats)
attach_to_running_session (state);
if (has_open_seats)
{
ply_trace ("at least one seat already open, so loading splash");
show_splash (state);
}
else
{
ply_trace ("no seats available to show splash on, waiting...");
}
}
static void
on_seat_removed (state_t *state,
ply_seat_t *seat)
{
ply_keyboard_t *keyboard;
keyboard = ply_seat_get_keyboard (seat);
ply_trace ("no longer listening for keystrokes");
ply_keyboard_remove_input_handler (keyboard,
(ply_keyboard_input_handler_t)
on_keyboard_input);
ply_trace ("no longer listening for escape");
@@ -960,67 +957,60 @@ show_splash (state_t *state)
running_time = now - state->start_time;
if (state->splash_delay > running_time)
{
double time_left = state->splash_delay - running_time;
ply_trace ("delaying show splash for %lf seconds",
time_left);
ply_event_loop_stop_watching_for_timeout (state->loop,
(ply_event_loop_timeout_handler_t)
show_splash,
state);
ply_event_loop_watch_for_timeout (state->loop,
time_left,
(ply_event_loop_timeout_handler_t)
show_splash,
state);
return;
}
}
if (plymouth_should_show_default_splash (state))
{
show_default_splash (state);
state->showing_details = false;
}
else
{
show_detailed_splash (state);
state->showing_details = true;
}
-
- if (state->show_trigger != NULL)
- {
- ply_trace ("telling boot server about completed show operation");
- ply_trigger_pull (state->show_trigger, NULL);
- state->show_trigger = NULL;
- }
}
static void
on_seat_added (state_t *state,
ply_seat_t *seat)
{
ply_keyboard_t *keyboard;
if (state->is_shown)
{
if (state->boot_splash == NULL)
{
ply_trace ("seat added before splash loaded, so loading splash now");
show_splash (state);
}
else
{
ply_trace ("seat added after splash loaded, so attaching to splash");
ply_boot_splash_attach_to_seat (state->boot_splash, seat);
}
}
keyboard = ply_seat_get_keyboard (seat);
ply_trace ("listening for keystrokes");
ply_keyboard_add_input_handler (keyboard,
(ply_keyboard_input_handler_t)
on_keyboard_input, state);
ply_trace ("listening for escape");
ply_keyboard_add_escape_handler (keyboard,
diff --git a/src/ply-boot-server.c b/src/ply-boot-server.c
index 78c9c52..3e67bfb 100644
--- a/src/ply-boot-server.c
+++ b/src/ply-boot-server.c
@@ -283,72 +283,60 @@ ply_boot_connection_send_answer (ply_boot_connection_t *connection,
{
size = strlen (answer);
if (!ply_write (connection->fd,
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ANSWER,
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ANSWER)) ||
!ply_write_uint32 (connection->fd,
size) ||
!ply_write (connection->fd,
answer, size))
ply_trace ("could not finish writing answer: %m");
}
}
static void
ply_boot_connection_on_password_answer (ply_boot_connection_t *connection,
const char *password)
{
ply_trace ("got password answer");
ply_boot_connection_send_answer (connection, password);
if (password != NULL)
ply_list_append_data (connection->server->cached_passwords,
strdup (password));
}
static void
-ply_boot_connection_on_splash_shown (ply_boot_connection_t *connection)
-{
- ply_trace ("shown");
- if (!ply_write (connection->fd,
- PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
- strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
- {
- ply_trace ("could not finish writing deactivate reply: %m");
- }
-}
-
-static void
ply_boot_connection_on_deactivated (ply_boot_connection_t *connection)
{
ply_trace ("deactivated");
if (!ply_write (connection->fd,
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
{
ply_trace ("could not finish writing deactivate reply: %m");
}
}
static void
ply_boot_connection_on_quit_complete (ply_boot_connection_t *connection)
{
ply_trace ("quit complete");
if (!ply_write (connection->fd,
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
{
ply_trace ("could not finish writing quit reply: %m");
}
}
static void
ply_boot_connection_on_question_answer (ply_boot_connection_t *connection,
const char *answer)
{
ply_trace ("got question answer: %s", answer);
ply_boot_connection_send_answer (connection, answer);
}
@@ -462,77 +450,63 @@ ply_boot_connection_on_request (ply_boot_connection_t *connection)
ply_error ("failed to parse percentage %s", argument);
value = 0;
}
ply_trace ("got system-update notification %li%%", value);
if (!ply_write (connection->fd,
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
ply_trace ("could not finish writing update reply: %m");
if (server->system_update_handler != NULL)
server->system_update_handler (server->user_data, value, server);
free (argument);
free (command);
return;
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SYSTEM_INITIALIZED) == 0)
{
ply_trace ("got system initialized notification");
if (server->system_initialized_handler != NULL)
server->system_initialized_handler (server->user_data, server);
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_ERROR) == 0)
{
ply_trace ("got error notification");
if (server->error_handler != NULL)
server->error_handler (server->user_data, server);
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SHOW_SPLASH) == 0)
{
- ply_trigger_t *show_trigger;
-
ply_trace ("got show splash request");
-
- show_trigger = ply_trigger_new (NULL);
-
- ply_trigger_add_handler (show_trigger,
- (ply_trigger_handler_t)
- ply_boot_connection_on_splash_shown,
- connection);
-
if (server->show_splash_handler != NULL)
- server->show_splash_handler (server->user_data, show_trigger, server);
-
- free (argument);
- free (command);
- return;
+ server->show_splash_handler (server->user_data, server);
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_HIDE_SPLASH) == 0)
{
ply_trace ("got hide splash request");
if (server->hide_splash_handler != NULL)
server->hide_splash_handler (server->user_data, server);
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_DEACTIVATE) == 0)
{
ply_trigger_t *deactivate_trigger;
ply_trace ("got deactivate request");
deactivate_trigger = ply_trigger_new (NULL);
ply_trigger_add_handler (deactivate_trigger,
(ply_trigger_handler_t)
ply_boot_connection_on_deactivated,
connection);
if (server->deactivate_handler != NULL)
server->deactivate_handler (server->user_data, deactivate_trigger, server);
free (argument);
free (command);
return;
}
else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_REACTIVATE) == 0)
{
ply_trace ("got reactivate request");
diff --git a/src/ply-boot-server.h b/src/ply-boot-server.h
index 4436be8..b885a81 100644
--- a/src/ply-boot-server.h
+++ b/src/ply-boot-server.h
@@ -22,61 +22,60 @@
#ifndef PLY_BOOT_SERVER_H
#define PLY_BOOT_SERVER_H
#include <stdbool.h>
#include <stdint.h>
#include <unistd.h>
#include "ply-trigger.h"
#include "ply-boot-protocol.h"
#include "ply-event-loop.h"
typedef struct _ply_boot_server ply_boot_server_t;
typedef void (* ply_boot_server_update_handler_t) (void *user_data,
const char *status,
ply_boot_server_t *server);
typedef void (* ply_boot_server_change_mode_handler_t) (void *user_data,
const char *mode,
ply_boot_server_t *server);
typedef void (* ply_boot_server_system_update_handler_t) (void *user_data,
int progress,
ply_boot_server_t *server);
typedef void (* ply_boot_server_newroot_handler_t) (void *user_data,
const char *root_dir,
ply_boot_server_t *server);
typedef void (* ply_boot_server_show_splash_handler_t) (void *user_data,
- ply_trigger_t *show_trigger,
ply_boot_server_t *server);
typedef void (* ply_boot_server_hide_splash_handler_t) (void *user_data,
ply_boot_server_t *server);
typedef void (* ply_boot_server_password_answer_handler_t) (void *answer_data,
const char *password,
ply_boot_server_t *server);
typedef void (* ply_boot_server_ask_for_password_handler_t) (void *user_data,
const char *prompt,
ply_trigger_t *answer,
ply_boot_server_t *server);
typedef void (* ply_boot_server_question_answer_handler_t) (void *answer_data,
const char *answer,
ply_boot_server_t *server);
typedef void (* ply_boot_server_ask_question_handler_t) (void *user_data,
const char *prompt,
ply_trigger_t *answer,
ply_boot_server_t *server);
typedef void (* ply_boot_server_display_message_handler_t) (void *user_data,
const char *message,
ply_boot_server_t *server);
typedef void (* ply_boot_server_hide_message_handler_t) (void *user_data,
const char *message,
ply_boot_server_t *server);
typedef void (* ply_boot_server_watch_for_keystroke_handler_t) (void *user_data,
const char *keys,
ply_trigger_t *answer,
ply_boot_server_t *server);
typedef void (* ply_boot_server_ignore_keystroke_handler_t) (void *user_data,
--
1.8.3.1