logind: check whether first drmSetMaster succeeded

[elogind.git] / src / login / logind-session-device.c

diff --git a/src/login/logind-session-device.c b/src/login/logind-session-device.c
index 80fd36413947ff2ae0833da58034cd28d1a59bef..546c53710e08ba9b857028dd926e9110e572023b 100644 (file)
--- a/src/login/logind-session-device.c
+++ b/src/login/logind-session-device.c
@@ -46,9 +46,13 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
         _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
         _cleanup_free_ char *path = NULL;
         const char *t = NULL;
+        uint32_t major, minor;
 
         assert(sd);
 
+        major = major(sd->dev);
+        minor = minor(sd->dev);
+
         if (!sd->session->controller)
                 return;
 
@@ -68,8 +72,8 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
         switch (type) {
         case SESSION_DEVICE_RESUME:
                 if (!dbus_message_append_args(m,
-                                              DBUS_TYPE_UINT32, major(sd->dev),
-                                              DBUS_TYPE_UINT32, minor(sd->dev),
+                                              DBUS_TYPE_UINT32, &major,
+                                              DBUS_TYPE_UINT32, &minor,
                                               DBUS_TYPE_UNIX_FD, &sd->fd,
                                               DBUS_TYPE_INVALID))
                         return;
@@ -88,8 +92,8 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
         }
 
         if (t && !dbus_message_append_args(m,
-                                           DBUS_TYPE_UINT32, major(sd->dev),
-                                           DBUS_TYPE_UINT32, minor(sd->dev),
+                                           DBUS_TYPE_UINT32, &major,
+                                           DBUS_TYPE_UINT32, &minor,
                                            DBUS_TYPE_STRING, &t,
                                            DBUS_TYPE_INVALID))
                 return;
@@ -140,7 +144,7 @@ static int sd_drmdropmaster(int fd) {
 }
 
 static int session_device_open(SessionDevice *sd, bool active) {
-        int fd;
+        int fd, r;
 
         assert(sd->type != DEVICE_TYPE_UNKNOWN);
 
@@ -151,9 +155,17 @@ static int session_device_open(SessionDevice *sd, bool active) {
 
         switch (sd->type) {
         case DEVICE_TYPE_DRM:
-                if (active)
-                        sd_drmsetmaster(fd);
-                else {
+                if (active) {
+                        /* Weird legacy DRM semantics might return an error
+                         * even though we're master. No way to detect that so
+                         * fail at all times and let caller retry in inactive
+                         * state. */
+                        r = sd_drmsetmaster(fd);
+                        if (r < 0) {
+                                close(fd);
+                                return r;
+                        }
+                } else {
                         /* DRM-Master is granted to the first user who opens a
                          * device automatically (ughh, racy!). Hence, we just
                          * drop DRM-Master in case we were the first. */
@@ -369,9 +381,7 @@ int session_device_new(Session *s, dev_t dev, SessionDevice **out) {
         if (r < 0)
                 goto error;
 
-        assert_cc(sizeof(unsigned long) >= sizeof(dev_t));
-
-        r = hashmap_put(s->devices, ULONG_TO_PTR((unsigned long)sd->dev), sd);
+        r = hashmap_put(s->devices, &sd->dev, sd);
         if (r < 0) {
                 r = -ENOMEM;
                 goto error;
@@ -382,9 +392,17 @@ int session_device_new(Session *s, dev_t dev, SessionDevice **out) {
          * revoke access and thus invalidate the fd. But this is still needed
          * to pass a valid fd back. */
         sd->active = session_is_active(s);
-        sd->fd = session_device_open(sd, sd->active);
-        if (sd->fd < 0)
-                goto error;
+        r = session_device_open(sd, sd->active);
+        if (r < 0) {
+                /* EINVAL _may_ mean a master is active; retry inactive */
+                if (sd->active && r == -EINVAL) {
+                        sd->active = false;
+                        r = session_device_open(sd, false);
+                }
+                if (r < 0)
+                        goto error;
+        }
+        sd->fd = r;
 
         LIST_PREPEND(SessionDevice, sd_by_device, sd->device->session_devices, sd);
 
@@ -392,7 +410,7 @@ int session_device_new(Session *s, dev_t dev, SessionDevice **out) {
         return 0;
 
 error:
-        hashmap_remove(s->devices, ULONG_TO_PTR((unsigned long)sd->dev));
+        hashmap_remove(s->devices, &sd->dev);
         free(sd->node);
         free(sd);
         return r;
@@ -407,17 +425,28 @@ void session_device_free(SessionDevice *sd) {
 
         LIST_REMOVE(SessionDevice, sd_by_device, sd->device->session_devices, sd);
 
-        hashmap_remove(sd->session->devices, ULONG_TO_PTR((unsigned long)sd->dev));
+        hashmap_remove(sd->session->devices, &sd->dev);
 
         free(sd->node);
         free(sd);
 }
 
 void session_device_complete_pause(SessionDevice *sd) {
+        SessionDevice *iter;
+        Iterator i;
+
         if (!sd->active)
                 return;
 
         session_device_stop(sd);
+
+        /* if not all devices are paused, wait for further completion events */
+        HASHMAP_FOREACH(iter, sd->session->devices, i)
+                if (iter->active)
+                        return;
+
+        /* complete any pending session switch */
+        seat_complete_switch(sd->session->seat);
 }
 
 void session_device_resume_all(Session *s) {
@@ -449,3 +478,20 @@ void session_device_pause_all(Session *s) {
                 }
         }
 }
+
+unsigned int session_device_try_pause_all(Session *s) {
+        SessionDevice *sd;
+        Iterator i;
+        unsigned int num_pending = 0;
+
+        assert(s);
+
+        HASHMAP_FOREACH(sd, s->devices, i) {
+                if (sd->active) {
+                        session_device_notify(sd, SESSION_DEVICE_TRY_PAUSE);
+                        ++num_pending;
+                }
+        }
+
+        return num_pending;
+}