From be52bd06949cb2a386fda147d24155581708ef1a Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Fri, 10 Oct 2014 13:30:56 -0400

Subject: [PATCH] main: show splash when init=/bin/sh

but quit after switch root.  The keeps luks

working.

---

 src/main.c | 23 ++++++++++++++++++++---

 1 file changed, 20 insertions(+), 3 deletions(-)

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

index fb91bf2..4101550 100644

--- a/src/main.c

+++ b/src/main.c

@@ -135,60 +135,64 @@ static ply_boot_splash_t *load_theme (state_t    *state,

 static ply_boot_splash_t *show_theme (state_t    *state,

                                       const char *theme_path);

 static void attach_splash_to_seats (state_t           *state,

                                     ply_boot_splash_t *splash);

 static bool attach_to_running_session (state_t *state);

 static void detach_from_running_session (state_t *state);

 static void on_escape_pressed (state_t *state);

 static void dump_details_and_quit_splash (state_t *state);

 static void update_display (state_t *state);

 static void on_error_message (ply_buffer_t *debug_buffer,

                               const void   *bytes,

                               size_t        number_of_bytes);

 static ply_buffer_t *debug_buffer;

 static char *debug_buffer_path = NULL;

 static char *pid_file = NULL;

 static void toggle_between_splash_and_details (state_t *state);

 #ifdef PLY_ENABLE_SYSTEMD_INTEGRATION

 static void tell_systemd_to_print_details (state_t *state);

 static void tell_systemd_to_stop_printing_details (state_t *state);

 #endif

 static const char * get_cache_file_for_mode (ply_mode_t mode);

 static void on_escape_pressed (state_t *state);

 static void on_enter (state_t    *state,

                       const char *line);

 static void on_keyboard_input (state_t    *state,

                                const char *keyboard_input,

                                size_t      character_size);

 static void on_backspace (state_t *state);

+static void on_quit (state_t       *state,

+                     bool           retain_splash,

+                     ply_trigger_t *quit_trigger);

+static bool sh_is_init (state_t *state);

 static void

 on_session_output (state_t    *state,

                    const char *output,

                    size_t      size)

 {

   ply_buffer_append_bytes (state->boot_buffer, output, size);

   if (state->boot_splash != NULL)

     ply_boot_splash_update_output (state->boot_splash,

                                    output, size);

 }

 static void

 on_session_hangup (state_t *state)

 {

   ply_trace ("got hang up on terminal session fd");

 }

 static void

 on_update (state_t     *state,

            const char  *status)

 {

   ply_trace ("updating status to '%s'", status);

   ply_progress_status_update (state->progress,

                                status);

   if (state->boot_splash != NULL)

     ply_boot_splash_update_status (state->boot_splash,

                                    status);

 }

@@ -626,60 +630,67 @@ on_ignore_keystroke (state_t      *state,

     {

       ply_keystroke_watch_t* keystroke_trigger = ply_list_node_get_data (node);

       if ((!keystroke_trigger->keys && !keys) ||

           (keystroke_trigger->keys && keys && strcmp(keystroke_trigger->keys, keys)==0))

         {

           ply_trigger_pull (keystroke_trigger->trigger, NULL);

           ply_list_remove_node (state->keystroke_triggers, node);

           return;

         }

     }

 }

 static void

 on_progress_pause (state_t *state)

 {

   ply_trace ("pausing progress");

   ply_progress_pause (state->progress);

 }

 static void

 on_progress_unpause (state_t *state)

 {

   ply_trace ("unpausing progress");

   ply_progress_unpause (state->progress);

 }

 static void

 on_newroot (state_t    *state,

             const char *root_dir)

 {

+  if (sh_is_init (state))

+    {

+      ply_trace ("new root mounted at \"%s\", exiting since init= a shell", root_dir);

+      on_quit (state, false, ply_trigger_new (NULL));

+      return;

+    }

+

   ply_trace ("new root mounted at \"%s\", switching to it", root_dir);

   chdir(root_dir);

   chroot(".");

   chdir("/");

   ply_progress_load_cache (state->progress, get_cache_file_for_mode (state->mode));

   if (state->boot_splash != NULL)

     ply_boot_splash_root_mounted (state->boot_splash);

 }

 static const char *

 get_cache_file_for_mode (ply_mode_t mode)

 {

   const char *filename;

   switch ((int)mode)

     {

     case PLY_MODE_BOOT:

       filename = BOOT_DURATION_FILE;

       break;

     case PLY_MODE_SHUTDOWN:

       filename = SHUTDOWN_DURATION_FILE;

       break;

     case PLY_MODE_UPDATES:

       filename = NULL;

       break;

     default:

       ply_error ("Unhandled case in %s line %d\n", __FILE__, __LINE__);

       abort ();

       break;

     }

@@ -781,70 +792,76 @@ prepare_logging (state_t *state)

       if (state->number_of_errors > 0)

         spool_error (state);

     }

 }

 static void

 on_system_initialized (state_t *state)

 {

   ply_trace ("system now initialized, opening log");

   state->system_initialized = true;

   prepare_logging (state);

 }

 static void

 on_error (state_t *state)

 {

   ply_trace ("encountered error during boot up");

   if (state->system_initialized && state->number_of_errors == 0)

     spool_error (state);

   else

     ply_trace ("not spooling because number of errors %d", state->number_of_errors);

   state->number_of_errors++;

 }

 static bool

 plymouth_should_ignore_show_splash_calls (state_t *state)

 {

-  const char *init_string;

-  size_t length;

-

   ply_trace ("checking if plymouth should be running");

   if (state->mode != PLY_MODE_BOOT || command_line_has_argument (state->kernel_command_line, "plymouth.force-splash"))

       return false;

   if (command_line_has_argument (state->kernel_command_line, "plymouth.ignore-show-splash"))

       return true;

+  return false;

+}

+

+static bool

+sh_is_init (state_t *state)

+{

+  const char *init_string;

+  size_t length;

+

   init_string = command_line_get_string_after_prefix (state->kernel_command_line, "init=");

   if (init_string)

     {

       length = strcspn (init_string, " \n");

       if (length > 2 && ply_string_has_prefix (init_string + length - 2, "sh"))

         return true;

     }

   return false;

 }

 static bool

 plymouth_should_show_default_splash (state_t *state)

 {

   ply_trace ("checking if plymouth should show default splash");

   const char const *strings[] = {

       "single", "1", "s", "S", "-S", NULL

   };

   int i;

   if (state->should_force_details)

     return false;

   for (i = 0; strings[i] != NULL; i++)

     {

       if (command_line_has_argument (state->kernel_command_line, strings[i]))

         {

           ply_trace ("no default splash because kernel command line has option \"%s\"", strings[i]);

-- 

1.8.3.1