#include <sys/ioctl.h>
#include <unistd.h>
-#include "sd-id128.h"
#include "sd-messages.h"
-#include "strv.h"
#include "util.h"
#include "mkdir.h"
#include "path-util.h"
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);
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;
}
_cleanup_free_ char *remote = NULL,
*seat = NULL,
*vtnr = NULL,
+ *state = NULL,
*pos = NULL,
*leader = NULL,
*type = NULL,
"SERVICE", &s->service,
"DESKTOP", &s->desktop,
"VTNR", &vtnr,
+ "STATE", &state,
"POS", &pos,
"LEADER", &leader,
"TYPE", &type,
"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;
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;
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);
assert(s->user);
if (!s->seat)
- return -ENOTSUP;
+ return -EOPNOTSUPP;
if (s->seat->active == s)
return 0;
/* on seats with VTs, we let VTs manage session-switching */
if (seat_has_vts(s->seat)) {
if (!s->vtnr)
- return -ENOTSUP;
+ return -EOPNOTSUPP;
return chvt(s->vtnr);
}
if (!scope)
return log_oom();
- r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-logind.service", "systemd-user-sessions.service", &error, &job);
+ r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "logind.service", "systemd-user-sessions.service", &error, &job);
if (r < 0) {
log_error("Failed to start session scope %s: %s %s",
scope, bus_error_message(&error, r), error.name);
return r;
/* Create cgroup */
+#if 0
r = session_start_scope(s);
if (r < 0)
return r;
+#endif
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))
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);
return 0;
}
-void session_release(Session *s) {
+int session_release(Session *s) {
assert(s);
if (!s->started || s->stopping)
- return;
+ return 0;
+
+ if (s->timer_event_source)
+ return 0;
- if (!s->timer_event_source)
- sd_event_add_time(s->manager->event,
- &s->timer_event_source,
- CLOCK_MONOTONIC,
- now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
- release_timeout_callback, s);
+ return sd_event_add_time(s->manager->event,
+ &s->timer_event_source,
+ CLOCK_MONOTONIC,
+ now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
+ release_timeout_callback, s);
}
bool session_is_active(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;
}
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;
}
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;
}
if (vt < 0)
return;
- ioctl(vt, KDSETMODE, KD_TEXT);
+ (void) ioctl(vt, KDSETMODE, KD_TEXT);
if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
kb = K_UNICODE;
- ioctl(vt, KDSKBMODE, kb);
+ (void) ioctl(vt, KDSKBMODE, kb);
mode.mode = VT_AUTO;
- ioctl(vt, VT_SETMODE, &mode);
+ (void) ioctl(vt, VT_SETMODE, &mode);
fchown(vt, 0, -1);
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);
return streq_ptr(s->controller, sender);
}
-static void session_swap_controller(Session *s, char *name) {
+static void session_release_controller(Session *s, bool notify) {
+ _cleanup_free_ char *name = NULL;
SessionDevice *sd;
- char *c;
- if (s->controller) {
- c = s->controller;
- s->controller = NULL;
- manager_drop_busname(s->manager, c);
- free(c);
+ if (!s->controller)
+ return;
- /* Drop all devices as they're now unused. Do that after the
- * controller is released to avoid sending out useles
- * dbus signals. */
- while ((sd = hashmap_first(s->devices)))
- session_device_free(sd);
+ name = s->controller;
- if (!name)
- session_restore_vt(s);
- }
+ /* By resetting the controller before releasing the devices, we won't
+ * send notification signals. This avoids sending useless notifications
+ * if the controller is released on disconnects. */
+ if (!notify)
+ s->controller = NULL;
- s->controller = name;
- session_save(s);
+ while ((sd = hashmap_first(s->devices)))
+ session_device_free(sd);
+
+ s->controller = NULL;
+ manager_drop_busname(s->manager, name);
}
int session_set_controller(Session *s, const char *sender, bool force) {
- char *t;
+ _cleanup_free_ char *name = NULL;
int r;
assert(s);
if (s->controller && !force)
return -EBUSY;
- t = strdup(sender);
- if (!t)
+ name = strdup(sender);
+ if (!name)
return -ENOMEM;
- r = manager_watch_busname(s->manager, sender);
- if (r) {
- free(t);
+ r = manager_watch_busname(s->manager, name);
+ if (r)
return r;
- }
/* When setting a session controller, we forcibly mute the VT and set
* it into graphics-mode. Applications can override that by changing
* or reset the VT in case it crashed/exited, too. */
r = session_prepare_vt(s);
if (r < 0) {
- free(t);
+ manager_drop_busname(s->manager, name);
return r;
}
- session_swap_controller(s, t);
+ session_release_controller(s, true);
+ s->controller = name;
+ name = NULL;
+ session_save(s);
return 0;
}
if (!s->controller)
return;
- session_swap_controller(s, NULL);
+ session_release_controller(s, false);
+ session_save(s);
+ session_restore_vt(s);
}
static const char* const session_state_table[_SESSION_STATE_MAX] = {