HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/login/logind-user.c

41,432 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 9bac65cc815088c6d69515d2eb869508b6d5debc

Lines 1001–1179 of 1,179

        if (!timestamp_is_set(user_stop_delay))
                return;
 
        if (sd_event_get_state(u->manager->event) == SD_EVENT_FINISHED) {
                log_debug("Not allocating user stop timeout, since we are already exiting.");
                return;
        }
 
        r = sd_event_add_time(u->manager->event,
                              &u->timer_event_source,
                              CLOCK_MONOTONIC,
                              usec_add(u->last_session_timestamp, user_stop_delay), 0,
                              user_stop_timeout_callback, u);
        if (r < 0)
                log_warning_errno(r, "Failed to enqueue user stop event source, ignoring: %m");
 
        if (DEBUG_LOGGING)
                log_debug("Last session of user '%s' logged out, terminating user context in %s.",
                          u->user_record->user_name,
                          FORMAT_TIMESPAN(user_stop_delay, USEC_PER_MSEC));
}
 
static int user_sessions_build_json(sd_json_variant **ret, const char *name, void *userdata) {
        User *u = ASSERT_PTR(userdata);
        int r;
 
        assert(ret);
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        LIST_FOREACH(sessions_by_user, session, u->sessions) {
                r = sd_json_variant_append_arrayb(&v, SD_JSON_BUILD_STRING(session->id));
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(v);
        return 0;
}
 
static int user_context_build_json(sd_json_variant **ret, const char *name, void *userdata) {
        User *u = ASSERT_PTR(userdata);
 
        assert(ret);
        assert(u->user_record);
 
        int linger = user_check_linger_file(u);
        if (linger == -ENOMEM)
                return linger;
        if (linger < 0)
                log_warning_errno(linger,
                                  "Failed to check linger file for user '%s', assuming disabled: %m",
                                  u->user_record->user_name);
 
        return sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_UNSIGNED("UID", u->user_record->uid),
                        SD_JSON_BUILD_PAIR_UNSIGNED("GID", u->user_record->gid),
                        SD_JSON_BUILD_PAIR_STRING("Name", u->user_record->user_name),
                        SD_JSON_BUILD_PAIR_BOOLEAN("Linger", linger > 0),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Service", u->service_manager_unit),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Slice", u->slice),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("RuntimePath", u->runtime_path));
}
 
static int user_runtime_build_json(sd_json_variant **ret, const char *name, void *userdata) {
        User *u = ASSERT_PTR(userdata);
 
        assert(ret);
 
        dual_timestamp idle_ts;
        bool idle = user_get_idle_hint(u, &idle_ts);
 
        return sd_json_buildo(
                        ret,
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Display", u->display ? u->display->id : NULL),
                        JSON_BUILD_PAIR_ENUM("State", user_state_to_string(user_get_state(u))),
                        JSON_BUILD_PAIR_CALLBACK_NON_NULL("Sessions", user_sessions_build_json, u),
                        JSON_BUILD_PAIR_DUAL_TIMESTAMP_NON_NULL("Timestamp", &u->timestamp),
                        SD_JSON_BUILD_PAIR_BOOLEAN("IdleHint", idle),
                        SD_JSON_BUILD_PAIR_CONDITION(idle, "IdleSinceHint", JSON_BUILD_DUAL_TIMESTAMP(&idle_ts)));
}
 
int user_build_json(User *u, sd_json_variant **ret) {
        assert(u);
        assert(u->user_record);
        assert(ret);
 
        return sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_CALLBACK("context", user_context_build_json, u),
                        SD_JSON_BUILD_PAIR_CALLBACK("runtime", user_runtime_build_json, u));
}
 
static const char* const user_state_table[_USER_STATE_MAX] = {
        [USER_OFFLINE]   = "offline",
        [USER_OPENING]   = "opening",
        [USER_LINGERING] = "lingering",
        [USER_ONLINE]    = "online",
        [USER_ACTIVE]    = "active",
        [USER_CLOSING]   = "closing"
};
 
DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);
 
static const char* const user_gc_mode_table[_USER_GC_MODE_MAX] = {
        [USER_GC_BY_PIN] = "pin",
        [USER_GC_BY_ANY] = "any",
};
 
DEFINE_STRING_TABLE_LOOKUP(user_gc_mode, UserGCMode);
 
int config_parse_tmpfs_size(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        uint64_t *sz = ASSERT_PTR(data);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        /* First, try to parse as percentage */
        r = parse_permyriad(rvalue);
        if (r > 0)
                *sz = physical_memory_scale(r, 10000U);
        else {
                uint64_t k;
 
                /* If the passed argument was not a percentage, or out of range, parse as byte size */
 
                r = parse_size(rvalue, 1024, &k);
                if (r >= 0 && (k <= 0 || (uint64_t) (size_t) k != k))
                        r = -ERANGE;
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse size value '%s', ignoring: %m", rvalue);
                        return 0;
                }
 
                *sz = PAGE_ALIGN((size_t) k);
        }
 
        return 0;
}
 
int config_parse_compat_user_tasks_max(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        log_syntax(unit, LOG_NOTICE, filename, line, 0,
                   "Support for option %s= has been removed.",
                   lvalue);
        log_info("Hint: try creating /etc/systemd/system/user-.slice.d/50-limits.conf with:\n"
                 "        [Slice]\n"
                 "        TasksMax=%s",
                 rvalue);
        return 0;
}