From d6aca6da3ab9c16e907c7f46cf6d7bc2abbc2890 Mon Sep 17 00:00:00 2001

From: Iain Lane <iainl@gnome.org>

Date: Tue, 7 May 2019 16:00:14 +0100

Subject: [PATCH 50/51] Allow sessions to register with GDM

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

Recording when sessions start, for Wayland → Xorg fallback or

transitioning to the user session, is currently done with timeouts.

This isn't ideal, because on some very slow machines the timeout can be

hit before the session has had a chance to fail: if gnome-session takes

more than 3 seconds to fail then the session will be considered to have

exited rather than failed, and so we don't do Xorg fallback.

We can do this more reliably if we allow sessions to optionally register

themselves with GDM. Then we will know when they've started, so can shut

down the greeter or fall back to Xorg as appropriate. The mechanism is

that they specify X-GDM-SessionRegisters=true in their file, and then

call RegsterSession on the DisplayManager interface on the bus (added in

the previous commit) to say that they've started up.

If X-GDM-SessionRegisters is missing or false, GDM will call the same

method for them after 10 seconds.

Closes: #483

---

 common/gdm-common.h                |  2 +

 daemon/gdm-display.c               | 19 ++-----

 daemon/gdm-local-display-factory.c | 49 +++++++++---------

 daemon/gdm-session.c               | 47 +++++++++++++++--

 daemon/gdm-session.h               |  1 +

 daemon/gdm-wayland-session.c       | 81 +++++++++++++++++++++++-------

 daemon/gdm-x-session.c             | 81 +++++++++++++++++++++++-------

 7 files changed, 201 insertions(+), 79 deletions(-)

diff --git a/common/gdm-common.h b/common/gdm-common.h

index 3fbf07653..7fd6458d7 100644

--- a/common/gdm-common.h

+++ b/common/gdm-common.h

@@ -1,59 +1,61 @@

 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-

  *

  * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>

  *

  * This library is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Library General Public

  * License as published by the Free Software Foundation; either

  * version 2 of the License, or (at your option) any later version.

  *

  * This library is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  * Library General Public License for more details.

  *

  * You should have received a copy of the GNU Library General Public

  * License along with this library; if not, write to the

  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

  * Boston, MA 02110-1301, USA.

  */

 #ifndef _GDM_COMMON_H

 #define _GDM_COMMON_H

 #include <glib-unix.h>

 #include <gio/gio.h>

 #include <pwd.h>

 #include <errno.h>

+#define REGISTER_SESSION_TIMEOUT 10

+

 #define        VE_IGNORE_EINTR(expr) \

         do {                         \

                 errno = 0;           \

                 expr;                \

         } while G_UNLIKELY (errno == EINTR);

 GQuark gdm_common_error_quark (void);

 #define GDM_COMMON_ERROR gdm_common_error_quark()

 typedef char * (*GdmExpandVarFunc) (const char *var,

                                     gpointer user_data);

 G_BEGIN_DECLS

 int            gdm_wait_on_pid           (int pid);

 int            gdm_wait_on_and_disown_pid (int pid,

                                            int timeout);

 int            gdm_signal_pid            (int pid,

                                           int signal);

 gboolean       gdm_get_pwent_for_name    (const char     *name,

                                           struct passwd **pwentp);

 gboolean       gdm_clear_close_on_exec_flag (int fd);

 const char *   gdm_make_temp_dir         (char    *template);

 char          *gdm_generate_random_bytes (gsize          size,

                                           GError       **error);

 gboolean       gdm_get_login_window_session_id (const char  *seat_id,

                                                 char       **session_id);

diff --git a/daemon/gdm-display.c b/daemon/gdm-display.c

index 09cc2e116..ae20491cd 100644

--- a/daemon/gdm-display.c

+++ b/daemon/gdm-display.c

@@ -39,61 +39,60 @@

 #include "gdm-common.h"

 #include "gdm-display.h"

 #include "gdm-display-glue.h"

 #include "gdm-display-access-file.h"

 #include "gdm-launch-environment.h"

 #include "gdm-settings-direct.h"

 #include "gdm-settings-keys.h"

 #include "gdm-launch-environment.h"

 #include "gdm-dbus-util.h"

 #define GNOME_SESSION_SESSIONS_PATH DATADIR "/gnome-session/sessions"

 #define GDM_DISPLAY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_DISPLAY, GdmDisplayPrivate))

 struct GdmDisplayPrivate

 {

         char                 *id;

         char                 *seat_id;

         char                 *session_id;

         char                 *session_class;

         char                 *session_type;

         char                 *remote_hostname;

         int                   x11_display_number;

         char                 *x11_display_name;

         int                   status;

         time_t                creation_time;

-        GTimer               *server_timer;

         char                 *x11_cookie;

         gsize                 x11_cookie_size;

         GdmDisplayAccessFile *access_file;

         guint                 finish_idle_id;

         xcb_connection_t     *xcb_connection;

         int                   xcb_screen_number;

         GDBusConnection      *connection;

         GdmDisplayAccessFile *user_access_file;

         GdmDBusDisplay       *display_skeleton;

         GDBusObjectSkeleton  *object_skeleton;

         /* this spawns and controls the greeter session */

         GdmLaunchEnvironment *launch_environment;

         guint                 is_local : 1;

         guint                 is_initial : 1;

         guint                 allow_timed_login : 1;

         guint                 have_existing_user_accounts : 1;

         guint                 doing_initial_setup : 1;

         guint                 session_registered : 1;

 };

 enum {

         PROP_0,

         PROP_ID,

@@ -510,62 +509,60 @@ gdm_display_prepare (GdmDisplay *self)

          * asynchronously

          */

         look_for_existing_users_sync (self);

         self->priv->doing_initial_setup = wants_initial_setup (self);

         g_object_ref (self);

         ret = GDM_DISPLAY_GET_CLASS (self)->prepare (self);

         g_object_unref (self);

         return ret;

 }

 gboolean

 gdm_display_manage (GdmDisplay *self)

 {

         gboolean res;

         g_return_val_if_fail (GDM_IS_DISPLAY (self), FALSE);

         g_debug ("GdmDisplay: Managing display: %s", self->priv->id);

         /* If not explicitly prepared, do it now */

         if (self->priv->status == GDM_DISPLAY_UNMANAGED) {

                 res = gdm_display_prepare (self);

                 if (! res) {

                         return FALSE;

                 }

         }

-        g_timer_start (self->priv->server_timer);

-

         if (g_strcmp0 (self->priv->session_class, "greeter") == 0) {

                 if (GDM_DISPLAY_GET_CLASS (self)->manage != NULL) {

                         GDM_DISPLAY_GET_CLASS (self)->manage (self);

                 }

         }

         return TRUE;

 }

 gboolean

 gdm_display_finish (GdmDisplay *self)

 {

         g_return_val_if_fail (GDM_IS_DISPLAY (self), FALSE);

         if (self->priv->finish_idle_id != 0) {

                 g_source_remove (self->priv->finish_idle_id);

                 self->priv->finish_idle_id = 0;

         }

         _gdm_display_set_status (self, GDM_DISPLAY_FINISHED);

         g_debug ("GdmDisplay: finish display");

         return TRUE;

 }

 static void

 gdm_display_disconnect (GdmDisplay *self)

 {

         /* These 3 bits are reserved/unused by the X protocol */

@@ -576,85 +573,80 @@ gdm_display_disconnect (GdmDisplay *self)

         if (self->priv->xcb_connection == NULL) {

                 return;

         }

         setup = xcb_get_setup (self->priv->xcb_connection);

         /* resource_id_mask is the bits given to each client for

          * addressing resources */

         highest_client = (XID) ~unused_bits & ~setup->resource_id_mask;

         client_increment = setup->resource_id_mask + 1;

         /* Kill every client but ourselves, then close our own connection

          */

         for (client = 0;

              client <= highest_client;

              client += client_increment) {

                 if (client != setup->resource_id_base)

                         xcb_kill_client (self->priv->xcb_connection, client);

         }

         xcb_flush (self->priv->xcb_connection);

         g_clear_pointer (&self->priv->xcb_connection, xcb_disconnect);

 }

 gboolean

 gdm_display_unmanage (GdmDisplay *self)

 {

-        gdouble elapsed;

-

         g_return_val_if_fail (GDM_IS_DISPLAY (self), FALSE);

         g_debug ("GdmDisplay: unmanage display");

         gdm_display_disconnect (self);

-        g_timer_stop (self->priv->server_timer);

-

         if (self->priv->user_access_file != NULL) {

                 gdm_display_access_file_close (self->priv->user_access_file);

                 g_object_unref (self->priv->user_access_file);

                 self->priv->user_access_file = NULL;

         }

         if (self->priv->access_file != NULL) {

                 gdm_display_access_file_close (self->priv->access_file);

                 g_object_unref (self->priv->access_file);

                 self->priv->access_file = NULL;

         }

-        elapsed = g_timer_elapsed (self->priv->server_timer, NULL);

-        if (elapsed < 3) {

-                g_warning ("GdmDisplay: display lasted %lf seconds", elapsed);

+        if (!self->priv->session_registered) {

+                g_warning ("GdmDisplay: Session never registered, failing");

                 _gdm_display_set_status (self, GDM_DISPLAY_FAILED);

         } else {

                 _gdm_display_set_status (self, GDM_DISPLAY_UNMANAGED);

         }

         return TRUE;

 }

 gboolean

 gdm_display_get_id (GdmDisplay         *self,

                     char              **id,

                     GError            **error)

 {

         g_return_val_if_fail (GDM_IS_DISPLAY (self), FALSE);

         if (id != NULL) {

                 *id = g_strdup (self->priv->id);

         }

         return TRUE;

 }

 gboolean

 gdm_display_get_x11_display_name (GdmDisplay   *self,

                                   char        **x11_display,

                                   GError      **error)

 {

         g_return_val_if_fail (GDM_IS_DISPLAY (self), FALSE);

         if (x11_display != NULL) {

@@ -898,61 +890,61 @@ gdm_display_get_property (GObject        *object,

         case PROP_X11_DISPLAY_NAME:

                 g_value_set_string (value, self->priv->x11_display_name);

                 break;

         case PROP_X11_COOKIE:

                 g_value_set_string (value, self->priv->x11_cookie);

                 break;

         case PROP_X11_AUTHORITY_FILE:

                 g_value_take_string (value,

                                      self->priv->access_file?

                                      gdm_display_access_file_get_path (self->priv->access_file) : NULL);

                 break;

         case PROP_IS_LOCAL:

                 g_value_set_boolean (value, self->priv->is_local);

                 break;

         case PROP_IS_CONNECTED:

                 g_value_set_boolean (value, self->priv->xcb_connection != NULL);

                 break;

         case PROP_LAUNCH_ENVIRONMENT:

                 g_value_set_object (value, self->priv->launch_environment);

                 break;

         case PROP_IS_INITIAL:

                 g_value_set_boolean (value, self->priv->is_initial);

                 break;

         case PROP_HAVE_EXISTING_USER_ACCOUNTS:

                 g_value_set_boolean (value, self->priv->have_existing_user_accounts);

                 break;

         case PROP_DOING_INITIAL_SETUP:

                 g_value_set_boolean (value, self->priv->doing_initial_setup);

                 break;

         case PROP_SESSION_REGISTERED:

-                g_value_set_boolean (value, priv->session_registered);

+                g_value_set_boolean (value, self->priv->session_registered);

                 break;

         case PROP_ALLOW_TIMED_LOGIN:

                 g_value_set_boolean (value, self->priv->allow_timed_login);

                 break;

         default:

                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

                 break;

         }

 }

 static gboolean

 handle_get_id (GdmDBusDisplay        *skeleton,

                GDBusMethodInvocation *invocation,

                GdmDisplay            *self)

 {

         char *id;

         gdm_display_get_id (self, &id, NULL);

         gdm_dbus_display_complete_get_id (skeleton, invocation, id);

         g_free (id);

         return TRUE;

 }

 static gboolean

 handle_get_remote_hostname (GdmDBusDisplay        *skeleton,

                             GDBusMethodInvocation *invocation,

                             GdmDisplay            *self)

 {

@@ -1251,99 +1243,94 @@ gdm_display_class_init (GdmDisplayClass *klass)

                                                                FALSE,

                                                                G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (object_class,

                                          PROP_LAUNCH_ENVIRONMENT,

                                          g_param_spec_object ("launch-environment",

                                                               NULL,

                                                               NULL,

                                                               GDM_TYPE_LAUNCH_ENVIRONMENT,

                                                               G_PARAM_READWRITE));

         g_object_class_install_property (object_class,

                                          PROP_STATUS,

                                          g_param_spec_int ("status",

                                                            "status",

                                                            "status",

                                                            -1,

                                                            G_MAXINT,

                                                            GDM_DISPLAY_UNMANAGED,

                                                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

         g_type_class_add_private (klass, sizeof (GdmDisplayPrivate));

 }

 static void

 gdm_display_init (GdmDisplay *self)

 {

         self->priv = GDM_DISPLAY_GET_PRIVATE (self);

         self->priv->creation_time = time (NULL);

-        self->priv->server_timer = g_timer_new ();

 }

 static void

 gdm_display_finalize (GObject *object)

 {

         GdmDisplay *self;

         g_return_if_fail (object != NULL);

         g_return_if_fail (GDM_IS_DISPLAY (object));

         self = GDM_DISPLAY (object);

         g_return_if_fail (self->priv != NULL);

         g_debug ("GdmDisplay: Finalizing display: %s", self->priv->id);

         g_free (self->priv->id);

         g_free (self->priv->seat_id);

         g_free (self->priv->session_class);

         g_free (self->priv->remote_hostname);

         g_free (self->priv->x11_display_name);

         g_free (self->priv->x11_cookie);

         g_clear_object (&self->priv->display_skeleton);

         g_clear_object (&self->priv->object_skeleton);

         g_clear_object (&self->priv->connection);

         if (self->priv->access_file != NULL) {

                 g_object_unref (self->priv->access_file);

         }

         if (self->priv->user_access_file != NULL) {

                 g_object_unref (self->priv->user_access_file);

         }

-        if (self->priv->server_timer != NULL) {

-                g_timer_destroy (self->priv->server_timer);

-        }

-

         G_OBJECT_CLASS (gdm_display_parent_class)->finalize (object);

 }

 GDBusObjectSkeleton *

 gdm_display_get_object_skeleton (GdmDisplay *self)

 {

         return self->priv->object_skeleton;

 }

 static void

 on_launch_environment_session_opened (GdmLaunchEnvironment *launch_environment,

                                       GdmDisplay           *self)

 {

         char       *session_id;

         g_debug ("GdmDisplay: Greeter session opened");

         session_id = gdm_launch_environment_get_session_id (launch_environment);

         _gdm_display_set_session_id (self, session_id);

         g_free (session_id);

 }

 static void

 on_launch_environment_session_started (GdmLaunchEnvironment *launch_environment,

                                        GdmDisplay           *self)

 {

         g_debug ("GdmDisplay: Greeter started");

 }

 static void

 self_destruct (GdmDisplay *self)

diff --git a/daemon/gdm-local-display-factory.c b/daemon/gdm-local-display-factory.c

index aae226750..35880563d 100644

--- a/daemon/gdm-local-display-factory.c

+++ b/daemon/gdm-local-display-factory.c

@@ -39,61 +39,60 @@

 #include "gdm-settings-keys.h"

 #include "gdm-settings-direct.h"

 #include "gdm-display-store.h"

 #include "gdm-local-display.h"

 #include "gdm-legacy-display.h"

 #define GDM_LOCAL_DISPLAY_FACTORY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_LOCAL_DISPLAY_FACTORY, GdmLocalDisplayFactoryPrivate))

 #define GDM_DBUS_PATH                       "/org/gnome/DisplayManager"

 #define GDM_LOCAL_DISPLAY_FACTORY_DBUS_PATH GDM_DBUS_PATH "/LocalDisplayFactory"

 #define GDM_MANAGER_DBUS_NAME               "org.gnome.DisplayManager.LocalDisplayFactory"

 #define MAX_DISPLAY_FAILURES 5

 #define WAIT_TO_FINISH_TIMEOUT 10 /* seconds */

 struct GdmLocalDisplayFactoryPrivate

 {

         GdmDBusLocalDisplayFactory *skeleton;

         GDBusConnection *connection;

         GHashTable      *used_display_numbers;

         /* FIXME: this needs to be per seat? */

         guint            num_failures;

         guint            seat_new_id;

         guint            seat_removed_id;

 #if defined(ENABLE_WAYLAND_SUPPORT) && defined(ENABLE_USER_DISPLAY_SERVER)

         unsigned int     active_vt;

         guint            active_vt_watch_id;

-        guint            wait_to_finish_timeout_id;

 #endif

 };

 enum {

         PROP_0,

 };

 static void     gdm_local_display_factory_class_init    (GdmLocalDisplayFactoryClass *klass);

 static void     gdm_local_display_factory_init          (GdmLocalDisplayFactory      *factory);

 static void     gdm_local_display_factory_finalize      (GObject                     *object);

 static GdmDisplay *create_display                       (GdmLocalDisplayFactory      *factory,

                                                          const char                  *seat_id,

                                                          const char                  *session_type,

                                                          gboolean                    initial_display);

 static void     on_display_status_changed               (GdmDisplay                  *display,

                                                          GParamSpec                  *arg1,

                                                          GdmLocalDisplayFactory      *factory);

 static gboolean gdm_local_display_factory_sync_seats    (GdmLocalDisplayFactory *factory);

 static gpointer local_display_factory_object = NULL;

 static gboolean lookup_by_session_id (const char *id,

                                       GdmDisplay *display,

                                       gpointer    user_data);

 G_DEFINE_TYPE (GdmLocalDisplayFactory, gdm_local_display_factory, GDM_TYPE_DISPLAY_FACTORY)

 GQuark

 gdm_local_display_factory_error_quark (void)

@@ -276,60 +275,79 @@ gdm_local_display_factory_create_transient_display (GdmLocalDisplayFactory *fact

 static gboolean

 finish_display_on_seat_if_waiting (GdmDisplayStore *display_store,

                                    GdmDisplay      *display,

                                    const char      *seat_id)

 {

         if (gdm_display_get_status (display) != GDM_DISPLAY_WAITING_TO_FINISH)

                 return FALSE;

         g_debug ("GdmLocalDisplayFactory: finish background display\n");

         gdm_display_stop_greeter_session (display);

         gdm_display_unmanage (display);

         gdm_display_finish (display);

         return FALSE;

 }

 static void

 finish_waiting_displays_on_seat (GdmLocalDisplayFactory *factory,

                                  const char             *seat_id)

 {

         GdmDisplayStore *store;

         store = gdm_display_factory_get_display_store (GDM_DISPLAY_FACTORY (factory));

         gdm_display_store_foreach (store,

                                    (GdmDisplayStoreFunc) finish_display_on_seat_if_waiting,

                                    (gpointer)

                                    seat_id);

 }

+static void

+on_session_registered_cb (GObject *gobject,

+                          GParamSpec *pspec,

+                          gpointer user_data)

+{

+        GdmDisplay *display = GDM_DISPLAY (gobject);

+        GdmLocalDisplayFactory *factory = GDM_LOCAL_DISPLAY_FACTORY (user_data);

+        gboolean registered;

+

+        g_object_get (display, "session-registered", &registered, NULL);

+

+        if (!registered)

+                return;

+

+        g_debug ("GdmLocalDisplayFactory: session registered on display, looking for any background displays to kill");

+

+        finish_waiting_displays_on_seat (factory, "seat0");

+}

+

 static void

 on_display_status_changed (GdmDisplay             *display,

                            GParamSpec             *arg1,

                            GdmLocalDisplayFactory *factory)

 {

         int              status;

         int              num;

         char            *seat_id = NULL;

         char            *session_type = NULL;

         char            *session_class = NULL;

         gboolean         is_initial = TRUE;

         gboolean         is_local = TRUE;

         num = -1;

         gdm_display_get_x11_display_number (display, &num, NULL);

         g_object_get (display,

                       "seat-id", &seat_id,

                       "is-initial", &is_initial,

                       "is-local", &is_local,

                       "session-type", &session_type,

                       "session-class", &session_class,

                       NULL);

         status = gdm_display_get_status (display);

         g_debug ("GdmLocalDisplayFactory: display status changed: %d", status);

         switch (status) {

         case GDM_DISPLAY_FINISHED:

                 /* remove the display number from factory->priv->used_display_numbers

@@ -359,60 +377,67 @@ on_display_status_changed (GdmDisplay             *display,

                 /* Create a new equivalent display if it was static */

                 if (is_local) {

                         factory->priv->num_failures++;

                         if (factory->priv->num_failures > MAX_DISPLAY_FAILURES) {

                                 /* oh shit */

                                 g_warning ("GdmLocalDisplayFactory: maximum number of X display failures reached: check X server log for errors");

                         } else {

 #ifdef ENABLE_WAYLAND_SUPPORT

                                 if (g_strcmp0 (session_type, "wayland") == 0) {

                                         g_free (session_type);

                                         session_type = NULL;

                                         /* workaround logind race for now

                                          * bug 1643874

                                          */

                                         g_usleep (2 * G_USEC_PER_SEC);

                                 }

 #endif

                                 create_display (factory, seat_id, session_type, is_initial);

                         }

                 }

                 break;

         case GDM_DISPLAY_UNMANAGED:

                 break;

         case GDM_DISPLAY_PREPARED:

                 break;

         case GDM_DISPLAY_MANAGED:

+#if defined(ENABLE_WAYLAND_SUPPORT) && defined(ENABLE_USER_DISPLAY_SERVER)

+                g_signal_connect_object (display,

+                                         "notify::session-registered",

+                                         G_CALLBACK (on_session_registered_cb),

+                                         factory,

+                                         0);

+#endif

                 break;

         case GDM_DISPLAY_WAITING_TO_FINISH:

                 break;

         default:

                 g_assert_not_reached ();

                 break;

         }

         g_free (seat_id);

         g_free (session_type);

         g_free (session_class);

 }

 static gboolean

 lookup_by_seat_id (const char *id,

                    GdmDisplay *display,

                    gpointer    user_data)

 {

         const char *looking_for = user_data;

         char *current;

         gboolean res;

         g_object_get (G_OBJECT (display), "seat-id", &current, NULL);

         res = g_strcmp0 (current, looking_for) == 0;

         g_free(current);

         return res;

 }

@@ -587,100 +612,83 @@ on_seat_new (GDBusConnection *connection,

 }

 static void

 on_seat_removed (GDBusConnection *connection,

                  const gchar     *sender_name,

                  const gchar     *object_path,

                  const gchar     *interface_name,

                  const gchar     *signal_name,

                  GVariant        *parameters,

                  gpointer         user_data)

 {

         const char *seat;

         g_variant_get (parameters, "(&s&o)", &seat, NULL);

         delete_display (GDM_LOCAL_DISPLAY_FACTORY (user_data), seat);

 }

 #if defined(ENABLE_WAYLAND_SUPPORT) && defined(ENABLE_USER_DISPLAY_SERVER)

 static gboolean

 lookup_by_session_id (const char *id,

                       GdmDisplay *display,