HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/login/logind-session.c
Git blob: f5fb47920749c2e3aa64669c4a0516626f898f16
Lines 1001–1801 of 1,801
int session_stop(Session *s, bool force) {
int r;
assert(s);
/* This is called whenever we begin with tearing down a session record. It's called in four cases: explicit API
* request via the bus (either directly for the session object or for the seat or user object this session
* belongs to; 'force' is true), or due to automatic GC (i.e. scope vanished; 'force' is false), or because the
* session FIFO saw an EOF ('force' is false), or because the release timer hit ('force' is false). */
if (!s->user)
return -ESTALE;
if (!s->started)
return 0;
if (s->stopping)
return 0;
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
if (s->seat)
seat_evict_position(s->seat, s);
/* Kill cgroup */
r = session_stop_scope(s, force);
s->stopping = true;
user_elect_display(s->user);
(void) session_save(s);
(void) user_save(s->user);
(void) trigger_xaccess(s->extra_device_access);
return r;
}
int session_finalize(Session *s) {
SessionDevice *sd;
assert(s);
if (!s->user)
return -ESTALE;
if (s->started)
log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP_STR),
LOG_ITEM("SESSION_ID=%s", s->id),
LOG_ITEM("USER_ID=%s", s->user->user_record->user_name),
LOG_ITEM("LEADER="PID_FMT, s->leader.pid),
LOG_MESSAGE("Removed session %s.", s->id));
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
if (s->seat)
seat_evict_position(s->seat, s);
/* Kill session devices */
while ((sd = hashmap_first(s->devices)))
session_device_free(sd);
(void) unlink(s->state_file);
session_add_to_gc_queue(s);
user_add_to_gc_queue(s->user);
if (s->started) {
session_send_signal(s, false);
s->started = false;
}
if (s->seat) {
if (s->seat->active == s)
seat_set_active(s->seat, NULL);
seat_save(s->seat);
}
session_reset_leader(s, /* keep_fdstore= */ false);
(void) user_save(s->user);
(void) user_send_changed(s->user, "Display");
return 0;
}
static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
Session *s = ASSERT_PTR(userdata);
assert(es);
session_stop(s, /* force= */ false);
return 0;
}
int session_release(Session *s) {
assert(s);
if (!s->started || s->stopping)
return 0;
if (s->timer_event_source)
return 0;
return sd_event_add_time_relative(
s->manager->event,
&s->timer_event_source,
CLOCK_MONOTONIC,
RELEASE_USEC, 0,
release_timeout_callback, s);
}
bool session_is_active(Session *s) {
assert(s);
if (!s->seat)
return true;
return s->seat->active == s;
}
static int get_tty_atime(const char *tty, usec_t *atime) {
_cleanup_free_ char *p = NULL;
struct stat st;
assert(tty);
assert(atime);
if (!path_is_absolute(tty)) {
p = path_join("/dev", tty);
if (!p)
return -ENOMEM;
tty = p;
} else if (!path_startswith(tty, "/dev/"))
return -ENOENT;
if (lstat(tty, &st) < 0)
return -errno;
*atime = timespec_load(&st.st_atim);
return 0;
}
static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
_cleanup_free_ char *p = NULL;
int r;
assert(pid > 0);
assert(atime);
r = get_ctty(pid, NULL, &p);
if (r < 0)
return r;
return get_tty_atime(p, atime);
}
bool session_get_idle_hint(Session *s, dual_timestamp *ret_timestamp) {
usec_t atime = 0, dtime = 0;
int r;
assert(s);
if (!SESSION_CLASS_CAN_IDLE(s->class)) {
if (ret_timestamp)
*ret_timestamp = DUAL_TIMESTAMP_NULL;
return false;
}
/* Graphical sessions have an explicit idle hint */
if (SESSION_TYPE_IS_GRAPHICAL(s->type)) {
if (ret_timestamp)
*ret_timestamp = s->idle_hint_timestamp;
return s->idle_hint;
}
if (s->type == SESSION_TTY) {
/* For sessions with an explicitly configured tty, let's check its atime */
if (s->tty) {
r = get_tty_atime(s->tty, &atime);
if (r >= 0)
goto found_atime;
}
/* For sessions with a leader but no explicitly configured tty, let's check the controlling tty of
* the leader */
if (pidref_is_set(&s->leader)) {
r = get_process_ctty_atime(s->leader.pid, &atime);
if (r >= 0)
goto found_atime;
}
}
if (ret_timestamp)
*ret_timestamp = DUAL_TIMESTAMP_NULL;
return false;
found_atime:
if (ret_timestamp)
dual_timestamp_from_realtime(ret_timestamp, atime);
if (s->manager->idle_action_usec > 0 && s->manager->stop_idle_session_usec != USEC_INFINITY)
dtime = MIN(s->manager->idle_action_usec, s->manager->stop_idle_session_usec);
else if (s->manager->idle_action_usec > 0)
dtime = s->manager->idle_action_usec;
else if (s->manager->stop_idle_session_usec != USEC_INFINITY)
dtime = s->manager->stop_idle_session_usec;
else
return false;
return usec_add(atime, dtime) <= now(CLOCK_REALTIME);
}
int session_set_idle_hint(Session *s, bool b) {
assert(s);
if (!SESSION_CLASS_CAN_IDLE(s->class)) /* Only some session classes know the idle concept at all */
return -ENOTTY;
if (!SESSION_TYPE_IS_GRAPHICAL(s->type)) /* And only graphical session types can set the field explicitly */
return -ENOTTY;
if (s->idle_hint == b)
return 0;
s->idle_hint = b;
dual_timestamp_now(&s->idle_hint_timestamp);
(void) session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic");
if (s->seat)
(void) seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic");
(void) user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic");
(void) manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic");
return 1;
}
int session_get_locked_hint(Session *s) {
assert(s);
return s->locked_hint;
}
int session_set_locked_hint(Session *s, bool b) {
assert(s);
if (!SESSION_CLASS_CAN_LOCK(s->class))
return -ENOTTY;
if (s->locked_hint == b)
return 0;
s->locked_hint = b;
(void) session_save(s);
(void) session_send_changed(s, "LockedHint");
return 1;
}
void session_set_type(Session *s, SessionType t) {
assert(s);
if (s->type == t)
return;
s->type = t;
(void) session_save(s);
(void) session_send_changed(s, "Type");
}
void session_set_class(Session *s, SessionClass c) {
assert(s);
if (s->class == c)
return;
s->class = c;
(void) session_save(s);
(void) session_send_changed(s, "Class");
/* This class change might mean we need the per-user session manager now. Try to start it. */
(void) user_start_service_manager(s->user);
}
int session_set_display(Session *s, const char *display) {
int r;
assert(s);
assert(display);
r = free_and_strdup(&s->display, display);
if (r <= 0) /* 0 means the strings were equal */
return r;
(void) session_save(s);
(void) session_send_changed(s, "Display");
return 1;
}
int session_set_tty(Session *s, const char *tty) {
int r;
assert(s);
assert(tty);
r = free_and_strdup(&s->tty, tty);
if (r <= 0) /* 0 means the strings were equal */
return r;
(void) session_save(s);
(void) session_send_changed(s, "TTY");
return 1;
}
bool session_may_gc(Session *s, bool drop_not_started) {
int r;
assert(s);
if (drop_not_started && !s->started)
return true;
if (!s->user)
return true;
r = pidref_is_alive(&s->leader);
if (r == -ESRCH)
/* Session has no leader. This is probably because the leader vanished before deserializing
* pidfd from FD store. */
return true;
if (r < 0)
log_debug_errno(r, "Unable to determine if leader PID " PID_FMT " is still alive, assuming not: %m", s->leader.pid);
if (r > 0)
return false;
if (s->scope_job) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = manager_job_is_active(s->manager, s->scope_job, &error);
if (r < 0)
log_debug_errno(r, "Failed to determine whether job '%s' is pending, ignoring: %s", s->scope_job, bus_error_message(&error, r));
if (r != 0)
return false;
}
if (s->scope) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = manager_unit_is_active(s->manager, s->scope, &error);
if (r < 0)
log_debug_errno(r, "Failed to determine whether unit '%s' is active, ignoring: %s", s->scope, bus_error_message(&error, r));
if (r != 0)
return false;
}
return true;
}
void session_add_to_gc_queue(Session *s) {
assert(s);
if (s->in_gc_queue)
return;
LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
s->in_gc_queue = true;
}
SessionState session_get_state(Session *s) {
assert(s);
/* always check closing first */
if (s->stopping || s->timer_event_source)
return SESSION_CLOSING;
if (s->scope_job || !pidref_is_set(&s->leader))
return SESSION_OPENING;
if (session_is_active(s))
return SESSION_ACTIVE;
return SESSION_ONLINE;
}
int session_kill(Session *s, KillWhom whom, int signo, sd_bus_error *error) {
assert(s);
switch (whom) {
case KILL_ALL:
if (!SESSION_CLASS_WANTS_SCOPE(s->class))
return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
"Session '%s' has no associated scope", s->id);
if (!s->scope)
return sd_bus_error_set_errnof(error, ESRCH, "Scope for session '%s' not active", s->id);
return manager_kill_unit(s->manager, s->scope, KILL_ALL, signo, error);
case KILL_LEADER:
return pidref_kill(&s->leader, signo);
default:
assert_not_reached();
}
}
static int session_open_vt(Session *s, bool reopen) {
_cleanup_close_ int fd = -EBADF;
char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
assert(s);
if (s->vtnr < 1)
return -ENODEV;
if (!reopen && s->vtfd >= 0)
return s->vtfd;
sprintf(path, "/dev/tty%u", s->vtnr);
fd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
if (fd < 0)
return log_error_errno(fd, "Cannot open VT %s of session %s: %m", path, s->id);
close_and_replace(s->vtfd, fd);
return s->vtfd;
}
static int session_prepare_vt(Session *s) {
int vt, r;
struct vt_mode mode = {};
assert(s);
if (s->vtnr < 1)
return 0;
vt = session_open_vt(s, /* reopen= */ false);
if (vt < 0)
return vt;
r = fchown(vt, s->user->user_record->uid, -1);
if (r < 0) {
r = 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 = 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 = log_error_errno(errno,
"Cannot set KD_GRAPHICS on /dev/tty%u: %m",
s->vtnr);
goto error;
}
/* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
* So we need a dummy handler here which just acknowledges *all* VT
* switch requests. */
mode.mode = VT_PROCESS;
mode.relsig = SIGRTMIN;
mode.acqsig = SIGRTMIN + 1;
r = ioctl(vt, VT_SETMODE, &mode);
if (r < 0) {
r = log_error_errno(errno,
"Cannot set VT_PROCESS on /dev/tty%u: %m",
s->vtnr);
goto error;
}
return 0;
error:
session_restore_vt(s);
return r;
}
static void session_restore_vt(Session *s) {
int r;
assert(s);
if (s->vtfd < 0)
return;
r = vt_restore(s->vtfd);
if (r == -EIO) {
/* It might happen if the controlling process exited before or while we were
* restoring the VT as it would leave the old file-descriptor in a hung-up
* state. In this case let's retry with a fresh handle to the virtual terminal. */
/* We do a little dance to avoid having the terminal be available
* for reuse before we've cleaned it up. */
int fd = session_open_vt(s, /* reopen= */ true);
if (fd >= 0)
r = vt_restore(fd);
}
if (r < 0)
log_warning_errno(r, "Failed to restore VT, ignoring: %m");
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 = vt_release(s->vtfd, /* restore= */ false);
if (r == -EIO) {
/* Handle the same VT hung-up case as in session_restore_vt */
int fd = session_open_vt(s, /* reopen= */ true);
if (fd >= 0)
r = vt_release(fd, /* restore= */ false);
}
if (r < 0)
log_debug_errno(r, "Cannot release VT of session %s: %m", s->id);
}
bool session_is_controller(Session *s, const char *sender) {
return streq_ptr(ASSERT_PTR(s)->controller, sender);
}
static void session_release_controller(Session *s, bool notify) {
_unused_ _cleanup_free_ char *name = NULL;
SessionDevice *sd;
assert(s);
if (!s->controller)
return;
name = s->controller;
/* 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;
while ((sd = hashmap_first(s->devices)))
session_device_free(sd);
s->controller = NULL;
s->track = sd_bus_track_unref(s->track);
}
static int on_bus_track(sd_bus_track *track, void *userdata) {
Session *s = ASSERT_PTR(userdata);
assert(track);
session_drop_controller(s);
return 0;
}
int session_set_controller(Session *s, const char *sender, bool force, bool prepare) {
_cleanup_free_ char *name = NULL;
int r;
assert(s);
assert(sender);
if (session_is_controller(s, sender))
return 0;
if (s->controller && !force)
return -EBUSY;
name = strdup(sender);
if (!name)
return -ENOMEM;
s->track = sd_bus_track_unref(s->track);
r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
if (r < 0)
return r;
r = sd_bus_track_add_name(s->track, name);
if (r < 0)
return r;
/* When setting a session controller, we forcibly mute the VT and set
* it into graphics-mode. Applications can override that by changing
* VT state after calling TakeControl(). However, this serves as a good
* default and well-behaving controllers can now ignore VTs entirely.
* Note that we reset the VT on ReleaseControl() and if the controller
* exits.
* If logind crashes/restarts, we restore the controller during restart
* (without preparing the VT since the controller has probably overridden
* VT state by now) or reset the VT in case it crashed/exited, too. */
if (prepare) {
r = session_prepare_vt(s);
if (r < 0) {
s->track = sd_bus_track_unref(s->track);
return r;
}
}
session_release_controller(s, true);
s->controller = TAKE_PTR(name);
(void) session_save(s);
return 0;
}
void session_drop_controller(Session *s) {
assert(s);
if (!s->controller)
return;
s->track = sd_bus_track_unref(s->track);
session_set_type(s, s->original_type);
session_release_controller(s, false);
(void) session_save(s);
session_restore_vt(s);
}
bool session_job_pending(Session *s) {
assert(s);
assert(s->user);
/* Check if we have some jobs enqueued and not finished yet. Each time we get JobRemoved signal about
* relevant units, session_send_create_reply and hence us is called (see match_job_removed).
* Note that we don't care about job result here. */
return s->scope_job ||
s->user->runtime_dir_job ||
(SESSION_CLASS_WANTS_SERVICE_MANAGER(s->class) && s->user->service_manager_job);
}
int session_send_create_reply(Session *s, const sd_bus_error *error) {
int r;
assert(s);
/* If error occurred, return it immediately. Otherwise let's wait for all jobs to finish before
* continuing. */
if (!sd_bus_error_is_set(error) && session_job_pending(s))
return 0;
r = 0;
RET_GATHER(r, session_send_create_reply_bus(s, error));
RET_GATHER(r, session_send_create_reply_varlink(s, error));
return r;
}
bool session_is_self(const char *name) {
return isempty(name) || streq(name, "self");
}
bool session_is_auto(const char *name) {
return streq_ptr(name, "auto");
}
static int session_context_build_json(sd_json_variant **ret, const char *name, void *userdata) {
Session *s = ASSERT_PTR(userdata);
assert(ret);
assert(s->user);
return sd_json_buildo(
ret,
SD_JSON_BUILD_PAIR_UNSIGNED("UID", s->user->user_record->uid),
JSON_BUILD_PAIR_PIDREF_NON_NULL("PID", &s->leader),
JSON_BUILD_PAIR_ENUM("Type", session_type_to_string(s->type)),
JSON_BUILD_PAIR_ENUM("Class", session_class_to_string(s->class)),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Service", s->service),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Desktop", s->desktop),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Seat", s->seat ? s->seat->id : NULL),
JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("VTNr", s->vtnr),
JSON_BUILD_PAIR_STRING_NON_EMPTY("TTY", s->tty),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Display", s->display),
SD_JSON_BUILD_PAIR_BOOLEAN("Remote", s->remote),
JSON_BUILD_PAIR_STRING_NON_EMPTY("RemoteHost", s->remote_host),
JSON_BUILD_PAIR_STRING_NON_EMPTY("RemoteUser", s->remote_user),
JSON_BUILD_PAIR_STRV_NON_EMPTY("ExtraDeviceAccess", s->extra_device_access));
}
static int session_runtime_build_json(sd_json_variant **ret, const char *name, void *userdata) {
Session *s = ASSERT_PTR(userdata);
assert(ret);
dual_timestamp idle_ts;
bool idle = session_get_idle_hint(s, &idle_ts);
return sd_json_buildo(
ret,
SD_JSON_BUILD_PAIR_STRING("Id", s->id),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Scope", s->scope),
SD_JSON_BUILD_PAIR_CONDITION(audit_session_is_valid(s->audit_id),
"Audit", SD_JSON_BUILD_UNSIGNED(s->audit_id)),
JSON_BUILD_PAIR_DUAL_TIMESTAMP_NON_NULL("Timestamp", &s->timestamp),
JSON_BUILD_PAIR_ENUM("State", session_state_to_string(session_get_state(s))),
SD_JSON_BUILD_PAIR_BOOLEAN("Active", session_is_active(s)),
SD_JSON_BUILD_PAIR_BOOLEAN("IdleHint", idle),
SD_JSON_BUILD_PAIR_CONDITION(idle, "IdleSinceHint", JSON_BUILD_DUAL_TIMESTAMP(&idle_ts)),
SD_JSON_BUILD_PAIR_BOOLEAN("LockedHint", s->locked_hint),
SD_JSON_BUILD_PAIR_BOOLEAN("CanIdle", SESSION_CLASS_CAN_IDLE(s->class)),
SD_JSON_BUILD_PAIR_BOOLEAN("CanLock", SESSION_CLASS_CAN_LOCK(s->class)));
}
int session_build_json(Session *s, sd_json_variant **ret) {
assert(s);
assert(s->user);
assert(ret);
return sd_json_buildo(
ret,
SD_JSON_BUILD_PAIR_CALLBACK("context", session_context_build_json, s),
SD_JSON_BUILD_PAIR_CALLBACK("runtime", session_runtime_build_json, s));
}
static const char* const session_state_table[_SESSION_STATE_MAX] = {
[SESSION_OPENING] = "opening",
[SESSION_ONLINE] = "online",
[SESSION_ACTIVE] = "active",
[SESSION_CLOSING] = "closing",
};
DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
static const char* const session_type_table[_SESSION_TYPE_MAX] = {
[SESSION_UNSPECIFIED] = "unspecified",
[SESSION_TTY] = "tty",
[SESSION_X11] = "x11",
[SESSION_WAYLAND] = "wayland",
[SESSION_MIR] = "mir",
[SESSION_WEB] = "web",
};
DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
static const char* const session_class_table[_SESSION_CLASS_MAX] = {
[SESSION_USER] = "user",
[SESSION_USER_EARLY] = "user-early",
[SESSION_USER_INCOMPLETE] = "user-incomplete",
[SESSION_USER_LIGHT] = "user-light",
[SESSION_USER_EARLY_LIGHT] = "user-early-light",
[SESSION_GREETER] = "greeter",
[SESSION_LOCK_SCREEN] = "lock-screen",
[SESSION_BACKGROUND] = "background",
[SESSION_BACKGROUND_LIGHT] = "background-light",
[SESSION_MANAGER] = "manager",
[SESSION_MANAGER_EARLY] = "manager-early",
[SESSION_NONE] = "none",
};
DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
static const char* const kill_whom_table[_KILL_WHOM_MAX] = {
[KILL_LEADER] = "leader",
[KILL_ALL] = "all",
};
DEFINE_STRING_TABLE_LOOKUP(kill_whom, KillWhom);
static const char* const tty_validity_table[_TTY_VALIDITY_MAX] = {
[TTY_FROM_PAM] = "from-pam",
[TTY_FROM_UTMP] = "from-utmp",
[TTY_UTMP_INCONSISTENT] = "utmp-inconsistent",
};
DEFINE_STRING_TABLE_LOOKUP(tty_validity, TTYValidity);