[thirdparty/systemd.git] / src / logind-user.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <string.h>
#include <unistd.h>
#include <errno.h>

#include "logind-user.h"
#include "util.h"
#include "cgroup-util.h"
#include "hashmap.h"
#include "strv.h"

User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name) {
        User *u;

        assert(m);
        assert(name);

        u = new0(User, 1);
        if (!u)
                return NULL;

        u->name = strdup(name);
        if (!u->name) {
                free(u);
                return NULL;
        }

        if (asprintf(&u->state_file, "/run/systemd/users/%lu", (unsigned long) uid) < 0) {
                free(u->name);
                free(u);
                return NULL;
        }

        if (hashmap_put(m->users, ULONG_TO_PTR((unsigned long) uid), u) < 0) {
                free(u->state_file);
                free(u->name);
                free(u);
                return NULL;
        }

        u->manager = m;
        u->uid = uid;
        u->gid = gid;

        return u;
}

void user_free(User *u) {
        assert(u);

        if (u->in_gc_queue)
                LIST_REMOVE(User, gc_queue, u->manager->user_gc_queue, u);

        while (u->sessions)
                session_free(u->sessions);

        free(u->cgroup_path);

        free(u->service);
        free(u->runtime_path);

        hashmap_remove(u->manager->users, ULONG_TO_PTR((unsigned long) u->uid));

        free(u->name);
        free(u->state_file);
        free(u);
}

int user_save(User *u) {
        FILE *f;
        int r;
        char *temp_path;

        assert(u);
        assert(u->state_file);

        if (!u->started)
                return 0;

        r = safe_mkdir("/run/systemd/users", 0755, 0, 0);
        if (r < 0)
                goto finish;

        r = fopen_temporary(u->state_file, &f, &temp_path);
        if (r < 0)
                goto finish;

        fchmod(fileno(f), 0644);

        fprintf(f,
                "# This is private data. Do not parse.\n"
                "NAME=%s\n"
                "STATE=%s\n",
                u->name,
                user_state_to_string(user_get_state(u)));

        if (u->cgroup_path)
                fprintf(f,
                        "CGROUP=%s\n",
                        u->cgroup_path);

        if (u->runtime_path)
                fprintf(f,
                        "RUNTIME=%s\n",
                        u->runtime_path);

        if (u->service)
                fprintf(f,
                        "SERVICE=%s\n",
                        u->service);

        if (u->display)
                fprintf(f,
                        "DISPLAY=%s\n",
                        u->display->id);

        if (u->sessions) {
                Session *i;

                fputs("SESSIONS=", f);
                LIST_FOREACH(sessions_by_user, i, u->sessions) {
                        fprintf(f,
                                "%s%c",
                                i->id,
                                i->sessions_by_user_next ? ' ' : '\n');
                }

                fputs("SEATS=", f);
                LIST_FOREACH(sessions_by_user, i, u->sessions) {
                        if (i->seat)
                                fprintf(f,
                                        "%s%c",
                                        i->seat->id,
                                        i->sessions_by_user_next ? ' ' : '\n');
                }

                fputs("ACTIVE_SESSIONS=", f);
                LIST_FOREACH(sessions_by_user, i, u->sessions)
                        if (session_is_active(i))
                                fprintf(f,
                                        "%lu%c",
                                        (unsigned long) i->user->uid,
                                        i->sessions_by_user_next ? ' ' : '\n');

                fputs("ACTIVE_SEATS=", f);
                LIST_FOREACH(sessions_by_user, i, u->sessions) {
                        if (session_is_active(i) && i->seat)
                                fprintf(f,
                                        "%s%c",
                                        i->seat->id,
                                        i->sessions_by_user_next ? ' ' : '\n');
                }
        }

        fflush(f);

        if (ferror(f) || rename(temp_path, u->state_file) < 0) {
                r = -errno;
                unlink(u->state_file);
                unlink(temp_path);
        }

        fclose(f);
        free(temp_path);

finish:
        if (r < 0)
                log_error("Failed to save user data for %s: %s", u->name, strerror(-r));

        return r;
}

int user_load(User *u) {
        int r;
        char *display = NULL;
        Session *s = NULL;

        assert(u);

        r = parse_env_file(u->state_file, NEWLINE,
                           "CGROUP", &u->cgroup_path,
                           "RUNTIME", &u->runtime_path,
                           "SERVICE", &u->service,
                           "DISPLAY", &display,
                           NULL);
        if (r < 0) {
                free(display);

                if (r == -ENOENT)
                        return 0;

                log_error("Failed to read %s: %s", u->state_file, strerror(-r));
                return r;
        }

        if (display) {
                s = hashmap_get(u->manager->sessions, display);
                free(display);
        }

        if (s && s->display && display_is_local(s->display))
                u->display = s;

        return r;
}

static int user_mkdir_runtime_path(User *u) {
        char *p;
        int r;

        assert(u);

        r = safe_mkdir("/run/user", 0755, 0, 0);
        if (r < 0) {
                log_error("Failed to create /run/user: %s", strerror(-r));
                return r;
        }

        if (!u->runtime_path) {
                p = strappend("/run/user/", u->name);

                if (!p) {
                        log_error("Out of memory");
                        return -ENOMEM;
                }
        } else
                p = u->runtime_path;

        r = safe_mkdir(p, 0700, u->uid, u->gid);
        if (r < 0) {
                log_error("Failed to create runtime directory %s: %s", p, strerror(-r));
                free(p);
                u->runtime_path = NULL;
                return r;
        }

        u->runtime_path = p;
        return 0;
}

static int user_create_cgroup(User *u) {
        char **k;
        char *p;
        int r;

        assert(u);

        if (!u->cgroup_path) {
                if (asprintf(&p, "%s/%s", u->manager->cgroup_path, u->name) < 0) {
                        log_error("Out of memory");
                        return -ENOMEM;
                }
        } else
                p = u->cgroup_path;

        r = cg_create(SYSTEMD_CGROUP_CONTROLLER, p);
        if (r < 0) {
                log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", p, strerror(-r));
                free(p);
                u->cgroup_path = NULL;
                return r;
        }

        u->cgroup_path = p;

        STRV_FOREACH(k, u->manager->controllers) {

                if (strv_contains(u->manager->reset_controllers, *k))
                        continue;

                r = cg_create(*k, p);
                if (r < 0)
                        log_warning("Failed to create cgroup %s:%s: %s", *k, p, strerror(-r));
        }

        return 0;
}

static int user_start_service(User *u) {
        assert(u);

        return 0;
}

int user_start(User *u) {
        int r;

        assert(u);

        if (u->started)
                return 0;

        log_info("New user %s logged in.", u->name);

        /* Make XDG_RUNTIME_DIR */
        r = user_mkdir_runtime_path(u);
        if (r < 0)
                return r;

        /* Create cgroup */
        r = user_create_cgroup(u);
        if (r < 0)
                return r;

        /* Spawn user systemd */
        r = user_start_service(u);
        if (r < 0)
                return r;

        dual_timestamp_get(&u->timestamp);

        u->started = true;

        /* Save new user data */
        user_save(u);

        user_send_signal(u, true);

        return 0;
}

static int user_stop_service(User *u) {
        assert(u);

        if (!u->service)
                return 0;

        return 0;
}

static int user_shall_kill(User *u) {
        assert(u);

        if (!u->manager->kill_user_processes)
                return false;

        if (strv_contains(u->manager->kill_exclude_users, u->name))
                return false;

        if (strv_isempty(u->manager->kill_only_users))
                return true;

        return strv_contains(u->manager->kill_only_users, u->name);
}

static int user_terminate_cgroup(User *u) {
        int r;
        char **k;

        assert(u);

        if (!u->cgroup_path)
                return 0;

        cg_trim(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);

        if (user_shall_kill(u)) {

                r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
                if (r < 0)
                        log_error("Failed to kill user cgroup: %s", strerror(-r));
        } else {

                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
                if (r < 0)
                        log_error("Failed to check user cgroup: %s", strerror(-r));
                else if (r > 0) {
                        r = cg_delete(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
                        if (r < 0)
                                log_error("Failed to delete user cgroup: %s", strerror(-r));
                } else
                        r = -EBUSY;
        }

        STRV_FOREACH(k, u->manager->controllers)
                cg_trim(*k, u->cgroup_path, true);

        free(u->cgroup_path);
        u->cgroup_path = NULL;

        return r;
}

static int user_remove_runtime_path(User *u) {
        int r;

        assert(u);

        if (!u->runtime_path)
                return 0;

        r = rm_rf(u->runtime_path, false, true, false);
        if (r < 0)
                log_error("Failed to remove runtime directory %s: %s", u->runtime_path, strerror(-r));

        free(u->runtime_path);
        u->runtime_path = NULL;

        return r;
}

int user_stop(User *u) {
        Session *s;
        int r = 0, k;
        assert(u);

        if (u->started)
                log_info("User %s logged out.", u->name);

        LIST_FOREACH(sessions_by_user, s, u->sessions) {
                k = session_stop(s);
                if (k < 0)
                        r = k;
        }

        /* Kill systemd */
        k = user_stop_service(u);
        if (k < 0)
                r = k;

        /* Kill cgroup */
        k = user_terminate_cgroup(u);
        if (k < 0)
                r = k;

        /* Kill XDG_RUNTIME_DIR */
        k = user_remove_runtime_path(u);
        if (k < 0)
                r = k;

        unlink(u->state_file);
        user_add_to_gc_queue(u);

        if (u->started)
                user_send_signal(u, false);

        u->started = false;

        return r;
}

int user_get_idle_hint(User *u, dual_timestamp *t) {
        Session *s;
        bool idle_hint = true;
        dual_timestamp ts = { 0, 0 };

        assert(u);

        LIST_FOREACH(sessions_by_user, s, u->sessions) {
                dual_timestamp k;
                int ih;

                ih = session_get_idle_hint(s, &k);
                if (ih < 0)
                        return ih;

                if (!ih) {
                        if (!idle_hint) {
                                if (k.monotonic < ts.monotonic)
                                        ts = k;
                        } else {
                                idle_hint = false;
                                ts = k;
                        }
                } else if (idle_hint) {

                        if (k.monotonic > ts.monotonic)
                                ts = k;
                }
        }

        if (t)
                *t = ts;

        return idle_hint;
}

int user_check_gc(User *u, bool drop_not_started) {
        int r;
        char *p;

        assert(u);

        if (drop_not_started && !u->started)
                return 0;

        if (u->sessions)
                return 1;

        if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
                return -ENOMEM;

        r = access(p, F_OK) >= 0;
        free(p);

        if (r > 0)
                return 1;

        if (u->cgroup_path) {
                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
                if (r < 0)
                        return r;

                if (r <= 0)
                        return 1;
        }

        return 0;
}

void user_add_to_gc_queue(User *u) {
        assert(u);

        if (u->in_gc_queue)
                return;

        LIST_PREPEND(User, gc_queue, u->manager->user_gc_queue, u);
        u->in_gc_queue = true;
}

UserState user_get_state(User *u) {
        Session *i;

        assert(u);

        if (!u->sessions)
                return USER_LINGERING;

        LIST_FOREACH(sessions_by_user, i, u->sessions)
                if (session_is_active(i))
                        return USER_ACTIVE;

        return USER_ONLINE;
}

int user_kill(User *u, int signo) {
        int r = 0, q;
        Set *pid_set = NULL;

        assert(u);

        if (!u->cgroup_path)
                return -ESRCH;

        pid_set = set_new(trivial_hash_func, trivial_compare_func);
        if (!pid_set)
                return -ENOMEM;

        q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
        if (q < 0)
                if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
                        r = q;

        if (pid_set)
                set_free(pid_set);

        return r;
}

static const char* const user_state_table[_USER_STATE_MAX] = {
        [USER_OFFLINE] = "offline",
        [USER_LINGERING] = "lingering",
        [USER_ONLINE] = "online",
        [USER_ACTIVE] = "active"
};

DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);
Commit	Line	Data
20263082 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2011 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <string.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25
90821c93	26	#include "logind-user.h"
20263082 LP	27	#include "util.h"
	28	#include "cgroup-util.h"
	29	#include "hashmap.h"
	30	#include "strv.h"
	31
	32	User* user_new(Manager m, uid_t uid, gid_t gid, const char name) {
	33	User *u;
	34
	35	assert(m);
	36	assert(name);
	37
14c3baca	38	u = new0(User, 1);
20263082 LP	39	if (!u)
	40	return NULL;
	41
	42	u->name = strdup(name);
	43	if (!u->name) {
	44	free(u);
	45	return NULL;
	46	}
	47
98a28fef	48	if (asprintf(&u->state_file, "/run/systemd/users/%lu", (unsigned long) uid) < 0) {
20263082 LP	49	free(u->name);
	50	free(u);
	51	return NULL;
	52	}
	53
	54	if (hashmap_put(m->users, ULONG_TO_PTR((unsigned long) uid), u) < 0) {
	55	free(u->state_file);
	56	free(u->name);
	57	free(u);
	58	return NULL;
	59	}
	60
	61	u->manager = m;
	62	u->uid = uid;
	63	u->gid = gid;
	64
	65	return u;
	66	}
	67
	68	void user_free(User *u) {
	69	assert(u);
	70
14c3baca LP	71	if (u->in_gc_queue)
	72	LIST_REMOVE(User, gc_queue, u->manager->user_gc_queue, u);
	73
20263082 LP	74	while (u->sessions)
	75	session_free(u->sessions);
	76
	77	free(u->cgroup_path);
	78
	79	free(u->service);
	80	free(u->runtime_path);
	81
	82	hashmap_remove(u->manager->users, ULONG_TO_PTR((unsigned long) u->uid));
	83
	84	free(u->name);
d2f92cdf	85	free(u->state_file);
20263082 LP	86	free(u);
	87	}
	88
	89	int user_save(User *u) {
	90	FILE *f;
	91	int r;
14c3baca	92	char *temp_path;
20263082 LP	93
	94	assert(u);
	95	assert(u->state_file);
	96
accaeded LP	97	if (!u->started)
	98	return 0;
	99
98a28fef	100	r = safe_mkdir("/run/systemd/users", 0755, 0, 0);
20263082	101	if (r < 0)
14c3baca	102	goto finish;
20263082	103
14c3baca LP	104	r = fopen_temporary(u->state_file, &f, &temp_path);
	105	if (r < 0)
	106	goto finish;
	107
	108	fchmod(fileno(f), 0644);
20263082 LP	109
20263082 LP	110	fprintf(f,
14c3baca	111	"# This is private data. Do not parse.\n"
20263082 LP	112	"NAME=%s\n"
	113	"STATE=%s\n",
	114	u->name,
	115	user_state_to_string(user_get_state(u)));
	116
	117	if (u->cgroup_path)
	118	fprintf(f,
	119	"CGROUP=%s\n",
	120	u->cgroup_path);
	121
	122	if (u->runtime_path)
	123	fprintf(f,
	124	"RUNTIME=%s\n",
	125	u->runtime_path);
	126
	127	if (u->service)
	128	fprintf(f,
	129	"SERVICE=%s\n",
	130	u->service);
	131
	132	if (u->display)
	133	fprintf(f,
	134	"DISPLAY=%s\n",
	135	u->display->id);
	136
034a2a52 LP	137	if (u->sessions) {
	138	Session *i;
	139
	140	fputs("SESSIONS=", f);
	141	LIST_FOREACH(sessions_by_user, i, u->sessions) {
	142	fprintf(f,
	143	"%s%c",
	144	i->id,
6c7506dc	145	i->sessions_by_user_next ? ' ' : '\n');
034a2a52 LP	146	}
	147
	148	fputs("SEATS=", f);
	149	LIST_FOREACH(sessions_by_user, i, u->sessions) {
	150	if (i->seat)
	151	fprintf(f,
	152	"%s%c",
	153	i->seat->id,
6c7506dc	154	i->sessions_by_user_next ? ' ' : '\n');
034a2a52 LP	155	}
	156
	157	fputs("ACTIVE_SESSIONS=", f);
	158	LIST_FOREACH(sessions_by_user, i, u->sessions)
	159	if (session_is_active(i))
	160	fprintf(f,
	161	"%lu%c",
	162	(unsigned long) i->user->uid,
6c7506dc	163	i->sessions_by_user_next ? ' ' : '\n');
034a2a52 LP	164
	165	fputs("ACTIVE_SEATS=", f);
	166	LIST_FOREACH(sessions_by_user, i, u->sessions) {
	167	if (session_is_active(i) && i->seat)
	168	fprintf(f,
	169	"%s%c",
	170	i->seat->id,
6c7506dc	171	i->sessions_by_user_next ? ' ' : '\n');
034a2a52 LP	172	}
	173	}
	174
20263082	175	fflush(f);
14c3baca LP	176
14c3baca LP	177	if (ferror(f) \|\| rename(temp_path, u->state_file) < 0) {
20263082 LP	178	r = -errno;
20263082 LP	179	unlink(u->state_file);
14c3baca	180	unlink(temp_path);
20263082 LP	181	}
	182
	183	fclose(f);
14c3baca LP	184	free(temp_path);
	185
	186	finish:
	187	if (r < 0)
	188	log_error("Failed to save user data for %s: %s", u->name, strerror(-r));
	189
20263082 LP	190	return r;
	191	}
	192
	193	int user_load(User *u) {
	194	int r;
	195	char *display = NULL;
98a28fef	196	Session *s = NULL;
20263082 LP	197
	198	assert(u);
	199
a185c5aa	200	r = parse_env_file(u->state_file, NEWLINE,
20263082 LP	201	"CGROUP", &u->cgroup_path,
	202	"RUNTIME", &u->runtime_path,
	203	"SERVICE", &u->service,
	204	"DISPLAY", &display,
	205	NULL);
	206	if (r < 0) {
	207	free(display);
	208
	209	if (r == -ENOENT)
	210	return 0;
	211
	212	log_error("Failed to read %s: %s", u->state_file, strerror(-r));
	213	return r;
	214	}
	215
98a28fef LP	216	if (display) {
	217	s = hashmap_get(u->manager->sessions, display);
	218	free(display);
	219	}
20263082	220
4d6d6518	221	if (s && s->display && display_is_local(s->display))
20263082 LP	222	u->display = s;
	223
	224	return r;
	225	}
	226
	227	static int user_mkdir_runtime_path(User *u) {
	228	char *p;
	229	int r;
	230
	231	assert(u);
	232
	233	r = safe_mkdir("/run/user", 0755, 0, 0);
	234	if (r < 0) {
	235	log_error("Failed to create /run/user: %s", strerror(-r));
	236	return r;
	237	}
	238
	239	if (!u->runtime_path) {
	240	p = strappend("/run/user/", u->name);
	241
	242	if (!p) {
	243	log_error("Out of memory");
	244	return -ENOMEM;
	245	}
	246	} else
	247	p = u->runtime_path;
	248
	249	r = safe_mkdir(p, 0700, u->uid, u->gid);
	250	if (r < 0) {
	251	log_error("Failed to create runtime directory %s: %s", p, strerror(-r));
	252	free(p);
	253	u->runtime_path = NULL;
	254	return r;
	255	}
	256
	257	u->runtime_path = p;
	258	return 0;
	259	}
	260
	261	static int user_create_cgroup(User *u) {
	262	char **k;
	263	char *p;
	264	int r;
	265
	266	assert(u);
	267
	268	if (!u->cgroup_path) {
	269	if (asprintf(&p, "%s/%s", u->manager->cgroup_path, u->name) < 0) {
	270	log_error("Out of memory");
	271	return -ENOMEM;
	272	}
	273	} else
	274	p = u->cgroup_path;
	275
	276	r = cg_create(SYSTEMD_CGROUP_CONTROLLER, p);
	277	if (r < 0) {
4d6d6518	278	log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", p, strerror(-r));
20263082 LP	279	free(p);
20263082 LP	280	u->cgroup_path = NULL;
20263082 LP	281	return r;
	282	}
	283
	284	u->cgroup_path = p;
	285
	286	STRV_FOREACH(k, u->manager->controllers) {
193197e8 LP	287
	288	if (strv_contains(u->manager->reset_controllers, *k))
	289	continue;
	290
20263082 LP	291	r = cg_create(*k, p);
	292	if (r < 0)
	293	log_warning("Failed to create cgroup %s:%s: %s", *k, p, strerror(-r));
	294	}
	295
	296	return 0;
	297	}
	298
	299	static int user_start_service(User *u) {
	300	assert(u);
	301
	302	return 0;
	303	}
	304
	305	int user_start(User *u) {
	306	int r;
	307
	308	assert(u);
	309
9418f147 LP	310	if (u->started)
	311	return 0;
	312
ed18b08b LP	313	log_info("New user %s logged in.", u->name);
ed18b08b LP	314
20263082 LP	315	/* Make XDG_RUNTIME_DIR */
	316	r = user_mkdir_runtime_path(u);
	317	if (r < 0)
	318	return r;
	319
	320	/* Create cgroup */
	321	r = user_create_cgroup(u);
	322	if (r < 0)
	323	return r;
	324
	325	/* Spawn user systemd */
	326	r = user_start_service(u);
	327	if (r < 0)
	328	return r;
	329
	330	dual_timestamp_get(&u->timestamp);
	331
9418f147 LP	332	u->started = true;
9418f147 LP	333
7f7bb946 LP	334	/* Save new user data */
	335	user_save(u);
	336
da119395 LP	337	user_send_signal(u, true);
da119395 LP	338
20263082 LP	339	return 0;
	340	}
	341
	342	static int user_stop_service(User *u) {
	343	assert(u);
	344
	345	if (!u->service)
	346	return 0;
	347
	348	return 0;
	349	}
	350
	351	static int user_shall_kill(User *u) {
	352	assert(u);
	353
ed18b08b LP	354	if (!u->manager->kill_user_processes)
	355	return false;
	356
	357	if (strv_contains(u->manager->kill_exclude_users, u->name))
	358	return false;
	359
	360	if (strv_isempty(u->manager->kill_only_users))
	361	return true;
	362
	363	return strv_contains(u->manager->kill_only_users, u->name);
20263082 LP	364	}
20263082 LP	365
de07ab16	366	static int user_terminate_cgroup(User *u) {
20263082 LP	367	int r;
	368	char **k;
	369
	370	assert(u);
	371
	372	if (!u->cgroup_path)
	373	return 0;
	374
	375	cg_trim(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
	376
	377	if (user_shall_kill(u)) {
	378
	379	r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
	380	if (r < 0)
	381	log_error("Failed to kill user cgroup: %s", strerror(-r));
	382	} else {
	383
	384	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
	385	if (r < 0)
	386	log_error("Failed to check user cgroup: %s", strerror(-r));
	387	else if (r > 0) {
	388	r = cg_delete(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
	389	if (r < 0)
	390	log_error("Failed to delete user cgroup: %s", strerror(-r));
	391	} else
	392	r = -EBUSY;
	393	}
	394
	395	STRV_FOREACH(k, u->manager->controllers)
	396	cg_trim(*k, u->cgroup_path, true);
	397
	398	free(u->cgroup_path);
	399	u->cgroup_path = NULL;
	400
	401	return r;
	402	}
	403
	404	static int user_remove_runtime_path(User *u) {
	405	int r;
	406
	407	assert(u);
	408
	409	if (!u->runtime_path)
	410	return 0;
	411
ad293f5a	412	r = rm_rf(u->runtime_path, false, true, false);
20263082 LP	413	if (r < 0)
	414	log_error("Failed to remove runtime directory %s: %s", u->runtime_path, strerror(-r));
	415
	416	free(u->runtime_path);
	417	u->runtime_path = NULL;
	418
	419	return r;
	420	}
	421
	422	int user_stop(User *u) {
	423	Session *s;
	424	int r = 0, k;
	425	assert(u);
	426
ed18b08b LP	427	if (u->started)
ed18b08b LP	428	log_info("User %s logged out.", u->name);
9418f147	429
20263082 LP	430	LIST_FOREACH(sessions_by_user, s, u->sessions) {
	431	k = session_stop(s);
	432	if (k < 0)
	433	r = k;
	434	}
	435
	436	/* Kill systemd */
	437	k = user_stop_service(u);
	438	if (k < 0)
	439	r = k;
	440
	441	/* Kill cgroup */
de07ab16	442	k = user_terminate_cgroup(u);
20263082 LP	443	if (k < 0)
	444	r = k;
	445
	446	/* Kill XDG_RUNTIME_DIR */
	447	k = user_remove_runtime_path(u);
	448	if (k < 0)
	449	r = k;
	450
d2f92cdf LP	451	unlink(u->state_file);
	452	user_add_to_gc_queue(u);
	453
ed18b08b LP	454	if (u->started)
	455	user_send_signal(u, false);
	456
9418f147 LP	457	u->started = false;
9418f147 LP	458
20263082 LP	459	return r;
	460	}
	461
a185c5aa LP	462	int user_get_idle_hint(User u, dual_timestamp t) {
	463	Session *s;
	464	bool idle_hint = true;
	465	dual_timestamp ts = { 0, 0 };
	466
	467	assert(u);
	468
	469	LIST_FOREACH(sessions_by_user, s, u->sessions) {
	470	dual_timestamp k;
	471	int ih;
	472
	473	ih = session_get_idle_hint(s, &k);
	474	if (ih < 0)
	475	return ih;
	476
	477	if (!ih) {
	478	if (!idle_hint) {
	479	if (k.monotonic < ts.monotonic)
	480	ts = k;
	481	} else {
	482	idle_hint = false;
	483	ts = k;
	484	}
	485	} else if (idle_hint) {
	486
	487	if (k.monotonic > ts.monotonic)
	488	ts = k;
	489	}
	490	}
	491
	492	if (t)
	493	*t = ts;
	494
	495	return idle_hint;
	496	}
	497
4a4b033f	498	int user_check_gc(User *u, bool drop_not_started) {
20263082 LP	499	int r;
	500	char *p;
	501
	502	assert(u);
	503
4a4b033f	504	if (drop_not_started && !u->started)
932e3ee7 LP	505	return 0;
932e3ee7 LP	506
20263082 LP	507	if (u->sessions)
	508	return 1;
	509
	510	if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
	511	return -ENOMEM;
	512
	513	r = access(p, F_OK) >= 0;
	514	free(p);
	515
	516	if (r > 0)
	517	return 1;
	518
	519	if (u->cgroup_path) {
	520	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
	521	if (r < 0)
	522	return r;
	523
	524	if (r <= 0)
	525	return 1;
	526	}
	527
	528	return 0;
	529	}
	530
14c3baca LP	531	void user_add_to_gc_queue(User *u) {
	532	assert(u);
	533
	534	if (u->in_gc_queue)
	535	return;
	536
	537	LIST_PREPEND(User, gc_queue, u->manager->user_gc_queue, u);
	538	u->in_gc_queue = true;
	539	}
	540
20263082 LP	541	UserState user_get_state(User *u) {
	542	Session *i;
	543
	544	assert(u);
	545
	546	if (!u->sessions)
	547	return USER_LINGERING;
	548
	549	LIST_FOREACH(sessions_by_user, i, u->sessions)
	550	if (session_is_active(i))
	551	return USER_ACTIVE;
	552
	553	return USER_ONLINE;
	554	}
	555
de07ab16 LP	556	int user_kill(User *u, int signo) {
	557	int r = 0, q;
	558	Set *pid_set = NULL;
	559
	560	assert(u);
	561
	562	if (!u->cgroup_path)
	563	return -ESRCH;
	564
	565	pid_set = set_new(trivial_hash_func, trivial_compare_func);
	566	if (!pid_set)
	567	return -ENOMEM;
	568
	569	q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
	570	if (q < 0)
	571	if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
	572	r = q;
	573
de07ab16 LP	574	if (pid_set)
	575	set_free(pid_set);
	576
	577	return r;
	578	}
	579
20263082 LP	580	static const char* const user_state_table[_USER_STATE_MAX] = {
	581	[USER_OFFLINE] = "offline",
	582	[USER_LINGERING] = "lingering",
	583	[USER_ONLINE] = "online",
	584	[USER_ACTIVE] = "active"
	585	};
	586
	587	DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);