system/weston
system/weston
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/weston synced 2024-10-05 05:22:30 +00:00
Code Issues Packages Projects Releases Wiki Activity
weston/src/launcher-logind.c

941 lines
21 KiB
C
Raw Normal View History

launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
/*
* Copyright © 2013 David Herrmann
*
src: Update boilerplate from MIT X11 license to MIT Expat license
2015-06-11 22:35:43 +00:00
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
*
src: Update boilerplate from MIT X11 license to MIT Expat license
2015-06-11 22:35:43 +00:00
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
*/
#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <linux/vt.h>
#include <linux/kd.h>
#include <linux/major.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/signalfd.h>
#include <sys/stat.h>
#include <systemd/sd-login.h>
#include <unistd.h>
#include "compositor.h"
#include "dbus.h"
launcher: Rename logind-util to launcher-logind We're refactoring this to have multiple launcher "implementations". Reviewed-by: Derek Foreman <derekf@osg.samsung.com>
2015-09-23 17:46:46 +00:00
#include "launcher-logind.h"
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
#define DRM_MAJOR 226
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
#ifndef KDSKBMUTE
#define KDSKBMUTE 0x4B51
#endif
struct weston_logind {
struct weston_compositor *compositor;
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
bool sync_drm;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
char *seat;
char *sid;
unsigned int vtnr;
int vt;
int kb_mode;
int sfd;
struct wl_event_source *sfd_source;
DBusConnection *dbus;
struct wl_event_source *dbus_ctx;
char *spath;
DBusPendingCall *pending_active;
};
static int
weston_logind_take_device(struct weston_logind *wl, uint32_t major,
uint32_t minor, bool *paused_out)
{
DBusMessage *m, *reply;
logind: Use dbus_bool_t for bool types in dbus calls The gcc built-in 'bool' type is not the same size as dbus_bool_t, which is an uint32_t. Passing a pointer to bool where dbus expects a uint32_t * doesn't work. Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
2013-11-21 00:37:07 +00:00
bool b;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
int r, fd;
logind: Use dbus_bool_t for bool types in dbus calls The gcc built-in 'bool' type is not the same size as dbus_bool_t, which is an uint32_t. Passing a pointer to bool where dbus expects a uint32_t * doesn't work. Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
2013-11-21 00:37:07 +00:00
dbus_bool_t paused;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.login1.Session",
"TakeDevice");
if (!m)
return -ENOMEM;
b = dbus_message_append_args(m,
DBUS_TYPE_UINT32, &major,
DBUS_TYPE_UINT32, &minor,
DBUS_TYPE_INVALID);
if (!b) {
r = -ENOMEM;
goto err_unref;
}
reply = dbus_connection_send_with_reply_and_block(wl->dbus, m,
-1, NULL);
if (!reply) {
r = -ENODEV;
goto err_unref;
}
b = dbus_message_get_args(reply, NULL,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_BOOLEAN, &paused,
DBUS_TYPE_INVALID);
if (!b) {
r = -ENODEV;
goto err_reply;
}
r = fd;
if (paused_out)
*paused_out = paused;
err_reply:
dbus_message_unref(reply);
err_unref:
dbus_message_unref(m);
return r;
}
static void
weston_logind_release_device(struct weston_logind *wl, uint32_t major,
uint32_t minor)
{
DBusMessage *m;
bool b;
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.login1.Session",
"ReleaseDevice");
if (m) {
b = dbus_message_append_args(m,
DBUS_TYPE_UINT32, &major,
DBUS_TYPE_UINT32, &minor,
DBUS_TYPE_INVALID);
if (b)
dbus_connection_send(wl->dbus, m, NULL);
dbus_message_unref(m);
}
}
static void
weston_logind_pause_device_complete(struct weston_logind *wl, uint32_t major,
uint32_t minor)
{
DBusMessage *m;
bool b;
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.login1.Session",
"PauseDeviceComplete");
if (m) {
b = dbus_message_append_args(m,
DBUS_TYPE_UINT32, &major,
DBUS_TYPE_UINT32, &minor,
DBUS_TYPE_INVALID);
if (b)
dbus_connection_send(wl->dbus, m, NULL);
dbus_message_unref(m);
}
}
WL_EXPORT int
weston_logind_open(struct weston_logind *wl, const char *path,
int flags)
{
struct stat st;
int fl, r, fd;
r = stat(path, &st);
if (r < 0)
logind: change to -1+errno Set errno and return -1 in public API calls like all other weston code does. Most systemd+dbus calls return negative error-codes instead of -1 and setting errno. Thus, we need to explicitly set errno before returning. Also note that we must set errno _after_ the cleanup path. Calling functions like close() in the cleanup path might overwrite errno (which is not what we want). So protect errno until the final return -1;
2013-11-21 08:14:46 +00:00
return -1;
if (!S_ISCHR(st.st_mode)) {
errno = ENODEV;
return -1;
}
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
fd = weston_logind_take_device(wl, major(st.st_rdev),
minor(st.st_rdev), NULL);
if (fd < 0)
return fd;
/* Compared to weston_launcher_open() we cannot specify the open-mode
* directly. Instead, logind passes us an fd with sane default modes.
* For DRM and evdev this means O_RDWR | O_CLOEXEC. If we want
* something else, we need to change it afterwards. We currently
launcher-util: Force all weston_launcher_open()s to use O_CLOEXEC Really, there's pretty much no time we'd ever want O_CLOEXEC unset, as it will likely result in leaking fds to processes that aren't interested in them or shouldn't have them. This also removes the (now unused) code from weston_logind_open() that could drop O_CLOEXEC. Signed-off-by: Derek Foreman <derekf@osg.samsung.com> Reviewed-by: Daniel Stone <daniels@collabora.com> Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
2015-05-01 16:46:36 +00:00
* only support setting O_NONBLOCK. Changing access-modes is not
* possible so accept whatever logind passes us. */
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
fl = fcntl(fd, F_GETFL);
if (fl < 0) {
r = -errno;
goto err_close;
}
if (flags & O_NONBLOCK)
fl |= O_NONBLOCK;
r = fcntl(fd, F_SETFL, fl);
if (r < 0) {
r = -errno;
goto err_close;
}
return fd;
err_close:
close(fd);
weston_logind_release_device(wl, major(st.st_rdev),
minor(st.st_rdev));
logind: change to -1+errno Set errno and return -1 in public API calls like all other weston code does. Most systemd+dbus calls return negative error-codes instead of -1 and setting errno. Thus, we need to explicitly set errno before returning. Also note that we must set errno _after_ the cleanup path. Calling functions like close() in the cleanup path might overwrite errno (which is not what we want). So protect errno until the final return -1;
2013-11-21 08:14:46 +00:00
errno = -r;
return -1;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
}
WL_EXPORT void
weston_logind_close(struct weston_logind *wl, int fd)
{
struct stat st;
int r;
r = fstat(fd, &st);
if (r < 0) {
weston_log("logind: cannot fstat fd: %m\n");
return;
}
if (!S_ISCHR(st.st_mode)) {
weston_log("logind: invalid device passed\n");
return;
}
weston_logind_release_device(wl, major(st.st_rdev),
minor(st.st_rdev));
}
WL_EXPORT void
weston_logind_restore(struct weston_logind *wl)
{
struct vt_mode mode = { 0 };
ioctl(wl->vt, KDSETMODE, KD_TEXT);
ioctl(wl->vt, KDSKBMUTE, 0);
ioctl(wl->vt, KDSKBMODE, wl->kb_mode);
mode.mode = VT_AUTO;
ioctl(wl->vt, VT_SETMODE, &mode);
}
WL_EXPORT int
weston_logind_activate_vt(struct weston_logind *wl, int vt)
{
int r;
r = ioctl(wl->vt, VT_ACTIVATE, vt);
if (r < 0)
logind: change to -1+errno Set errno and return -1 in public API calls like all other weston code does. Most systemd+dbus calls return negative error-codes instead of -1 and setting errno. Thus, we need to explicitly set errno before returning. Also note that we must set errno _after_ the cleanup path. Calling functions like close() in the cleanup path might overwrite errno (which is not what we want). So protect errno until the final return -1;
2013-11-21 08:14:46 +00:00
return -1;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
return 0;
}
static void
weston_logind_set_active(struct weston_logind *wl, bool active)
{
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
if (!wl->compositor->session_active == !active)
return;
wl->compositor->session_active = active;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
wl_signal_emit(&wl->compositor->session_signal,
wl->compositor);
}
static void
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
parse_active(struct weston_logind *wl, DBusMessage *m, DBusMessageIter *iter)
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
{
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
DBusMessageIter sub;
logind: Use dbus_bool_t for bool types in dbus calls The gcc built-in 'bool' type is not the same size as dbus_bool_t, which is an uint32_t. Passing a pointer to bool where dbus expects a uint32_t * doesn't work. Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
2013-11-21 00:37:07 +00:00
dbus_bool_t b;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
return;
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
dbus_message_iter_recurse(iter, &sub);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
return;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
dbus_message_iter_get_basic(&sub, &b);
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
/* If the backend requested DRM master-device synchronization, we only
* wake-up the compositor once the master-device is up and running. For
* other backends, we immediately forward the Active-change event. */
if (!wl->sync_drm || !b)
weston_logind_set_active(wl, b);
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
}
static void
get_active_cb(DBusPendingCall *pending, void *data)
{
struct weston_logind *wl = data;
DBusMessageIter iter;
DBusMessage *m;
int type;
dbus_pending_call_unref(wl->pending_active);
wl->pending_active = NULL;
m = dbus_pending_call_steal_reply(pending);
if (!m)
return;
type = dbus_message_get_type(m);
if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN &&
dbus_message_iter_init(m, &iter))
parse_active(wl, m, &iter);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
dbus_message_unref(m);
}
static void
weston_logind_get_active(struct weston_logind *wl)
{
DBusPendingCall *pending;
DBusMessage *m;
bool b;
const char *iface, *name;
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.DBus.Properties",
"Get");
if (!m)
return;
iface = "org.freedesktop.login1.Session";
name = "Active";
b = dbus_message_append_args(m,
DBUS_TYPE_STRING, &iface,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID);
if (!b)
goto err_unref;
b = dbus_connection_send_with_reply(wl->dbus, m, &pending, -1);
if (!b)
goto err_unref;
b = dbus_pending_call_set_notify(pending, get_active_cb, wl, NULL);
if (!b) {
dbus_pending_call_cancel(pending);
dbus_pending_call_unref(pending);
goto err_unref;
}
if (wl->pending_active) {
dbus_pending_call_cancel(wl->pending_active);
dbus_pending_call_unref(wl->pending_active);
}
wl->pending_active = pending;
return;
err_unref:
dbus_message_unref(m);
}
static void
disconnected_dbus(struct weston_logind *wl)
{
weston_log("logind: dbus connection lost, exiting..\n");
weston_logind_restore(wl);
exit(-1);
}
static void
session_removed(struct weston_logind *wl, DBusMessage *m)
{
const char *name, *obj;
bool r;
r = dbus_message_get_args(m, NULL,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_OBJECT_PATH, &obj,
DBUS_TYPE_INVALID);
if (!r) {
weston_log("logind: cannot parse SessionRemoved dbus signal\n");
return;
}
if (!strcmp(name, wl->sid)) {
weston_log("logind: our session got closed, exiting..\n");
weston_logind_restore(wl);
exit(-1);
}
}
static void
property_changed(struct weston_logind *wl, DBusMessage *m)
{
DBusMessageIter iter, sub, entry;
const char *interface, *name;
if (!dbus_message_iter_init(m, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
goto error;
dbus_message_iter_get_basic(&iter, &interface);
if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
goto error;
dbus_message_iter_recurse(&iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY) {
dbus_message_iter_recurse(&sub, &entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
goto error;
dbus_message_iter_get_basic(&entry, &name);
if (!dbus_message_iter_next(&entry))
goto error;
if (!strcmp(name, "Active")) {
logind: fix PropertiesChanged parser The current parser directly reads a BOOLEAN on the PropertiesChanged signal for 'Active' properties. However, all property-values are packed in a VARIANT, otherwise, we wouldn't know the type. Fix the parser to recurse into the variant before reading the boolean. To avoid such bugs in the future, we extract the 'Active' parser into a helper function parse_active(), which is then shared between the PropertiesChanged and Get handlers. Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:23 +00:00
parse_active(wl, m, &entry);
return;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
}
dbus_message_iter_next(&sub);
}
if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
goto error;
dbus_message_iter_recurse(&iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
dbus_message_iter_get_basic(&sub, &name);
if (!strcmp(name, "Active")) {
weston_logind_get_active(wl);
return;
}
dbus_message_iter_next(&sub);
}
return;
error:
weston_log("logind: cannot parse PropertiesChanged dbus signal\n");
}
static void
device_paused(struct weston_logind *wl, DBusMessage *m)
{
bool r;
const char *type;
uint32_t major, minor;
r = dbus_message_get_args(m, NULL,
DBUS_TYPE_UINT32, &major,
DBUS_TYPE_UINT32, &minor,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INVALID);
if (!r) {
weston_log("logind: cannot parse PauseDevice dbus signal\n");
return;
}
/* "pause" means synchronous pausing. Acknowledge it unconditionally
* as we support asynchronous device shutdowns, anyway.
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
* "force" means asynchronous pausing.
* "gone" means the device is gone. We handle it the same as "force" as
* a following udev event will be caught, too.
*
* If it's our main DRM device, tell the compositor to go asleep. */
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
if (!strcmp(type, "pause"))
weston_logind_pause_device_complete(wl, major, minor);
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
if (wl->sync_drm && major == DRM_MAJOR)
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
weston_logind_set_active(wl, false);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
}
static void
device_resumed(struct weston_logind *wl, DBusMessage *m)
{
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
bool r;
uint32_t major;
r = dbus_message_get_args(m, NULL,
DBUS_TYPE_UINT32, &major,
/*DBUS_TYPE_UINT32, &minor,
DBUS_TYPE_UNIX_FD, &fd,*/
DBUS_TYPE_INVALID);
if (!r) {
weston_log("logind: cannot parse ResumeDevice dbus signal\n");
return;
}
/* DeviceResumed messages provide us a new file-descriptor for
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
* resumed devices. For DRM devices it's the same as before, for evdev
* devices it's a new open-file. As we reopen evdev devices, anyway,
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
* there is no need for us to handle this event for evdev. For DRM, we
* notify the compositor to wake up. */
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
if (wl->sync_drm && major == DRM_MAJOR)
logind: delay wakeup until DRM-device is resumed The logind API was designed to allow any kind of devices and any number of devices. It has no idea of "main DRM device" or similar. However, the weston DRM backend was designed with a single DRM device as master. Therefore, we wake it up unconditionally on session-wakeup. But this may fail with logind as a session may be awake, but not all devices have been resumed, yet. Therefore, we change the weston-logind backend to deal with this case correctly. Instead of waking up the compositor on session-wakeup, we wait for the main DRM device to wake up. Once we get the event, we notify the compositor. For sleep, we reverse this logic. On *any* of the following events we tell the compositor to go to sleep: - Session gets inactive - DRM device gets inactive - DRM device is removed This guarantees, that weston is only active if *both*, the session and the main DRM device are awake/active. Note that we could actually rely solely on the DRM-device Pause/Resume events from logind and drop all the Active-Prop-Changed handling. logind guarantees proper ordering of both. However, in case we ever change weston to support multiple GPUs, we need the per-device notification. Thus, keep the code. This also makes weston more fail-safe in case logind fails to send the PauseDevice event (for whatever reason..).
2013-11-30 10:25:45 +00:00
weston_logind_set_active(wl, true);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
}
static DBusHandlerResult
filter_dbus(DBusConnection *c, DBusMessage *m, void *data)
{
struct weston_logind *wl = data;
if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected")) {
disconnected_dbus(wl);
} else if (dbus_message_is_signal(m, "org.freedesktop.login1.Manager",
"SessionRemoved")) {
session_removed(wl, m);
} else if (dbus_message_is_signal(m, "org.freedesktop.DBus.Properties",
"PropertiesChanged")) {
property_changed(wl, m);
} else if (dbus_message_is_signal(m, "org.freedesktop.login1.Session",
"PauseDevice")) {
device_paused(wl, m);
} else if (dbus_message_is_signal(m, "org.freedesktop.login1.Session",
"ResumeDevice")) {
device_resumed(wl, m);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static int
weston_logind_setup_dbus(struct weston_logind *wl)
{
bool b;
int r;
r = asprintf(&wl->spath, "/org/freedesktop/login1/session/%s",
wl->sid);
if (r < 0)
return -ENOMEM;
b = dbus_connection_add_filter(wl->dbus, filter_dbus, wl, NULL);
if (!b) {
weston_log("logind: cannot add dbus filter\n");
r = -ENOMEM;
goto err_spath;
}
r = weston_dbus_add_match_signal(wl->dbus,
"org.freedesktop.login1",
"org.freedesktop.login1.Manager",
"SessionRemoved",
"/org/freedesktop/login1");
if (r < 0) {
weston_log("logind: cannot add dbus match\n");
goto err_spath;
}
r = weston_dbus_add_match_signal(wl->dbus,
"org.freedesktop.login1",
"org.freedesktop.login1.Session",
"PauseDevice",
wl->spath);
if (r < 0) {
weston_log("logind: cannot add dbus match\n");
goto err_spath;
}
r = weston_dbus_add_match_signal(wl->dbus,
"org.freedesktop.login1",
"org.freedesktop.login1.Session",
"ResumeDevice",
wl->spath);
if (r < 0) {
weston_log("logind: cannot add dbus match\n");
goto err_spath;
}
r = weston_dbus_add_match_signal(wl->dbus,
"org.freedesktop.login1",
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
wl->spath);
if (r < 0) {
weston_log("logind: cannot add dbus match\n");
goto err_spath;
}
return 0;
err_spath:
/* don't remove any dbus-match as the connection is closed, anyway */
free(wl->spath);
return r;
}
static void
weston_logind_destroy_dbus(struct weston_logind *wl)
{
/* don't remove any dbus-match as the connection is closed, anyway */
free(wl->spath);
}
static int
weston_logind_take_control(struct weston_logind *wl)
{
DBusError err;
DBusMessage *m, *reply;
dbus_bool_t force;
bool b;
int r;
dbus_error_init(&err);
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.login1.Session",
"TakeControl");
if (!m)
return -ENOMEM;
force = false;
b = dbus_message_append_args(m,
DBUS_TYPE_BOOLEAN, &force,
DBUS_TYPE_INVALID);
if (!b) {
r = -ENOMEM;
goto err_unref;
}
reply = dbus_connection_send_with_reply_and_block(wl->dbus,
m, -1, &err);
if (!reply) {
if (dbus_error_has_name(&err, DBUS_ERROR_UNKNOWN_METHOD))
weston_log("logind: old systemd version detected\n");
else
weston_log("logind: cannot take control over session %s\n", wl->sid);
dbus_error_free(&err);
r = -EIO;
goto err_unref;
}
dbus_message_unref(reply);
dbus_message_unref(m);
return 0;
err_unref:
dbus_message_unref(m);
return r;
}
static void
weston_logind_release_control(struct weston_logind *wl)
{
DBusMessage *m;
m = dbus_message_new_method_call("org.freedesktop.login1",
wl->spath,
"org.freedesktop.login1.Session",
"ReleaseControl");
if (m) {
dbus_connection_send(wl->dbus, m, NULL);
dbus_message_unref(m);
}
}
static int
signal_event(int fd, uint32_t mask, void *data)
{
struct weston_logind *wl = data;
struct signalfd_siginfo sig;
if (read(fd, &sig, sizeof sig) != sizeof sig) {
weston_log("logind: cannot read signalfd: %m\n");
return 0;
}
logind: use SIGRTMIN to not conflict with xwayland xwayland uses SIGUSR1 as startup notification. Make sure to use SIGRTMIN and SIGRTMIN+1 for VT handling. A bonus is SIGRT* signals can be queued multiple times, so we will be able to correctly track them and will no longer lose signals (which wouldn't really matter, but is confusing in logs). Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:20 +00:00
if (sig.ssi_signo == (unsigned int)SIGRTMIN)
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
ioctl(wl->vt, VT_RELDISP, 1);
logind: use SIGRTMIN to not conflict with xwayland xwayland uses SIGUSR1 as startup notification. Make sure to use SIGRTMIN and SIGRTMIN+1 for VT handling. A bonus is SIGRT* signals can be queued multiple times, so we will be able to correctly track them and will no longer lose signals (which wouldn't really matter, but is confusing in logs). Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:20 +00:00
else if (sig.ssi_signo == (unsigned int)SIGRTMIN + 1)
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
ioctl(wl->vt, VT_RELDISP, VT_ACKACQ);
return 0;
}
static int
weston_logind_setup_vt(struct weston_logind *wl)
{
struct stat st;
char buf[64];
struct vt_mode mode = { 0 };
int r;
sigset_t mask;
struct wl_event_loop *loop;
logind-util: Use %u for unsigned int in snprintf Addresses this warning found by Denis Denisov: [src/logind-util.c:702]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. Signed-off-by: Bryce Harrington <bryce@osg.samsung.com> Reviewed-by: Marek Chalupa <mchqwerty@gmail.com> Reviewed-By: Derek Foreman <derekf@osg.samsung.com>
2015-07-11 02:51:52 +00:00
snprintf(buf, sizeof(buf), "/dev/tty%u", wl->vtnr);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
buf[sizeof(buf) - 1] = 0;
wl->vt = open(buf, O_RDWR|O_CLOEXEC|O_NONBLOCK);
if (wl->vt < 0) {
r = -errno;
weston_log("logind: cannot open VT %s: %m\n", buf);
return r;
}
if (fstat(wl->vt, &st) == -1 ||
major(st.st_rdev) != TTY_MAJOR || minor(st.st_rdev) <= 0 ||
minor(st.st_rdev) >= 64) {
r = -EINVAL;
weston_log("logind: TTY %s is no virtual terminal\n", buf);
goto err_close;
}
/*r = setsid();
if (r < 0 && errno != EPERM) {
r = -errno;
weston_log("logind: setsid() failed: %m\n");
goto err_close;
}
r = ioctl(wl->vt, TIOCSCTTY, 0);
if (r < 0)
weston_log("logind: VT %s already in use\n", buf);*/
if (ioctl(wl->vt, KDGKBMODE, &wl->kb_mode) < 0) {
weston_log("logind: cannot read keyboard mode on %s: %m\n",
buf);
wl->kb_mode = K_UNICODE;
} else if (wl->kb_mode == K_OFF) {
wl->kb_mode = K_UNICODE;
}
if (ioctl(wl->vt, KDSKBMUTE, 1) < 0 &&
ioctl(wl->vt, KDSKBMODE, K_OFF) < 0) {
r = -errno;
weston_log("logind: cannot set K_OFF KB-mode on %s: %m\n",
buf);
goto err_close;
}
if (ioctl(wl->vt, KDSETMODE, KD_GRAPHICS) < 0) {
r = -errno;
weston_log("logind: cannot set KD_GRAPHICS mode on %s: %m\n",
buf);
goto err_kbmode;
}
logind: use SIGRTMIN to not conflict with xwayland xwayland uses SIGUSR1 as startup notification. Make sure to use SIGRTMIN and SIGRTMIN+1 for VT handling. A bonus is SIGRT* signals can be queued multiple times, so we will be able to correctly track them and will no longer lose signals (which wouldn't really matter, but is confusing in logs). Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:20 +00:00
/*
* SIGRTMIN is used as global VT-release signal, SIGRTMIN + 1 is used
* as VT-acquire signal. Note that SIGRT* must be tested on runtime, as
* their exact values are not known at compile-time. POSIX requires 32
* of them to be available, though.
*/
if (SIGRTMIN + 1 > SIGRTMAX) {
weston_log("logind: not enough RT signals available: %u-%u\n",
SIGRTMIN, SIGRTMAX);
return -EINVAL;
}
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
sigemptyset(&mask);
logind: use SIGRTMIN to not conflict with xwayland xwayland uses SIGUSR1 as startup notification. Make sure to use SIGRTMIN and SIGRTMIN+1 for VT handling. A bonus is SIGRT* signals can be queued multiple times, so we will be able to correctly track them and will no longer lose signals (which wouldn't really matter, but is confusing in logs). Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:20 +00:00
sigaddset(&mask, SIGRTMIN);
sigaddset(&mask, SIGRTMIN + 1);
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
sigprocmask(SIG_BLOCK, &mask, NULL);
wl->sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
if (wl->sfd < 0) {
r = -errno;
weston_log("logind: cannot create signalfd: %m\n");
goto err_mode;
}
loop = wl_display_get_event_loop(wl->compositor->wl_display);
wl->sfd_source = wl_event_loop_add_fd(loop, wl->sfd,
WL_EVENT_READABLE,
signal_event, wl);
if (!wl->sfd_source) {
r = -errno;
weston_log("logind: cannot create signalfd source: %m\n");
goto err_sfd;
}
mode.mode = VT_PROCESS;
logind: use SIGRTMIN to not conflict with xwayland xwayland uses SIGUSR1 as startup notification. Make sure to use SIGRTMIN and SIGRTMIN+1 for VT handling. A bonus is SIGRT* signals can be queued multiple times, so we will be able to correctly track them and will no longer lose signals (which wouldn't really matter, but is confusing in logs). Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:20 +00:00
mode.relsig = SIGRTMIN;
mode.acqsig = SIGRTMIN + 1;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
if (ioctl(wl->vt, VT_SETMODE, &mode) < 0) {
r = -errno;
weston_log("logind: cannot take over VT: %m\n");
goto err_sfd_source;
}
weston_log("logind: using VT %s\n", buf);
return 0;
err_sfd_source:
wl_event_source_remove(wl->sfd_source);
err_sfd:
close(wl->sfd);
err_mode:
ioctl(wl->vt, KDSETMODE, KD_TEXT);
err_kbmode:
ioctl(wl->vt, KDSKBMUTE, 0);
ioctl(wl->vt, KDSKBMODE, wl->kb_mode);
err_close:
close(wl->vt);
return r;
}
static void
weston_logind_destroy_vt(struct weston_logind *wl)
{
weston_logind_restore(wl);
wl_event_source_remove(wl->sfd_source);
close(wl->sfd);
close(wl->vt);
}
WL_EXPORT int
weston_logind_connect(struct weston_logind **out,
struct weston_compositor *compositor,
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
const char *seat_id, int tty, bool sync_drm)
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
{
struct weston_logind *wl;
struct wl_event_loop *loop;
char *t;
int r;
Use zalloc instead of calloc(1, ...) Signed-off-by: Bryce Harrington <bryce@osg.samsung.com> Reviewed-by: Marek Chalupa <mchqwerty@gmail.com>
2014-11-21 06:21:57 +00:00
wl = zalloc(sizeof(*wl));
if (wl == NULL) {
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
r = -ENOMEM;
goto err_out;
}
wl->compositor = compositor;
logind: forward Active=true changes for non-DRM backends Logind sends us a notification whenever the Active attribute of our session changes. However, due to the way compositor-drm.c relies on the master DRM device to be synced with the session, we used to delay Active=true handling until the DRM device was up, too. See: commit aedc7732ebd9bc7b4f51ee247ea857ffec6260a7 Author: David Herrmann <dh.herrmann@gmail.com> Date: Sat Nov 30 11:25:45 2013 +0100 logind: delay wakeup until DRM-device is resumed However, the other compositor backends do not use DRM, so logind-util will never get notified about any DRM device. Therefore, we have to forward the Active=true change immediately. This commit fixes logind-util to take sync_drm as argument. If it is true, we do DRM-device synchronisation, otherwise we don't. Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=86889 Signed-off-by: David Herrmann <dh.herrmann@gmail.com> Reviewed-by: Bryce Harrington <bryce@osg.samsung.com> Tested-by: nerdopolis <bluescreen_avenger@verizon.net>
2014-12-30 13:33:22 +00:00
wl->sync_drm = sync_drm;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
wl->seat = strdup(seat_id);
if (!wl->seat) {
r = -ENOMEM;
goto err_wl;
}
r = sd_pid_get_session(getpid(), &wl->sid);
if (r < 0) {
weston_log("logind: not running in a systemd session\n");
goto err_seat;
}
t = NULL;
r = sd_session_get_seat(wl->sid, &t);
logind: Return proper error value when tty or seat doesn't match If the seat or tty doesn't match we return with r == 0, which looks like success to weston_launcher_connect(), which then fails to fall back to the legacy path. https://bugs.freedesktop.org/show_bug.cgi?id=70876
2013-10-30 20:53:01 +00:00
if (r < 0) {
weston_log("logind: failed to get session seat\n");
free(t);
goto err_session;
} else if (strcmp(seat_id, t)) {
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
weston_log("logind: weston's seat '%s' differs from session-seat '%s'\n",
seat_id, t);
logind: Return proper error value when tty or seat doesn't match If the seat or tty doesn't match we return with r == 0, which looks like success to weston_launcher_connect(), which then fails to fall back to the legacy path. https://bugs.freedesktop.org/show_bug.cgi?id=70876
2013-10-30 20:53:01 +00:00
r = -EINVAL;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
free(t);
goto err_session;
}
free(t);
r = weston_sd_session_get_vt(wl->sid, &wl->vtnr);
if (r < 0) {
weston_log("logind: session not running on a VT\n");
goto err_session;
} else if (tty > 0 && wl->vtnr != (unsigned int )tty) {
weston_log("logind: requested VT --tty=%d differs from real session VT %u\n",
tty, wl->vtnr);
logind: Return proper error value when tty or seat doesn't match If the seat or tty doesn't match we return with r == 0, which looks like success to weston_launcher_connect(), which then fails to fall back to the legacy path. https://bugs.freedesktop.org/show_bug.cgi?id=70876
2013-10-30 20:53:01 +00:00
r = -EINVAL;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
goto err_session;
}
loop = wl_display_get_event_loop(compositor->wl_display);
r = weston_dbus_open(loop, DBUS_BUS_SYSTEM, &wl->dbus, &wl->dbus_ctx);
if (r < 0) {
weston_log("logind: cannot connect to system dbus\n");
goto err_session;
}
r = weston_logind_setup_dbus(wl);
if (r < 0)
goto err_dbus;
r = weston_logind_take_control(wl);
if (r < 0)
goto err_dbus_cleanup;
r = weston_logind_setup_vt(wl);
if (r < 0)
goto err_control;
weston_log("logind: session control granted\n");
*out = wl;
return 0;
err_control:
weston_logind_release_control(wl);
err_dbus_cleanup:
weston_logind_destroy_dbus(wl);
err_dbus:
weston_dbus_close(wl->dbus, wl->dbus_ctx);
err_session:
free(wl->sid);
err_seat:
free(wl->seat);
err_wl:
free(wl);
err_out:
weston_log("logind: cannot setup systemd-logind helper (%d), using legacy fallback\n", r);
logind: change to -1+errno Set errno and return -1 in public API calls like all other weston code does. Most systemd+dbus calls return negative error-codes instead of -1 and setting errno. Thus, we need to explicitly set errno before returning. Also note that we must set errno _after_ the cleanup path. Calling functions like close() in the cleanup path might overwrite errno (which is not what we want). So protect errno until the final return -1;
2013-11-21 08:14:46 +00:00
errno = -r;
return -1;
launcher: add logind backend Instead of connecting to weston-launch from launcher-util, we now try to connect to logind first. If logind provides session-devices, we use them. If not, we fall back to the old weston-launch facility.
2013-10-21 22:28:09 +00:00
}
WL_EXPORT void
weston_logind_destroy(struct weston_logind *wl)
{
if (wl->pending_active) {
dbus_pending_call_cancel(wl->pending_active);
dbus_pending_call_unref(wl->pending_active);
}
weston_logind_destroy_vt(wl);
weston_logind_release_control(wl);
weston_logind_destroy_dbus(wl);
weston_dbus_close(wl->dbus, wl->dbus_ctx);
free(wl->sid);
free(wl->seat);
free(wl);
}
Reference in a new issue Copy permalink