logind: handle closing sessions over daemon restarts

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

diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index 10a43a4a30a344eb4349d226f11f863a881671bf..a02a537f7ca00666a2316ec357408d84d2323c32 100644 (file)
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -61,7 +61,7 @@ Session* session_new(Manager *m, const char *id) {
                 return NULL;
         }
 
-        s->devices = hashmap_new(devt_hash_func, devt_compare_func);
+        s->devices = hashmap_new(&devt_hash_ops);
         if (!s->devices) {
                 free(s->state_file);
                 free(s);
@@ -292,7 +292,7 @@ int session_save(Session *s) {
 
 finish:
         if (r < 0)
-                log_error("Failed to save session data %s: %s", s->state_file, strerror(-r));
+                log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
 
         return r;
 }
@@ -301,6 +301,7 @@ int session_load(Session *s) {
         _cleanup_free_ char *remote = NULL,
                 *seat = NULL,
                 *vtnr = NULL,
+                *state = NULL,
                 *pos = NULL,
                 *leader = NULL,
                 *type = NULL,
@@ -327,6 +328,7 @@ int session_load(Session *s) {
                            "SERVICE",        &s->service,
                            "DESKTOP",        &s->desktop,
                            "VTNR",           &vtnr,
+                           "STATE",          &state,
                            "POS",            &pos,
                            "LEADER",         &leader,
                            "TYPE",           &type,
@@ -337,10 +339,8 @@ int session_load(Session *s) {
                            "CONTROLLER",     &controller,
                            NULL);
 
-        if (r < 0) {
-                log_error("Failed to read %s: %s", s->state_file, strerror(-r));
-                return r;
-        }
+        if (r < 0)
+                return log_error_errno(r, "Failed to read %s: %m", s->state_file);
 
         if (!s->user) {
                 uid_t u;
@@ -357,7 +357,7 @@ int session_load(Session *s) {
                         return r;
                 }
 
-                user = hashmap_get(s->manager->users, ULONG_TO_PTR((unsigned long) u));
+                user = hashmap_get(s->manager->users, UID_TO_PTR(u));
                 if (!user) {
                         log_error("User of session %s not known.", s->id);
                         return -ENOENT;
@@ -417,13 +417,18 @@ int session_load(Session *s) {
                         s->class = c;
         }
 
+        if (state && streq(state, "closing"))
+                s->stopping = true;
+
         if (s->fifo_path) {
                 int fd;
 
                 /* If we open an unopened pipe for reading we will not
                    get an EOF. to trigger an EOF we hence open it for
-                   reading, but close it right-away which then will
-                   trigger the EOF. */
+                   writing, but close it right away which then will
+                   trigger the EOF. This will happen immediately if no
+                   other process has the FIFO open for writing, i. e.
+                   when the session died before logind (re)started. */
 
                 fd = session_create_fifo(s);
                 safe_close(fd);
@@ -549,11 +554,11 @@ int session_start(Session *s) {
                 return r;
 
         log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
-                   MESSAGE_ID(SD_MESSAGE_SESSION_START),
+                   LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START),
                    "SESSION_ID=%s", s->id,
                    "USER_ID=%s", s->user->name,
                    "LEADER="PID_FMT, s->leader,
-                   "MESSAGE=New session %s of user %s.", s->id, s->user->name,
+                   LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name),
                    NULL);
 
         if (!dual_timestamp_is_set(&s->timestamp))
@@ -652,11 +657,11 @@ int session_finalize(Session *s) {
 
         if (s->started)
                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
-                           MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
+                           LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
                            "SESSION_ID=%s", s->id,
                            "USER_ID=%s", s->user->name,
                            "LEADER="PID_FMT, s->leader,
-                           "MESSAGE=Removed session %s.", s->id,
+                           LOG_MESSAGE("Removed session %s.", s->id),
                            NULL);
 
         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
@@ -969,10 +974,8 @@ static int session_open_vt(Session *s) {
 
         sprintf(path, "/dev/tty%u", s->vtnr);
         s->vtfd = open(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
-        if (s->vtfd < 0) {
-                log_error("cannot open VT %s of session %s: %m", path, s->id);
-                return -errno;
-        }
+        if (s->vtfd < 0)
+                return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id);
 
         return s->vtfd;
 }
@@ -991,21 +994,21 @@ int session_prepare_vt(Session *s) {
         r = fchown(vt, s->user->uid, -1);
         if (r < 0) {
                 r = -errno;
-                log_error("Cannot change owner of /dev/tty%u: %m", s->vtnr);
+                log_error_errno(errno, "Cannot change owner of /dev/tty%u: %m", s->vtnr);
                 goto error;
         }
 
         r = ioctl(vt, KDSKBMODE, K_OFF);
         if (r < 0) {
                 r = -errno;
-                log_error("Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
+                log_error_errno(errno, "Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
                 goto error;
         }
 
         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
         if (r < 0) {
                 r = -errno;
-                log_error("Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr);
+                log_error_errno(errno, "Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr);
                 goto error;
         }
 
@@ -1018,7 +1021,7 @@ int session_prepare_vt(Session *s) {
         r = ioctl(vt, VT_SETMODE, &mode);
         if (r < 0) {
                 r = -errno;
-                log_error("Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr);
+                log_error_errno(errno, "Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr);
                 goto error;
         }
 
@@ -1053,6 +1056,31 @@ void session_restore_vt(Session *s) {
         s->vtfd = safe_close(s->vtfd);
 }
 
+void session_leave_vt(Session *s) {
+        int r;
+
+        assert(s);
+
+        /* This is called whenever we get a VT-switch signal from the kernel.
+         * We acknowledge all of them unconditionally. Note that session are
+         * free to overwrite those handlers and we only register them for
+         * sessions with controllers. Legacy sessions are not affected.
+         * However, if we switch from a non-legacy to a legacy session, we must
+         * make sure to pause all device before acknowledging the switch. We
+         * process the real switch only after we are notified via sysfs, so the
+         * legacy session might have already started using the devices. If we
+         * don't pause the devices before the switch, we might confuse the
+         * session we switch to. */
+
+        if (s->vtfd < 0)
+                return;
+
+        session_device_pause_all(s);
+        r = ioctl(s->vtfd, VT_RELDISP, 1);
+        if (r < 0)
+                log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
+}
+
 bool session_is_controller(Session *s, const char *sender) {
         assert(s);