From 7ed3a638b2e4ffb5e76a0cf1a008e1c7233edb75 Mon Sep 17 00:00:00 2001

From: David Herrmann <dh.herrmann@gmail.com>

Date: Tue, 26 Aug 2014 15:03:41 +0200

Subject: [PATCH] terminal: add system view interface

We're going to need multiple binaries that provide session-services via

logind device management. To avoid re-writing the seat/session/device

scan/monitor interface for each of them, this commit adds a generic helper

to libsystemd-terminal:

The sysview interface scans and tracks seats, sessions and devices on a

system. It basically mirrors the state of logind on the application side.

Now, each session-service can listen for matching sessions and

attach to them. On each session, managed device access is provided. This

way, it is pretty simple to write session-services that attach to multiple

sessions (even split across seats).

---

 Makefile.am                                |    4 +

 src/libsystemd-terminal/sysview-internal.h |  140 +++

 src/libsystemd-terminal/sysview.c          | 1471 ++++++++++++++++++++++++++++

 src/libsystemd-terminal/sysview.h          |  151 +++

 4 files changed, 1766 insertions(+)

 create mode 100644 src/libsystemd-terminal/sysview-internal.h

 create mode 100644 src/libsystemd-terminal/sysview.c

 create mode 100644 src/libsystemd-terminal/sysview.h

diff --git a/Makefile.am b/Makefile.am

index 70faed4acb..3a263f8c17 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -2971,6 +2971,9 @@ libsystemd_terminal_la_CFLAGS = \

 	$(AM_CFLAGS)

 libsystemd_terminal_la_SOURCES = \

+	src/libsystemd-terminal/sysview.h \

+	src/libsystemd-terminal/sysview-internal.h \

+	src/libsystemd-terminal/sysview.c \

 	src/libsystemd-terminal/term-internal.h \

 	src/libsystemd-terminal/term-charset.c \

 	src/libsystemd-terminal/term-page.c \

@@ -2981,6 +2984,7 @@ libsystemd_terminal_la_SOURCES = \

 	src/libsystemd-terminal/unifont.c

 libsystemd_terminal_la_LIBADD = \

+	libudev-internal.la \

 	libsystemd-internal.la \

 	libsystemd-shared.la

diff --git a/src/libsystemd-terminal/sysview-internal.h b/src/libsystemd-terminal/sysview-internal.h

new file mode 100644

index 0000000000..5aee9f67d8

--- /dev/null

+++ b/src/libsystemd-terminal/sysview-internal.h

@@ -0,0 +1,140 @@

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

+

+/***

+  This file is part of systemd.

+

+  Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>

+

+  systemd is free software; you can redistribute it and/or modify it

+  under the terms of the GNU Lesser General Public License as published by

+  the Free Software Foundation; either version 2.1 of the License, or

+  (at your option) any later version.

+

+  systemd 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

+  Lesser General Public License for more details.

+

+  You should have received a copy of the GNU Lesser General Public License

+  along with systemd; If not, see <http://www.gnu.org/licenses/>.

+***/

+

+#pragma once

+

+#include <inttypes.h>

+#include <libudev.h>

+#include <stdbool.h>

+#include <stdlib.h>

+#include <systemd/sd-bus.h>

+#include <systemd/sd-event.h>

+#include "hashmap.h"

+#include "list.h"

+#include "macro.h"

+#include "sysview.h"

+#include "util.h"

+

+/*

+ * Devices

+ */

+

+struct sysview_device {

+        sysview_seat *seat;

+        const char *name;

+        unsigned int type;

+

+        union {

+                struct {

+                        struct udev_device *ud;

+                } evdev, drm;

+        };

+};

+

+sysview_device *sysview_find_device(sysview_context *c, const char *name);

+

+int sysview_device_new(sysview_device **out, sysview_seat *seat, const char *name);

+sysview_device *sysview_device_free(sysview_device *device);

+

+DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_device*, sysview_device_free);

+

+/*

+ * Sessions

+ */

+

+struct sysview_session {

+        sysview_seat *seat;

+        char *name;

+        char *path;

+

+        sd_bus_slot *slot_take_control;

+

+        bool custom : 1;

+        bool public : 1;

+        bool wants_control : 1;

+        bool has_control : 1;

+};

+

+sysview_session *sysview_find_session(sysview_context *c, const char *name);

+

+int sysview_session_new(sysview_session **out, sysview_seat *seat, const char *name);

+sysview_session *sysview_session_free(sysview_session *session);

+

+DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_session*, sysview_session_free);

+

+/*

+ * Seats

+ */

+

+struct sysview_seat {

+        sysview_context *context;

+        char *name;

+

+        Hashmap *session_map;

+        Hashmap *device_map;

+

+        bool scanned : 1;

+        bool public : 1;

+};

+

+sysview_seat *sysview_find_seat(sysview_context *c, const char *name);

+

+int sysview_seat_new(sysview_seat **out, sysview_context *c, const char *name);

+sysview_seat *sysview_seat_free(sysview_seat *seat);

+

+DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_seat*, sysview_seat_free);

+

+/*

+ * Contexts

+ */

+

+struct sysview_context {

+        sd_event *event;

+        sd_bus *sysbus;

+        struct udev *ud;

+        uint64_t custom_sid;

+

+        Hashmap *seat_map;

+        Hashmap *session_map;

+        Hashmap *device_map;

+

+        sd_event_source *scan_src;

+        sysview_event_fn event_fn;

+        void *userdata;

+

+        /* udev scanner */

+        struct udev_monitor *ud_monitor;

+        sd_event_source *ud_monitor_src;

+

+        /* logind scanner */

+        sd_bus_slot *ld_slot_manager_signal;

+        sd_bus_slot *ld_slot_list_seats;

+        sd_bus_slot *ld_slot_list_sessions;

+

+        bool scan_logind : 1;

+        bool scan_evdev : 1;

+        bool scan_drm : 1;

+        bool running : 1;

+        bool scanned : 1;

+        bool rescan : 1;

+};

+

+int sysview_context_rescan(sysview_context *c);

diff --git a/src/libsystemd-terminal/sysview.c b/src/libsystemd-terminal/sysview.c

new file mode 100644

index 0000000000..d885cb4d4a

--- /dev/null

+++ b/src/libsystemd-terminal/sysview.c

@@ -0,0 +1,1471 @@

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

+

+/***

+  This file is part of systemd.

+

+  Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>

+

+  systemd is free software; you can redistribute it and/or modify it

+  under the terms of the GNU Lesser General Public License as published by

+  the Free Software Foundation; either version 2.1 of the License, or

+  (at your option) any later version.

+

+  systemd 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

+  Lesser General Public License for more details.

+

+  You should have received a copy of the GNU Lesser General Public License

+  along with systemd; If not, see <http://www.gnu.org/licenses/>.

+***/

+

+#include <inttypes.h>

+#include <libudev.h>

+#include <stdbool.h>

+#include <stdlib.h>

+#include <systemd/sd-bus.h>

+#include <systemd/sd-event.h>

+#include <systemd/sd-login.h>

+#include "bus-util.h"

+#include "event-util.h"

+#include "macro.h"

+#include "set.h"

+#include "sysview.h"

+#include "sysview-internal.h"

+#include "udev-util.h"

+#include "util.h"

+

+static int context_raise_session_control(sysview_context *c, sysview_session *session, int error);

+

+/*

+ * Devices

+ */

+

+sysview_device *sysview_find_device(sysview_context *c, const char *name) {

+        assert_return(c, NULL);

+        assert_return(name, NULL);

+

+        return hashmap_get(c->device_map, name);

+}

+

+int sysview_device_new(sysview_device **out, sysview_seat *seat, const char *name) {

+        _cleanup_(sysview_device_freep) sysview_device *device = NULL;

+        int r;

+

+        assert_return(seat, -EINVAL);

+        assert_return(name, -EINVAL);

+

+        device = new0(sysview_device, 1);

+        if (!device)

+                return -ENOMEM;

+

+        device->seat = seat;

+        device->type = (unsigned)-1;

+

+        device->name = strdup(name);

+        if (!device->name)

+                return -ENOMEM;

+

+        r = hashmap_put(seat->context->device_map, device->name, device);

+        if (r < 0)

+                return r;

+

+        r = hashmap_put(seat->device_map, device->name, device);

+        if (r < 0)

+                return r;

+

+        if (out)

+                *out = device;

+        device = NULL;

+        return 0;

+}

+

+sysview_device *sysview_device_free(sysview_device *device) {

+        if (!device)

+                return NULL;

+

+        if (device->name) {

+                hashmap_remove_value(device->seat->device_map, device->name, device);

+                hashmap_remove_value(device->seat->context->device_map, device->name, device);

+        }

+

+        switch (device->type) {

+        case SYSVIEW_DEVICE_EVDEV:

+                device->evdev.ud = udev_device_unref(device->evdev.ud);

+                break;

+        case SYSVIEW_DEVICE_DRM:

+                device->drm.ud = udev_device_unref(device->drm.ud);

+                break;

+        }

+

+        free(device);

+

+        return NULL;

+}

+

+unsigned int sysview_device_get_type(sysview_device *device) {

+        assert_return(device, (unsigned)-1);

+

+        return device->type;

+}

+

+struct udev_device *sysview_device_get_ud(sysview_device *device) {

+        assert_return(device, NULL);

+

+        switch (device->type) {

+        case SYSVIEW_DEVICE_EVDEV:

+                return device->evdev.ud;

+        case SYSVIEW_DEVICE_DRM:

+                return device->drm.ud;

+        default:

+                assert_return(0, NULL);

+        }

+}

+

+static int device_new_ud(sysview_device **out, sysview_seat *seat, unsigned int type, struct udev_device *ud) {

+        _cleanup_(sysview_device_freep) sysview_device *device = NULL;

+        int r;

+

+        assert_return(seat, -EINVAL);

+        assert_return(ud, -EINVAL);

+

+        r = sysview_device_new(&device, seat, udev_device_get_syspath(ud));

+        if (r < 0)

+                return r;

+

+        device->type = type;

+

+        switch (type) {

+        case SYSVIEW_DEVICE_EVDEV:

+                device->evdev.ud = udev_device_ref(ud);

+                break;

+        case SYSVIEW_DEVICE_DRM:

+                device->drm.ud = udev_device_ref(ud);

+                break;

+        default:

+                assert_not_reached("sysview: invalid udev-device type");

+        }

+

+        if (out)

+                *out = device;

+        device = NULL;

+        return 0;

+}

+

+/*

+ * Sessions

+ */

+

+sysview_session *sysview_find_session(sysview_context *c, const char *name) {

+        assert_return(c, NULL);

+        assert_return(name, NULL);

+

+        return hashmap_get(c->session_map, name);

+}

+

+int sysview_session_new(sysview_session **out, sysview_seat *seat, const char *name) {

+        _cleanup_(sysview_session_freep) sysview_session *session = NULL;

+        int r;

+

+        assert_return(seat, -EINVAL);

+

+        session = new0(sysview_session, 1);

+        if (!session)

+                return -ENOMEM;

+

+        session->seat = seat;

+

+        if (name) {

+                /*

+                 * If a name is given, we require it to be a logind session

+                 * name. The session will be put in managed mode and we use

+                 * logind to request controller access.

+                 */

+

+                session->name = strdup(name);

+                if (!session->name)

+                        return -ENOMEM;

+

+                r = sd_bus_path_encode("/org/freedesktop/login1/session",

+                                       session->name, &session->path);

+                if (r < 0)

+                        return r;

+

+                session->custom = false;;

+        } else {

+                /*

+                 * No session name was given. We assume this is an unmanaged

+                 * session controlled by the application. We don't use logind

+                 * at all and leave session management to the application. The

+                 * name of the session-object is set to a unique random string

+                 * that does not clash with the logind namespace.

+                 */

+

+                r = asprintf(&session->name, "@custom%" PRIu64,

+                             ++seat->context->custom_sid);

+                if (r < 0)

+                        return -ENOMEM;

+

+                session->custom = true;

+        }

+

+        r = hashmap_put(seat->context->session_map, session->name, session);

+        if (r < 0)

+                return r;

+

+        r = hashmap_put(seat->session_map, session->name, session);

+        if (r < 0)

+                return r;

+

+        if (out)

+                *out = session;

+        session = NULL;

+        return 0;

+}

+

+sysview_session *sysview_session_free(sysview_session *session) {

+        if (!session)

+                return NULL;

+

+        assert(!session->public);

+        assert(!session->wants_control);

+

+        if (session->name) {

+                hashmap_remove_value(session->seat->session_map, session->name, session);

+                hashmap_remove_value(session->seat->context->session_map, session->name, session);

+        }

+

+        free(session->path);

+        free(session->name);

+        free(session);

+

+        return NULL;

+}

+

+const char *sysview_session_get_name(sysview_session *session) {

+        assert_return(session, NULL);

+

+        return session->name;

+}

+

+static int session_take_control_fn(sd_bus *bus,

+                                   sd_bus_message *reply,

+                                   void *userdata,

+                                   sd_bus_error *ret_error) {

+        sysview_session *session = userdata;

+        int error;

+

+        session->slot_take_control = sd_bus_slot_unref(session->slot_take_control);

+

+        if (sd_bus_message_is_method_error(reply, NULL)) {

+                const sd_bus_error *e = sd_bus_message_get_error(reply);

+

+                log_debug("sysview: %s: TakeControl failed: %s: %s",

+                          session->name, e->name, e->message);

+                error = sd_bus_error_get_errno(e);

+        } else {

+                session->has_control = true;

+                error = 0;

+        }

+

+        return context_raise_session_control(session->seat->context, session, error);

+}

+

+int sysview_session_take_control(sysview_session *session) {

+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;

+        int r;

+

+        assert_return(session, -EINVAL);

+        assert_return(!session->custom, -EINVAL);

+

+        if (session->wants_control)

+                return 0;

+

+        r = sd_bus_message_new_method_call(session->seat->context->sysbus,

+                                           &m,

+                                           "org.freedesktop.login1",

+                                           session->path,

+                                           "org.freedesktop.login1.Session",

+                                           "TakeControl");

+        if (r < 0)

+                return r;

+

+        r = sd_bus_message_append(m, "b", 0);

+        if (r < 0)

+                return r;

+

+        r = sd_bus_call_async(session->seat->context->sysbus,

+                              &session->slot_take_control,

+                              m,

+                              session_take_control_fn,

+                              session,

+                              0);

+        if (r < 0)

+                return r;

+

+        session->wants_control = true;

+        return 0;

+}

+

+void sysview_session_release_control(sysview_session *session) {

+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;

+        int r;

+

+        assert(session);

+        assert(!session->custom);

+

+        if (!session->wants_control)

+                return;

+

+        session->wants_control = false;

+

+        if (!session->has_control && !session->slot_take_control)

+                return;

+

+        session->has_control = false;

+        session->slot_take_control = sd_bus_slot_unref(session->slot_take_control);

+

+        r = sd_bus_message_new_method_call(session->seat->context->sysbus,

+                                           &m,

+                                           "org.freedesktop.login1",

+                                           session->path,

+                                           "org.freedesktop.login1.Session",

+                                           "ReleaseControl");

+        if (r >= 0)

+                r = sd_bus_send(session->seat->context->sysbus, m, NULL);

+

+        if (r < 0 && r != -ENOTCONN)

+                log_debug("sysview: %s: cannot send ReleaseControl: %s",

+                          session->name, strerror(-r));

+}

+

+/*

+ * Seats

+ */

+

+sysview_seat *sysview_find_seat(sysview_context *c, const char *name) {

+        assert_return(c, NULL);

+        assert_return(name, NULL);

+

+        return hashmap_get(c->seat_map, name);

+}

+

+int sysview_seat_new(sysview_seat **out, sysview_context *c, const char *name) {

+        _cleanup_(sysview_seat_freep) sysview_seat *seat = NULL;

+        int r;

+

+        assert_return(c, -EINVAL);

+        assert_return(name, -EINVAL);

+

+        seat = new0(sysview_seat, 1);

+        if (!seat)

+                return -ENOMEM;

+

+        seat->context = c;

+

+        seat->name = strdup(name);

+        if (!seat->name)

+                return -ENOMEM;

+

+        seat->session_map = hashmap_new(string_hash_func, string_compare_func);

+        if (!seat->session_map)

+                return -ENOMEM;

+

+        seat->device_map = hashmap_new(string_hash_func, string_compare_func);

+        if (!seat->device_map)

+                return -ENOMEM;

+

+        r = hashmap_put(c->seat_map, seat->name, seat);

+        if (r < 0)

+                return r;

+

+        if (out)

+                *out = seat;

+        seat = NULL;

+        return 0;

+}

+

+sysview_seat *sysview_seat_free(sysview_seat *seat) {

+        if (!seat)

+                return NULL;

+

+        assert(!seat->public);

+        assert(hashmap_size(seat->device_map) == 0);

+        assert(hashmap_size(seat->session_map) == 0);

+

+        if (seat->name)

+                hashmap_remove_value(seat->context->seat_map, seat->name, seat);

+

+        hashmap_free(seat->device_map);

+        hashmap_free(seat->session_map);

+        free(seat->name);

+        free(seat);

+

+        return NULL;

+}

+

+const char *sysview_seat_get_name(sysview_seat *seat) {

+        assert_return(seat, NULL);

+

+        return seat->name;

+}

+

+/*

+ * Contexts

+ */

+

+static int context_raise(sysview_context *c, sysview_event *event, int def) {

+        return c->running ? c->event_fn(c, c->userdata, event) : def;

+}

+

+static int context_raise_seat_add(sysview_context *c, sysview_seat *seat) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SEAT_ADD,

+                .seat_add = {

+                        .seat = seat,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_seat_remove(sysview_context *c, sysview_seat *seat) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SEAT_REMOVE,

+                .seat_remove = {

+                        .seat = seat,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_session_filter(sysview_context *c,

+                                        const char *id,

+                                        const char *seatid,

+                                        const char *username,

+                                        unsigned int uid) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_FILTER,

+                .session_filter = {

+                        .id = id,

+                        .seatid = seatid,

+                        .username = username,

+                        .uid = uid,

+                }

+        };

+

+        return context_raise(c, &event, 1);

+}

+

+static int context_raise_session_add(sysview_context *c, sysview_session *session) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_ADD,

+                .session_add = {

+                        .session = session,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_session_remove(sysview_context *c, sysview_session *session) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_REMOVE,

+                .session_remove = {

+                        .session = session,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_session_control(sysview_context *c, sysview_session *session, int error) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_CONTROL,

+                .session_control = {

+                        .session = session,

+                        .error = error,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_session_attach(sysview_context *c, sysview_session *session, sysview_device *device) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_ATTACH,

+                .session_attach = {

+                        .session = session,

+                        .device = device,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_raise_session_detach(sysview_context *c, sysview_session *session, sysview_device *device) {

+        sysview_event event = {

+                .type = SYSVIEW_EVENT_SESSION_DETACH,

+                .session_detach = {

+                        .session = session,

+                        .device = device,

+                }

+        };

+

+        return context_raise(c, &event, 0);

+}

+

+static int context_add_device(sysview_context *c, sysview_device *device) {

+        sysview_session *session;

+        int r, error = 0;

+        Iterator i;

+

+        assert(c);

+        assert(device);

+

+        log_debug("sysview: add device '%s' on seat '%s'",

+                  device->name, device->seat->name);

+

+        HASHMAP_FOREACH(session, device->seat->session_map, i) {

+                if (!session->public)

+                        continue;

+

+                r = context_raise_session_attach(c, session, device);

+                if (r != 0)

+                        error = r;

+        }

+

+        if (error < 0)

+                log_debug("sysview: error while adding device '%s': %s",

+                          device->name, strerror(-r));

+        return error;

+}

+

+static int context_remove_device(sysview_context *c, sysview_device *device) {

+        sysview_session *session;

+        int r, error = 0;

+        Iterator i;

+

+        assert(c);

+        assert(device);

+

+        log_debug("sysview: remove device '%s'", device->name);

+

+        HASHMAP_FOREACH(session, device->seat->session_map, i) {

+                if (!session->public)

+                        continue;

+

+                r = context_raise_session_detach(c, session, device);

+                if (r != 0)

+                        error = r;

+        }

+

+        if (error < 0)

+                log_debug("sysview: error while removing device '%s': %s",

+                          device->name, strerror(-r));

+        sysview_device_free(device);

+        return error;

+}

+

+static int context_add_session(sysview_context *c, sysview_seat *seat, const char *id) {

+        sysview_session *session;

+        sysview_device *device;

+        int r, error = 0;

+        Iterator i;

+

+        assert(c);

+        assert(seat);

+        assert(id);

+

+        session = sysview_find_session(c, id);

+        if (session)

+                return 0;

+

+        log_debug("sysview: add session '%s' on seat '%s'", id, seat->name);

+

+        r = sysview_session_new(&session, seat, id);

+        if (r < 0)

+                goto error;

+

+        if (!seat->scanned) {

+                r = sysview_context_rescan(c);

+                if (r < 0)

+                        goto error;

+        }

+

+        if (seat->public) {

+                session->public = true;

+                r = context_raise_session_add(c, session);

+                if (r != 0) {

+                        session->public = false;

+                        goto error;

+                }

+

+                HASHMAP_FOREACH(device, seat->device_map, i) {

+                        r = context_raise_session_attach(c, session, device);

+                        if (r != 0)

+                                error = r;

+                }

+

+                r = error;

+                if (r != 0)

+                        goto error;

+        }

+

+        return 0;

+

+error:

+        if (r < 0)

+                log_debug("sysview: error while adding session '%s': %s",

+                          id, strerror(-r));

+        return r;

+}

+

+static int context_remove_session(sysview_context *c, sysview_session *session) {

+        sysview_device *device;

+        int r, error = 0;

+        Iterator i;

+

+        assert(c);

+        assert(session);

+

+        log_debug("sysview: remove session '%s'", session->name);

+

+        if (session->public) {

+                HASHMAP_FOREACH(device, session->seat->device_map, i) {

+                        r = context_raise_session_detach(c, session, device);

+                        if (r != 0)

+                                error = r;

+                }

+

+                session->public = false;

+                r = context_raise_session_remove(c, session);

+                if (r != 0)

+                        error = r;

+        }

+

+        if (!session->custom)

+                sysview_session_release_control(session);

+

+        if (error < 0)

+                log_debug("sysview: error while removing session '%s': %s",

+                          session->name, strerror(-error));

+        sysview_session_free(session);

+        return error;

+}

+

+static int context_add_seat(sysview_context *c, const char *id) {

+        sysview_seat *seat;

+        int r;

+

+        assert(c);

+        assert(id);

+

+        seat = sysview_find_seat(c, id);

+        if (seat)

+                return 0;

+

+        log_debug("sysview: add seat '%s'", id);

+

+        r = sysview_seat_new(&seat, c, id);

+        if (r < 0)

+                goto error;

+

+        seat->public = true;

+        r = context_raise_seat_add(c, seat);

+        if (r != 0) {

+                seat->public = false;