]>
Commit | Line | Data |
---|---|---|
663996b3 MS |
1 | /*** |
2 | This file is part of systemd. | |
3 | ||
4 | Copyright 2011 Lennart Poettering | |
5 | ||
6 | systemd is free software; you can redistribute it and/or modify it | |
7 | under the terms of the GNU Lesser General Public License as published by | |
8 | the Free Software Foundation; either version 2.1 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | systemd is distributed in the hope that it will be useful, but | |
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | Lesser General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU Lesser General Public License | |
17 | along with systemd; If not, see <http://www.gnu.org/licenses/>. | |
18 | ***/ | |
19 | ||
db2df898 | 20 | #include <errno.h> |
663996b3 | 21 | #include <string.h> |
db2df898 | 22 | #include <sys/mount.h> |
663996b3 | 23 | #include <unistd.h> |
663996b3 | 24 | |
db2df898 MP |
25 | #include "alloc-util.h" |
26 | #include "bus-common-errors.h" | |
60f067b4 | 27 | #include "bus-error.h" |
db2df898 | 28 | #include "bus-util.h" |
60f067b4 | 29 | #include "clean-ipc.h" |
db2df898 MP |
30 | #include "conf-parser.h" |
31 | #include "escape.h" | |
32 | #include "fd-util.h" | |
33 | #include "fileio.h" | |
e3bff60a | 34 | #include "formats-util.h" |
db2df898 MP |
35 | #include "fs-util.h" |
36 | #include "hashmap.h" | |
86f210e9 MP |
37 | #include "label.h" |
38 | #include "logind-user.h" | |
db2df898 MP |
39 | #include "mkdir.h" |
40 | #include "mount-util.h" | |
41 | #include "parse-util.h" | |
42 | #include "path-util.h" | |
43 | #include "rm-rf.h" | |
44 | #include "smack-util.h" | |
45 | #include "special.h" | |
46 | #include "stdio-util.h" | |
47 | #include "string-table.h" | |
48 | #include "unit-name.h" | |
49 | #include "user-util.h" | |
50 | #include "util.h" | |
663996b3 | 51 | |
db2df898 MP |
52 | int user_new(User **out, Manager *m, uid_t uid, gid_t gid, const char *name) { |
53 | _cleanup_(user_freep) User *u = NULL; | |
54 | char lu[DECIMAL_STR_MAX(uid_t) + 1]; | |
55 | int r; | |
663996b3 | 56 | |
db2df898 | 57 | assert(out); |
663996b3 MS |
58 | assert(m); |
59 | assert(name); | |
60 | ||
61 | u = new0(User, 1); | |
62 | if (!u) | |
db2df898 MP |
63 | return -ENOMEM; |
64 | ||
65 | u->manager = m; | |
66 | u->uid = uid; | |
67 | u->gid = gid; | |
68 | xsprintf(lu, UID_FMT, uid); | |
663996b3 MS |
69 | |
70 | u->name = strdup(name); | |
14228c0d | 71 | if (!u->name) |
db2df898 | 72 | return -ENOMEM; |
663996b3 | 73 | |
60f067b4 | 74 | if (asprintf(&u->state_file, "/run/systemd/users/"UID_FMT, uid) < 0) |
db2df898 | 75 | return -ENOMEM; |
663996b3 | 76 | |
db2df898 MP |
77 | if (asprintf(&u->runtime_path, "/run/user/"UID_FMT, uid) < 0) |
78 | return -ENOMEM; | |
663996b3 | 79 | |
db2df898 MP |
80 | r = slice_build_subslice(SPECIAL_USER_SLICE, lu, &u->slice); |
81 | if (r < 0) | |
82 | return r; | |
663996b3 | 83 | |
db2df898 MP |
84 | r = unit_name_build("user", lu, ".service", &u->service); |
85 | if (r < 0) | |
86 | return r; | |
14228c0d | 87 | |
db2df898 MP |
88 | r = hashmap_put(m->users, UID_TO_PTR(uid), u); |
89 | if (r < 0) | |
90 | return r; | |
91 | ||
92 | r = hashmap_put(m->user_units, u->slice, u); | |
93 | if (r < 0) | |
94 | return r; | |
95 | ||
96 | r = hashmap_put(m->user_units, u->service, u); | |
97 | if (r < 0) | |
98 | return r; | |
14228c0d | 99 | |
db2df898 MP |
100 | *out = u; |
101 | u = NULL; | |
102 | return 0; | |
663996b3 MS |
103 | } |
104 | ||
db2df898 MP |
105 | User *user_free(User *u) { |
106 | if (!u) | |
107 | return NULL; | |
663996b3 MS |
108 | |
109 | if (u->in_gc_queue) | |
60f067b4 | 110 | LIST_REMOVE(gc_queue, u->manager->user_gc_queue, u); |
663996b3 MS |
111 | |
112 | while (u->sessions) | |
113 | session_free(u->sessions); | |
114 | ||
db2df898 MP |
115 | if (u->service) |
116 | hashmap_remove_value(u->manager->user_units, u->service, u); | |
14228c0d | 117 | |
db2df898 MP |
118 | if (u->slice) |
119 | hashmap_remove_value(u->manager->user_units, u->slice, u); | |
14228c0d | 120 | |
db2df898 | 121 | hashmap_remove_value(u->manager->users, UID_TO_PTR(u->uid), u); |
663996b3 | 122 | |
db2df898 MP |
123 | u->slice_job = mfree(u->slice_job); |
124 | u->service_job = mfree(u->service_job); | |
663996b3 | 125 | |
db2df898 MP |
126 | u->service = mfree(u->service); |
127 | u->slice = mfree(u->slice); | |
128 | u->runtime_path = mfree(u->runtime_path); | |
129 | u->state_file = mfree(u->state_file); | |
130 | u->name = mfree(u->name); | |
663996b3 | 131 | |
db2df898 | 132 | return mfree(u); |
663996b3 MS |
133 | } |
134 | ||
86f210e9 | 135 | static int user_save_internal(User *u) { |
14228c0d MB |
136 | _cleanup_free_ char *temp_path = NULL; |
137 | _cleanup_fclose_ FILE *f = NULL; | |
663996b3 | 138 | int r; |
663996b3 MS |
139 | |
140 | assert(u); | |
141 | assert(u->state_file); | |
142 | ||
663996b3 MS |
143 | r = mkdir_safe_label("/run/systemd/users", 0755, 0, 0); |
144 | if (r < 0) | |
5fd56512 | 145 | goto fail; |
663996b3 MS |
146 | |
147 | r = fopen_temporary(u->state_file, &f, &temp_path); | |
148 | if (r < 0) | |
5fd56512 | 149 | goto fail; |
663996b3 MS |
150 | |
151 | fchmod(fileno(f), 0644); | |
152 | ||
153 | fprintf(f, | |
154 | "# This is private data. Do not parse.\n" | |
155 | "NAME=%s\n" | |
156 | "STATE=%s\n", | |
157 | u->name, | |
158 | user_state_to_string(user_get_state(u))); | |
159 | ||
db2df898 | 160 | /* LEGACY: no-one reads RUNTIME= anymore, drop it at some point */ |
663996b3 | 161 | if (u->runtime_path) |
14228c0d | 162 | fprintf(f, "RUNTIME=%s\n", u->runtime_path); |
663996b3 | 163 | |
14228c0d MB |
164 | if (u->service_job) |
165 | fprintf(f, "SERVICE_JOB=%s\n", u->service_job); | |
166 | ||
14228c0d MB |
167 | if (u->slice_job) |
168 | fprintf(f, "SLICE_JOB=%s\n", u->slice_job); | |
663996b3 MS |
169 | |
170 | if (u->display) | |
14228c0d MB |
171 | fprintf(f, "DISPLAY=%s\n", u->display->id); |
172 | ||
173 | if (dual_timestamp_is_set(&u->timestamp)) | |
663996b3 | 174 | fprintf(f, |
60f067b4 JS |
175 | "REALTIME="USEC_FMT"\n" |
176 | "MONOTONIC="USEC_FMT"\n", | |
177 | u->timestamp.realtime, | |
178 | u->timestamp.monotonic); | |
663996b3 MS |
179 | |
180 | if (u->sessions) { | |
181 | Session *i; | |
182 | bool first; | |
183 | ||
184 | fputs("SESSIONS=", f); | |
185 | first = true; | |
186 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
187 | if (first) | |
188 | first = false; | |
189 | else | |
190 | fputc(' ', f); | |
191 | ||
192 | fputs(i->id, f); | |
193 | } | |
194 | ||
195 | fputs("\nSEATS=", f); | |
196 | first = true; | |
197 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
198 | if (!i->seat) | |
199 | continue; | |
200 | ||
201 | if (first) | |
202 | first = false; | |
203 | else | |
204 | fputc(' ', f); | |
205 | ||
206 | fputs(i->seat->id, f); | |
207 | } | |
208 | ||
209 | fputs("\nACTIVE_SESSIONS=", f); | |
210 | first = true; | |
211 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
212 | if (!session_is_active(i)) | |
213 | continue; | |
214 | ||
215 | if (first) | |
216 | first = false; | |
217 | else | |
218 | fputc(' ', f); | |
219 | ||
220 | fputs(i->id, f); | |
221 | } | |
222 | ||
223 | fputs("\nONLINE_SESSIONS=", f); | |
224 | first = true; | |
225 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
226 | if (session_get_state(i) == SESSION_CLOSING) | |
227 | continue; | |
228 | ||
229 | if (first) | |
230 | first = false; | |
231 | else | |
232 | fputc(' ', f); | |
233 | ||
234 | fputs(i->id, f); | |
235 | } | |
236 | ||
237 | fputs("\nACTIVE_SEATS=", f); | |
238 | first = true; | |
239 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
240 | if (!session_is_active(i) || !i->seat) | |
241 | continue; | |
242 | ||
243 | if (first) | |
244 | first = false; | |
245 | else | |
246 | fputc(' ', f); | |
247 | ||
248 | fputs(i->seat->id, f); | |
249 | } | |
250 | ||
251 | fputs("\nONLINE_SEATS=", f); | |
252 | first = true; | |
253 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
254 | if (session_get_state(i) == SESSION_CLOSING || !i->seat) | |
255 | continue; | |
256 | ||
257 | if (first) | |
258 | first = false; | |
259 | else | |
260 | fputc(' ', f); | |
261 | ||
262 | fputs(i->seat->id, f); | |
263 | } | |
264 | fputc('\n', f); | |
265 | } | |
266 | ||
5fd56512 MP |
267 | r = fflush_and_check(f); |
268 | if (r < 0) | |
269 | goto fail; | |
663996b3 | 270 | |
5fd56512 | 271 | if (rename(temp_path, u->state_file) < 0) { |
663996b3 | 272 | r = -errno; |
5fd56512 | 273 | goto fail; |
663996b3 MS |
274 | } |
275 | ||
5fd56512 MP |
276 | return 0; |
277 | ||
278 | fail: | |
279 | (void) unlink(u->state_file); | |
280 | ||
281 | if (temp_path) | |
282 | (void) unlink(temp_path); | |
663996b3 | 283 | |
5fd56512 | 284 | return log_error_errno(r, "Failed to save user data %s: %m", u->state_file); |
663996b3 MS |
285 | } |
286 | ||
86f210e9 MP |
287 | int user_save(User *u) { |
288 | assert(u); | |
289 | ||
290 | if (!u->started) | |
291 | return 0; | |
292 | ||
293 | return user_save_internal (u); | |
294 | } | |
295 | ||
663996b3 | 296 | int user_load(User *u) { |
14228c0d | 297 | _cleanup_free_ char *display = NULL, *realtime = NULL, *monotonic = NULL; |
663996b3 | 298 | Session *s = NULL; |
14228c0d | 299 | int r; |
663996b3 MS |
300 | |
301 | assert(u); | |
302 | ||
303 | r = parse_env_file(u->state_file, NEWLINE, | |
14228c0d | 304 | "SERVICE_JOB", &u->service_job, |
14228c0d MB |
305 | "SLICE_JOB", &u->slice_job, |
306 | "DISPLAY", &display, | |
307 | "REALTIME", &realtime, | |
308 | "MONOTONIC", &monotonic, | |
663996b3 MS |
309 | NULL); |
310 | if (r < 0) { | |
663996b3 MS |
311 | if (r == -ENOENT) |
312 | return 0; | |
313 | ||
f47781d8 | 314 | log_error_errno(r, "Failed to read %s: %m", u->state_file); |
663996b3 MS |
315 | return r; |
316 | } | |
317 | ||
14228c0d | 318 | if (display) |
663996b3 | 319 | s = hashmap_get(u->manager->sessions, display); |
663996b3 MS |
320 | |
321 | if (s && s->display && display_is_local(s->display)) | |
322 | u->display = s; | |
323 | ||
14228c0d MB |
324 | if (realtime) { |
325 | unsigned long long l; | |
326 | if (sscanf(realtime, "%llu", &l) > 0) | |
327 | u->timestamp.realtime = l; | |
328 | } | |
329 | ||
330 | if (monotonic) { | |
331 | unsigned long long l; | |
332 | if (sscanf(monotonic, "%llu", &l) > 0) | |
333 | u->timestamp.monotonic = l; | |
334 | } | |
335 | ||
663996b3 MS |
336 | return r; |
337 | } | |
338 | ||
339 | static int user_mkdir_runtime_path(User *u) { | |
663996b3 MS |
340 | int r; |
341 | ||
342 | assert(u); | |
343 | ||
344 | r = mkdir_safe_label("/run/user", 0755, 0, 0); | |
f47781d8 MP |
345 | if (r < 0) |
346 | return log_error_errno(r, "Failed to create /run/user: %m"); | |
663996b3 | 347 | |
db2df898 | 348 | if (path_is_mount_point(u->runtime_path, 0) <= 0) { |
60f067b4 JS |
349 | _cleanup_free_ char *t = NULL; |
350 | ||
db2df898 | 351 | (void) mkdir_label(u->runtime_path, 0700); |
60f067b4 | 352 | |
5eef597e MP |
353 | if (mac_smack_use()) |
354 | r = asprintf(&t, "mode=0700,smackfsroot=*,uid=" UID_FMT ",gid=" GID_FMT ",size=%zu", u->uid, u->gid, u->manager->runtime_dir_size); | |
355 | else | |
356 | r = asprintf(&t, "mode=0700,uid=" UID_FMT ",gid=" GID_FMT ",size=%zu", u->uid, u->gid, u->manager->runtime_dir_size); | |
5eef597e | 357 | if (r < 0) { |
60f067b4 JS |
358 | r = log_oom(); |
359 | goto fail; | |
360 | } | |
361 | ||
db2df898 | 362 | r = mount("tmpfs", u->runtime_path, "tmpfs", MS_NODEV|MS_NOSUID, t); |
60f067b4 | 363 | if (r < 0) { |
e735f4d4 | 364 | if (errno != EPERM) { |
db2df898 | 365 | r = log_error_errno(errno, "Failed to mount per-user tmpfs directory %s: %m", u->runtime_path); |
e735f4d4 MP |
366 | goto fail; |
367 | } | |
368 | ||
369 | /* Lacking permissions, maybe | |
370 | * CAP_SYS_ADMIN-less container? In this case, | |
371 | * just use a normal directory. */ | |
372 | ||
db2df898 | 373 | r = chmod_and_chown(u->runtime_path, 0700, u->uid, u->gid); |
e735f4d4 MP |
374 | if (r < 0) { |
375 | log_error_errno(r, "Failed to change runtime directory ownership and mode: %m"); | |
376 | goto fail; | |
377 | } | |
60f067b4 | 378 | } |
86f210e9 | 379 | |
db2df898 | 380 | r = label_fix(u->runtime_path, false, false); |
86f210e9 | 381 | if (r < 0) |
db2df898 | 382 | log_warning_errno(r, "Failed to fix label of '%s', ignoring: %m", u->runtime_path); |
663996b3 MS |
383 | } |
384 | ||
663996b3 | 385 | return 0; |
60f067b4 JS |
386 | |
387 | fail: | |
db2df898 MP |
388 | /* Try to clean up, but ignore errors */ |
389 | (void) rmdir(u->runtime_path); | |
60f067b4 | 390 | return r; |
663996b3 MS |
391 | } |
392 | ||
14228c0d | 393 | static int user_start_slice(User *u) { |
4c89c718 | 394 | _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; |
db2df898 | 395 | const char *description; |
14228c0d | 396 | char *job; |
663996b3 MS |
397 | int r; |
398 | ||
399 | assert(u); | |
400 | ||
db2df898 MP |
401 | u->slice_job = mfree(u->slice_job); |
402 | description = strjoina("User Slice of ", u->name); | |
403 | ||
404 | r = manager_start_slice( | |
405 | u->manager, | |
406 | u->slice, | |
407 | description, | |
408 | "systemd-logind.service", | |
409 | "systemd-user-sessions.service", | |
410 | u->manager->user_tasks_max, | |
411 | &error, | |
412 | &job); | |
4c89c718 | 413 | if (r >= 0) |
db2df898 | 414 | u->slice_job = job; |
4c89c718 MP |
415 | else if (!sd_bus_error_has_name(&error, BUS_ERROR_UNIT_EXISTS)) |
416 | /* we don't fail due to this, let's try to continue */ | |
417 | log_error_errno(r, "Failed to start user slice %s, ignoring: %s (%s)", | |
418 | u->slice, bus_error_message(&error, r), error.name); | |
663996b3 | 419 | |
663996b3 MS |
420 | return 0; |
421 | } | |
422 | ||
423 | static int user_start_service(User *u) { | |
4c89c718 | 424 | _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; |
14228c0d MB |
425 | char *job; |
426 | int r; | |
427 | ||
663996b3 MS |
428 | assert(u); |
429 | ||
db2df898 | 430 | u->service_job = mfree(u->service_job); |
14228c0d | 431 | |
db2df898 MP |
432 | r = manager_start_unit( |
433 | u->manager, | |
434 | u->service, | |
435 | &error, | |
436 | &job); | |
437 | if (r < 0) { | |
438 | /* we don't fail due to this, let's try to continue */ | |
439 | log_error_errno(r, "Failed to start user service, ignoring: %s", bus_error_message(&error, r)); | |
440 | } else { | |
441 | u->service_job = job; | |
14228c0d MB |
442 | } |
443 | ||
663996b3 MS |
444 | return 0; |
445 | } | |
446 | ||
447 | int user_start(User *u) { | |
448 | int r; | |
449 | ||
450 | assert(u); | |
451 | ||
db2df898 | 452 | if (u->started && !u->stopping) |
663996b3 MS |
453 | return 0; |
454 | ||
db2df898 MP |
455 | /* |
456 | * If u->stopping is set, the user is marked for removal and the slice | |
457 | * and service stop-jobs are queued. We have to clear that flag before | |
458 | * queing the start-jobs again. If they succeed, the user object can be | |
459 | * re-used just fine (pid1 takes care of job-ordering and proper | |
460 | * restart), but if they fail, we want to force another user_stop() so | |
461 | * possibly pending units are stopped. | |
462 | * Note that we don't clear u->started, as we have no clue what state | |
463 | * the user is in on failure here. Hence, we pretend the user is | |
464 | * running so it will be properly taken down by GC. However, we clearly | |
465 | * return an error from user_start() in that case, so no further | |
466 | * reference to the user is taken. | |
467 | */ | |
468 | u->stopping = false; | |
469 | ||
470 | if (!u->started) { | |
471 | log_debug("New user %s logged in.", u->name); | |
472 | ||
473 | /* Make XDG_RUNTIME_DIR */ | |
474 | r = user_mkdir_runtime_path(u); | |
475 | if (r < 0) | |
476 | return r; | |
477 | } | |
663996b3 MS |
478 | |
479 | /* Create cgroup */ | |
14228c0d | 480 | r = user_start_slice(u); |
663996b3 MS |
481 | if (r < 0) |
482 | return r; | |
483 | ||
86f210e9 MP |
484 | /* Save the user data so far, because pam_systemd will read the |
485 | * XDG_RUNTIME_DIR out of it while starting up systemd --user. | |
486 | * We need to do user_save_internal() because we have not | |
487 | * "officially" started yet. */ | |
488 | user_save_internal(u); | |
489 | ||
663996b3 MS |
490 | /* Spawn user systemd */ |
491 | r = user_start_service(u); | |
492 | if (r < 0) | |
493 | return r; | |
494 | ||
db2df898 MP |
495 | if (!u->started) { |
496 | if (!dual_timestamp_is_set(&u->timestamp)) | |
497 | dual_timestamp_get(&u->timestamp); | |
498 | user_send_signal(u, true); | |
499 | u->started = true; | |
500 | } | |
663996b3 MS |
501 | |
502 | /* Save new user data */ | |
503 | user_save(u); | |
504 | ||
663996b3 MS |
505 | return 0; |
506 | } | |
507 | ||
14228c0d | 508 | static int user_stop_slice(User *u) { |
4c89c718 | 509 | _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; |
14228c0d MB |
510 | char *job; |
511 | int r; | |
663996b3 | 512 | |
663996b3 MS |
513 | assert(u); |
514 | ||
14228c0d MB |
515 | r = manager_stop_unit(u->manager, u->slice, &error, &job); |
516 | if (r < 0) { | |
60f067b4 | 517 | log_error("Failed to stop user slice: %s", bus_error_message(&error, r)); |
14228c0d MB |
518 | return r; |
519 | } | |
663996b3 | 520 | |
14228c0d MB |
521 | free(u->slice_job); |
522 | u->slice_job = job; | |
663996b3 | 523 | |
14228c0d | 524 | return r; |
663996b3 MS |
525 | } |
526 | ||
14228c0d | 527 | static int user_stop_service(User *u) { |
4c89c718 | 528 | _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; |
14228c0d | 529 | char *job; |
663996b3 | 530 | int r; |
663996b3 MS |
531 | |
532 | assert(u); | |
533 | ||
14228c0d MB |
534 | r = manager_stop_unit(u->manager, u->service, &error, &job); |
535 | if (r < 0) { | |
60f067b4 | 536 | log_error("Failed to stop user service: %s", bus_error_message(&error, r)); |
14228c0d | 537 | return r; |
663996b3 MS |
538 | } |
539 | ||
14228c0d MB |
540 | free(u->service_job); |
541 | u->service_job = job; | |
663996b3 MS |
542 | |
543 | return r; | |
544 | } | |
545 | ||
546 | static int user_remove_runtime_path(User *u) { | |
547 | int r; | |
548 | ||
549 | assert(u); | |
550 | ||
e3bff60a | 551 | r = rm_rf(u->runtime_path, 0); |
60f067b4 | 552 | if (r < 0) |
f47781d8 | 553 | log_error_errno(r, "Failed to remove runtime directory %s: %m", u->runtime_path); |
60f067b4 | 554 | |
e735f4d4 MP |
555 | /* Ignore cases where the directory isn't mounted, as that's |
556 | * quite possible, if we lacked the permissions to mount | |
557 | * something */ | |
558 | r = umount2(u->runtime_path, MNT_DETACH); | |
559 | if (r < 0 && errno != EINVAL && errno != ENOENT) | |
f47781d8 | 560 | log_error_errno(errno, "Failed to unmount user runtime directory %s: %m", u->runtime_path); |
60f067b4 | 561 | |
e3bff60a | 562 | r = rm_rf(u->runtime_path, REMOVE_ROOT); |
663996b3 | 563 | if (r < 0) |
f47781d8 | 564 | log_error_errno(r, "Failed to remove runtime directory %s: %m", u->runtime_path); |
663996b3 | 565 | |
663996b3 MS |
566 | return r; |
567 | } | |
568 | ||
60f067b4 | 569 | int user_stop(User *u, bool force) { |
663996b3 MS |
570 | Session *s; |
571 | int r = 0, k; | |
572 | assert(u); | |
573 | ||
60f067b4 JS |
574 | /* Stop jobs have already been queued */ |
575 | if (u->stopping) { | |
576 | user_save(u); | |
577 | return r; | |
578 | } | |
579 | ||
663996b3 | 580 | LIST_FOREACH(sessions_by_user, s, u->sessions) { |
60f067b4 | 581 | k = session_stop(s, force); |
663996b3 MS |
582 | if (k < 0) |
583 | r = k; | |
584 | } | |
585 | ||
586 | /* Kill systemd */ | |
587 | k = user_stop_service(u); | |
588 | if (k < 0) | |
589 | r = k; | |
590 | ||
591 | /* Kill cgroup */ | |
14228c0d | 592 | k = user_stop_slice(u); |
663996b3 MS |
593 | if (k < 0) |
594 | r = k; | |
595 | ||
60f067b4 JS |
596 | u->stopping = true; |
597 | ||
14228c0d MB |
598 | user_save(u); |
599 | ||
600 | return r; | |
601 | } | |
602 | ||
603 | int user_finalize(User *u) { | |
604 | Session *s; | |
605 | int r = 0, k; | |
606 | ||
607 | assert(u); | |
608 | ||
609 | if (u->started) | |
610 | log_debug("User %s logged out.", u->name); | |
611 | ||
612 | LIST_FOREACH(sessions_by_user, s, u->sessions) { | |
613 | k = session_finalize(s); | |
614 | if (k < 0) | |
615 | r = k; | |
616 | } | |
617 | ||
663996b3 MS |
618 | /* Kill XDG_RUNTIME_DIR */ |
619 | k = user_remove_runtime_path(u); | |
620 | if (k < 0) | |
621 | r = k; | |
622 | ||
60f067b4 JS |
623 | /* Clean SysV + POSIX IPC objects */ |
624 | if (u->manager->remove_ipc) { | |
625 | k = clean_ipc(u->uid); | |
626 | if (k < 0) | |
627 | r = k; | |
628 | } | |
629 | ||
663996b3 MS |
630 | unlink(u->state_file); |
631 | user_add_to_gc_queue(u); | |
632 | ||
14228c0d | 633 | if (u->started) { |
663996b3 | 634 | user_send_signal(u, false); |
14228c0d MB |
635 | u->started = false; |
636 | } | |
663996b3 MS |
637 | |
638 | return r; | |
639 | } | |
640 | ||
641 | int user_get_idle_hint(User *u, dual_timestamp *t) { | |
642 | Session *s; | |
643 | bool idle_hint = true; | |
86f210e9 | 644 | dual_timestamp ts = DUAL_TIMESTAMP_NULL; |
663996b3 MS |
645 | |
646 | assert(u); | |
647 | ||
648 | LIST_FOREACH(sessions_by_user, s, u->sessions) { | |
649 | dual_timestamp k; | |
650 | int ih; | |
651 | ||
652 | ih = session_get_idle_hint(s, &k); | |
653 | if (ih < 0) | |
654 | return ih; | |
655 | ||
656 | if (!ih) { | |
657 | if (!idle_hint) { | |
658 | if (k.monotonic < ts.monotonic) | |
659 | ts = k; | |
660 | } else { | |
661 | idle_hint = false; | |
662 | ts = k; | |
663 | } | |
664 | } else if (idle_hint) { | |
665 | ||
666 | if (k.monotonic > ts.monotonic) | |
667 | ts = k; | |
668 | } | |
669 | } | |
670 | ||
671 | if (t) | |
672 | *t = ts; | |
673 | ||
674 | return idle_hint; | |
675 | } | |
676 | ||
60f067b4 JS |
677 | int user_check_linger_file(User *u) { |
678 | _cleanup_free_ char *cc = NULL; | |
679 | char *p = NULL; | |
663996b3 | 680 | |
60f067b4 JS |
681 | cc = cescape(u->name); |
682 | if (!cc) | |
663996b3 MS |
683 | return -ENOMEM; |
684 | ||
e735f4d4 | 685 | p = strjoina("/var/lib/systemd/linger/", cc); |
663996b3 | 686 | |
60f067b4 | 687 | return access(p, F_OK) >= 0; |
663996b3 MS |
688 | } |
689 | ||
60f067b4 | 690 | bool user_check_gc(User *u, bool drop_not_started) { |
663996b3 MS |
691 | assert(u); |
692 | ||
693 | if (drop_not_started && !u->started) | |
60f067b4 | 694 | return false; |
663996b3 MS |
695 | |
696 | if (u->sessions) | |
60f067b4 | 697 | return true; |
663996b3 MS |
698 | |
699 | if (user_check_linger_file(u) > 0) | |
60f067b4 | 700 | return true; |
663996b3 | 701 | |
60f067b4 JS |
702 | if (u->slice_job && manager_job_is_active(u->manager, u->slice_job)) |
703 | return true; | |
14228c0d | 704 | |
60f067b4 JS |
705 | if (u->service_job && manager_job_is_active(u->manager, u->service_job)) |
706 | return true; | |
663996b3 | 707 | |
60f067b4 | 708 | return false; |
663996b3 MS |
709 | } |
710 | ||
711 | void user_add_to_gc_queue(User *u) { | |
712 | assert(u); | |
713 | ||
714 | if (u->in_gc_queue) | |
715 | return; | |
716 | ||
60f067b4 | 717 | LIST_PREPEND(gc_queue, u->manager->user_gc_queue, u); |
663996b3 MS |
718 | u->in_gc_queue = true; |
719 | } | |
720 | ||
721 | UserState user_get_state(User *u) { | |
722 | Session *i; | |
663996b3 MS |
723 | |
724 | assert(u); | |
725 | ||
60f067b4 | 726 | if (u->stopping) |
14228c0d MB |
727 | return USER_CLOSING; |
728 | ||
86f210e9 | 729 | if (!u->started || u->slice_job || u->service_job) |
14228c0d | 730 | return USER_OPENING; |
663996b3 | 731 | |
60f067b4 JS |
732 | if (u->sessions) { |
733 | bool all_closing = true; | |
734 | ||
735 | LIST_FOREACH(sessions_by_user, i, u->sessions) { | |
736 | SessionState state; | |
737 | ||
738 | state = session_get_state(i); | |
739 | if (state == SESSION_ACTIVE) | |
740 | return USER_ACTIVE; | |
741 | if (state != SESSION_CLOSING) | |
742 | all_closing = false; | |
743 | } | |
663996b3 | 744 | |
663996b3 | 745 | return all_closing ? USER_CLOSING : USER_ONLINE; |
60f067b4 | 746 | } |
663996b3 MS |
747 | |
748 | if (user_check_linger_file(u) > 0) | |
749 | return USER_LINGERING; | |
750 | ||
751 | return USER_CLOSING; | |
752 | } | |
753 | ||
754 | int user_kill(User *u, int signo) { | |
663996b3 MS |
755 | assert(u); |
756 | ||
14228c0d | 757 | return manager_kill_unit(u->manager, u->slice, KILL_ALL, signo, NULL); |
663996b3 MS |
758 | } |
759 | ||
86f210e9 MP |
760 | static bool elect_display_filter(Session *s) { |
761 | /* Return true if the session is a candidate for the user’s ‘primary | |
762 | * session’ or ‘display’. */ | |
763 | assert(s); | |
764 | ||
765 | return (s->class == SESSION_USER && !s->stopping); | |
766 | } | |
767 | ||
768 | static int elect_display_compare(Session *s1, Session *s2) { | |
769 | /* Indexed by SessionType. Lower numbers mean more preferred. */ | |
770 | const int type_ranks[_SESSION_TYPE_MAX] = { | |
771 | [SESSION_UNSPECIFIED] = 0, | |
772 | [SESSION_TTY] = -2, | |
773 | [SESSION_X11] = -3, | |
774 | [SESSION_WAYLAND] = -3, | |
775 | [SESSION_MIR] = -3, | |
776 | [SESSION_WEB] = -1, | |
777 | }; | |
778 | ||
779 | /* Calculate the partial order relationship between s1 and s2, | |
780 | * returning < 0 if s1 is preferred as the user’s ‘primary session’, | |
781 | * 0 if s1 and s2 are equally preferred or incomparable, or > 0 if s2 | |
782 | * is preferred. | |
783 | * | |
784 | * s1 or s2 may be NULL. */ | |
785 | if (!s1 && !s2) | |
786 | return 0; | |
787 | ||
788 | if ((s1 == NULL) != (s2 == NULL)) | |
789 | return (s1 == NULL) - (s2 == NULL); | |
790 | ||
791 | if (s1->stopping != s2->stopping) | |
792 | return s1->stopping - s2->stopping; | |
793 | ||
794 | if ((s1->class != SESSION_USER) != (s2->class != SESSION_USER)) | |
795 | return (s1->class != SESSION_USER) - (s2->class != SESSION_USER); | |
796 | ||
797 | if ((s1->type == _SESSION_TYPE_INVALID) != (s2->type == _SESSION_TYPE_INVALID)) | |
798 | return (s1->type == _SESSION_TYPE_INVALID) - (s2->type == _SESSION_TYPE_INVALID); | |
799 | ||
800 | if (s1->type != s2->type) | |
801 | return type_ranks[s1->type] - type_ranks[s2->type]; | |
802 | ||
803 | return 0; | |
804 | } | |
805 | ||
60f067b4 | 806 | void user_elect_display(User *u) { |
86f210e9 | 807 | Session *s; |
60f067b4 JS |
808 | |
809 | assert(u); | |
810 | ||
811 | /* This elects a primary session for each user, which we call | |
812 | * the "display". We try to keep the assignment stable, but we | |
813 | * "upgrade" to better choices. */ | |
86f210e9 | 814 | log_debug("Electing new display for user %s", u->name); |
60f067b4 JS |
815 | |
816 | LIST_FOREACH(sessions_by_user, s, u->sessions) { | |
86f210e9 MP |
817 | if (!elect_display_filter(s)) { |
818 | log_debug("Ignoring session %s", s->id); | |
60f067b4 | 819 | continue; |
86f210e9 | 820 | } |
60f067b4 | 821 | |
86f210e9 MP |
822 | if (elect_display_compare(s, u->display) < 0) { |
823 | log_debug("Choosing session %s in preference to %s", s->id, u->display ? u->display->id : "-"); | |
824 | u->display = s; | |
825 | } | |
5eef597e | 826 | } |
60f067b4 JS |
827 | } |
828 | ||
663996b3 MS |
829 | static const char* const user_state_table[_USER_STATE_MAX] = { |
830 | [USER_OFFLINE] = "offline", | |
14228c0d | 831 | [USER_OPENING] = "opening", |
663996b3 MS |
832 | [USER_LINGERING] = "lingering", |
833 | [USER_ONLINE] = "online", | |
834 | [USER_ACTIVE] = "active", | |
835 | [USER_CLOSING] = "closing" | |
836 | }; | |
837 | ||
838 | DEFINE_STRING_TABLE_LOOKUP(user_state, UserState); | |
60f067b4 JS |
839 | |
840 | int config_parse_tmpfs_size( | |
841 | const char* unit, | |
842 | const char *filename, | |
843 | unsigned line, | |
844 | const char *section, | |
845 | unsigned section_line, | |
846 | const char *lvalue, | |
847 | int ltype, | |
848 | const char *rvalue, | |
849 | void *data, | |
850 | void *userdata) { | |
851 | ||
852 | size_t *sz = data; | |
853 | const char *e; | |
854 | int r; | |
855 | ||
856 | assert(filename); | |
857 | assert(lvalue); | |
858 | assert(rvalue); | |
859 | assert(data); | |
860 | ||
861 | e = endswith(rvalue, "%"); | |
862 | if (e) { | |
863 | unsigned long ul; | |
864 | char *f; | |
865 | ||
866 | errno = 0; | |
867 | ul = strtoul(rvalue, &f, 10); | |
4c89c718 | 868 | if (errno > 0 || f != e) { |
6300502b | 869 | log_syntax(unit, LOG_ERR, filename, line, errno, "Failed to parse percentage value, ignoring: %s", rvalue); |
60f067b4 JS |
870 | return 0; |
871 | } | |
872 | ||
873 | if (ul <= 0 || ul >= 100) { | |
6300502b | 874 | log_syntax(unit, LOG_ERR, filename, line, 0, "Percentage value out of range, ignoring: %s", rvalue); |
60f067b4 JS |
875 | return 0; |
876 | } | |
877 | ||
878 | *sz = PAGE_ALIGN((size_t) ((physical_memory() * (uint64_t) ul) / (uint64_t) 100)); | |
879 | } else { | |
6300502b | 880 | uint64_t k; |
60f067b4 | 881 | |
6300502b MP |
882 | r = parse_size(rvalue, 1024, &k); |
883 | if (r < 0 || (uint64_t) (size_t) k != k) { | |
884 | log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse size value, ignoring: %s", rvalue); | |
60f067b4 JS |
885 | return 0; |
886 | } | |
887 | ||
6300502b | 888 | *sz = PAGE_ALIGN((size_t) k); |
60f067b4 JS |
889 | } |
890 | ||
891 | return 0; | |
892 | } |