HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/login/logind-session.c

60,874 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);