X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flogin%2Flogind-session-device.c;h=592bcf2d9f958fcf88f8ef59e37cd67cfd229330;hp=80fd36413947ff2ae0833da58034cd28d1a59bef;hb=ec202eae8e84a4c99f054f771cb832046cb8769f;hpb=118ecf32425a590ea266b5c2b6de7962bb242356 diff --git a/src/login/logind-session-device.c b/src/login/logind-session-device.c index 80fd36413..592bcf2d9 100644 --- a/src/login/logind-session-device.c +++ b/src/login/logind-session-device.c @@ -30,10 +30,10 @@ #include #include -#include "dbus-common.h" -#include "logind-session-device.h" #include "util.h" #include "missing.h" +#include "bus-util.h" +#include "logind-session-device.h" enum SessionDeviceNotifications { SESSION_DEVICE_RESUME, @@ -42,37 +42,42 @@ enum SessionDeviceNotifications { SESSION_DEVICE_RELEASE, }; -static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) { - _cleanup_dbus_message_unref_ DBusMessage *m = NULL; +static int session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; _cleanup_free_ char *path = NULL; const char *t = NULL; + uint32_t major, minor; + int r; assert(sd); + major = major(sd->dev); + minor = minor(sd->dev); + if (!sd->session->controller) - return; + return 0; path = session_bus_path(sd->session); if (!path) - return; + return -ENOMEM; - m = dbus_message_new_signal(path, - "org.freedesktop.login1.Session", - (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice"); + r = sd_bus_message_new_signal( + sd->session->manager->bus, path, + "org.freedesktop.login1.Session", + (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice", + &m); if (!m) - return; + return r; - if (!dbus_message_set_destination(m, sd->session->controller)) - return; + r = sd_bus_message_set_destination(m, sd->session->controller); + if (r < 0) + return r; 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_UNIX_FD, &sd->fd, - DBUS_TYPE_INVALID)) - return; + r = sd_bus_message_append(m, "uuh", major, minor, sd->fd); + if (r < 0) + return r; break; case SESSION_DEVICE_TRY_PAUSE: t = "pause"; @@ -84,17 +89,16 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat t = "gone"; break; default: - return; + return -EINVAL; } - if (t && !dbus_message_append_args(m, - DBUS_TYPE_UINT32, major(sd->dev), - DBUS_TYPE_UINT32, minor(sd->dev), - DBUS_TYPE_STRING, &t, - DBUS_TYPE_INVALID)) - return; + if (t) { + r = sd_bus_message_append(m, "uus", major, minor, t); + if (r < 0) + return r; + } - dbus_connection_send(sd->session->manager->bus, m, NULL); + return sd_bus_send(sd->session->manager->bus, m, NULL); } static int sd_eviocrevoke(int fd) { @@ -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_nointr(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. */ @@ -164,7 +176,6 @@ static int session_device_open(SessionDevice *sd, bool active) { if (!active) sd_eviocrevoke(fd); break; - case DEVICE_TYPE_FBDEV: case DEVICE_TYPE_UNKNOWN: default: /* fallback for devices wihout synchronizations */ @@ -198,17 +209,9 @@ static int session_device_start(SessionDevice *sd) { r = session_device_open(sd, true); if (r < 0) return r; - close_nointr_nofail(sd->fd); + close_nointr(sd->fd); sd->fd = r; break; - case DEVICE_TYPE_FBDEV: - /* fbdev devices have no way to synchronize access. Moreover, - * they mostly operate through mmaps() without any pageflips - * and modesetting, so there is no way for us to prevent access - * but tear down mmaps. - * That would be quite expensive to do on a per-fd context. So - * ignore legcy fbdev and let its users feel the pain they asked - * for when deciding for fbdev. */ case DEVICE_TYPE_UNKNOWN: default: /* fallback for devices wihout synchronizations */ @@ -240,7 +243,6 @@ static void session_device_stop(SessionDevice *sd) { * protection this way. */ sd_eviocrevoke(sd->fd); break; - case DEVICE_TYPE_FBDEV: case DEVICE_TYPE_UNKNOWN: default: /* fallback for devices without synchronization */ @@ -258,10 +260,7 @@ static DeviceType detect_device_type(struct udev_device *dev) { subsystem = udev_device_get_subsystem(dev); type = DEVICE_TYPE_UNKNOWN; - if (streq_ptr(subsystem, "graphics")) { - if (!streq(sysname, "fbcon") && startswith(sysname, "fb")) - type = DEVICE_TYPE_FBDEV; - } else if (streq_ptr(subsystem, "drm")) { + if (streq_ptr(subsystem, "drm")) { if (startswith(sysname, "card")) type = DEVICE_TYPE_DRM; } else if (streq_ptr(subsystem, "input")) { @@ -302,8 +301,7 @@ static int session_device_verify(SessionDevice *sd) { goto err_dev; } sp = udev_device_get_syspath(dev); - } else if (sd->type != DEVICE_TYPE_FBDEV && - sd->type != DEVICE_TYPE_DRM) { + } else if (sd->type != DEVICE_TYPE_DRM) { /* Prevent opening unsupported devices. Especially devices of * subsystem "input" must be opened via the evdev node as * we require EVIOCREVOKE. */ @@ -369,9 +367,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,17 +378,25 @@ 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); + LIST_PREPEND(sd_by_device, sd->device->session_devices, sd); *out = sd; 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; @@ -403,21 +407,32 @@ void session_device_free(SessionDevice *sd) { session_device_stop(sd); session_device_notify(sd, SESSION_DEVICE_RELEASE); - close_nointr_nofail(sd->fd); + close_nointr(sd->fd); - LIST_REMOVE(SessionDevice, sd_by_device, sd->device->session_devices, sd); + LIST_REMOVE(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 +464,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; +}