Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <string.h>
5 : : #include <unistd.h>
6 : :
7 : : #include "alloc-util.h"
8 : : #include "bus-common-errors.h"
9 : : #include "bus-error.h"
10 : : #include "bus-util.h"
11 : : #include "cgroup-util.h"
12 : : #include "clean-ipc.h"
13 : : #include "env-file.h"
14 : : #include "escape.h"
15 : : #include "fd-util.h"
16 : : #include "fileio.h"
17 : : #include "format-util.h"
18 : : #include "fs-util.h"
19 : : #include "hashmap.h"
20 : : #include "label.h"
21 : : #include "limits-util.h"
22 : : #include "logind-dbus.h"
23 : : #include "logind-user.h"
24 : : #include "logind-user-dbus.h"
25 : : #include "mkdir.h"
26 : : #include "parse-util.h"
27 : : #include "path-util.h"
28 : : #include "rm-rf.h"
29 : : #include "serialize.h"
30 : : #include "special.h"
31 : : #include "stdio-util.h"
32 : : #include "string-table.h"
33 : : #include "strv.h"
34 : : #include "tmpfile-util.h"
35 : : #include "unit-name.h"
36 : : #include "user-util.h"
37 : : #include "util.h"
38 : :
39 : 0 : int user_new(User **ret,
40 : : Manager *m,
41 : : uid_t uid,
42 : : gid_t gid,
43 : : const char *name,
44 : : const char *home) {
45 : :
46 : 0 : _cleanup_(user_freep) User *u = NULL;
47 : : char lu[DECIMAL_STR_MAX(uid_t) + 1];
48 : : int r;
49 : :
50 [ # # ]: 0 : assert(ret);
51 [ # # ]: 0 : assert(m);
52 [ # # ]: 0 : assert(name);
53 : :
54 : 0 : u = new(User, 1);
55 [ # # ]: 0 : if (!u)
56 : 0 : return -ENOMEM;
57 : :
58 : 0 : *u = (User) {
59 : : .manager = m,
60 : : .uid = uid,
61 : : .gid = gid,
62 : : .last_session_timestamp = USEC_INFINITY,
63 : : };
64 : :
65 : 0 : u->name = strdup(name);
66 [ # # ]: 0 : if (!u->name)
67 : 0 : return -ENOMEM;
68 : :
69 : 0 : u->home = strdup(home);
70 [ # # ]: 0 : if (!u->home)
71 : 0 : return -ENOMEM;
72 : :
73 : 0 : path_simplify(u->home, true);
74 : :
75 [ # # ]: 0 : if (asprintf(&u->state_file, "/run/systemd/users/"UID_FMT, uid) < 0)
76 : 0 : return -ENOMEM;
77 : :
78 [ # # ]: 0 : if (asprintf(&u->runtime_path, "/run/user/"UID_FMT, uid) < 0)
79 : 0 : return -ENOMEM;
80 : :
81 [ # # ]: 0 : xsprintf(lu, UID_FMT, uid);
82 : 0 : r = slice_build_subslice(SPECIAL_USER_SLICE, lu, &u->slice);
83 [ # # ]: 0 : if (r < 0)
84 : 0 : return r;
85 : :
86 : 0 : r = unit_name_build("user", lu, ".service", &u->service);
87 [ # # ]: 0 : if (r < 0)
88 : 0 : return r;
89 : :
90 : 0 : r = unit_name_build("user-runtime-dir", lu, ".service", &u->runtime_dir_service);
91 [ # # ]: 0 : if (r < 0)
92 : 0 : return r;
93 : :
94 : 0 : r = hashmap_put(m->users, UID_TO_PTR(uid), u);
95 [ # # ]: 0 : if (r < 0)
96 : 0 : return r;
97 : :
98 : 0 : r = hashmap_put(m->user_units, u->slice, u);
99 [ # # ]: 0 : if (r < 0)
100 : 0 : return r;
101 : :
102 : 0 : r = hashmap_put(m->user_units, u->service, u);
103 [ # # ]: 0 : if (r < 0)
104 : 0 : return r;
105 : :
106 : 0 : r = hashmap_put(m->user_units, u->runtime_dir_service, u);
107 [ # # ]: 0 : if (r < 0)
108 : 0 : return r;
109 : :
110 : 0 : *ret = TAKE_PTR(u);
111 : 0 : return 0;
112 : : }
113 : :
114 : 0 : User *user_free(User *u) {
115 [ # # ]: 0 : if (!u)
116 : 0 : return NULL;
117 : :
118 [ # # ]: 0 : if (u->in_gc_queue)
119 [ # # # # : 0 : LIST_REMOVE(gc_queue, u->manager->user_gc_queue, u);
# # # # ]
120 : :
121 [ # # ]: 0 : while (u->sessions)
122 : 0 : session_free(u->sessions);
123 : :
124 [ # # ]: 0 : if (u->service)
125 : 0 : hashmap_remove_value(u->manager->user_units, u->service, u);
126 : :
127 [ # # ]: 0 : if (u->runtime_dir_service)
128 : 0 : hashmap_remove_value(u->manager->user_units, u->runtime_dir_service, u);
129 : :
130 [ # # ]: 0 : if (u->slice)
131 : 0 : hashmap_remove_value(u->manager->user_units, u->slice, u);
132 : :
133 : 0 : hashmap_remove_value(u->manager->users, UID_TO_PTR(u->uid), u);
134 : :
135 : 0 : (void) sd_event_source_unref(u->timer_event_source);
136 : :
137 : 0 : u->service_job = mfree(u->service_job);
138 : :
139 : 0 : u->service = mfree(u->service);
140 : 0 : u->runtime_dir_service = mfree(u->runtime_dir_service);
141 : 0 : u->slice = mfree(u->slice);
142 : 0 : u->runtime_path = mfree(u->runtime_path);
143 : 0 : u->state_file = mfree(u->state_file);
144 : 0 : u->name = mfree(u->name);
145 : 0 : u->home = mfree(u->home);
146 : :
147 : 0 : return mfree(u);
148 : : }
149 : :
150 : 0 : static int user_save_internal(User *u) {
151 : 0 : _cleanup_free_ char *temp_path = NULL;
152 : 0 : _cleanup_fclose_ FILE *f = NULL;
153 : : int r;
154 : :
155 [ # # ]: 0 : assert(u);
156 [ # # ]: 0 : assert(u->state_file);
157 : :
158 : 0 : r = mkdir_safe_label("/run/systemd/users", 0755, 0, 0, MKDIR_WARN_MODE);
159 [ # # ]: 0 : if (r < 0)
160 : 0 : goto fail;
161 : :
162 : 0 : r = fopen_temporary(u->state_file, &f, &temp_path);
163 [ # # ]: 0 : if (r < 0)
164 : 0 : goto fail;
165 : :
166 : 0 : (void) fchmod(fileno(f), 0644);
167 : :
168 : 0 : fprintf(f,
169 : : "# This is private data. Do not parse.\n"
170 : : "NAME=%s\n"
171 : : "STATE=%s\n" /* friendly user-facing state */
172 : : "STOPPING=%s\n", /* low-level state */
173 : : u->name,
174 : : user_state_to_string(user_get_state(u)),
175 : 0 : yes_no(u->stopping));
176 : :
177 : : /* LEGACY: no-one reads RUNTIME= anymore, drop it at some point */
178 [ # # ]: 0 : if (u->runtime_path)
179 : 0 : fprintf(f, "RUNTIME=%s\n", u->runtime_path);
180 : :
181 [ # # ]: 0 : if (u->service_job)
182 : 0 : fprintf(f, "SERVICE_JOB=%s\n", u->service_job);
183 : :
184 [ # # ]: 0 : if (u->display)
185 : 0 : fprintf(f, "DISPLAY=%s\n", u->display->id);
186 : :
187 [ # # ]: 0 : if (dual_timestamp_is_set(&u->timestamp))
188 : 0 : fprintf(f,
189 : : "REALTIME="USEC_FMT"\n"
190 : : "MONOTONIC="USEC_FMT"\n",
191 : : u->timestamp.realtime,
192 : : u->timestamp.monotonic);
193 : :
194 [ # # ]: 0 : if (u->last_session_timestamp != USEC_INFINITY)
195 : 0 : fprintf(f, "LAST_SESSION_TIMESTAMP=" USEC_FMT "\n",
196 : : u->last_session_timestamp);
197 : :
198 [ # # ]: 0 : if (u->sessions) {
199 : : Session *i;
200 : : bool first;
201 : :
202 : 0 : fputs("SESSIONS=", f);
203 : 0 : first = true;
204 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
205 [ # # ]: 0 : if (first)
206 : 0 : first = false;
207 : : else
208 : 0 : fputc(' ', f);
209 : :
210 : 0 : fputs(i->id, f);
211 : : }
212 : :
213 : 0 : fputs("\nSEATS=", f);
214 : 0 : first = true;
215 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
216 [ # # ]: 0 : if (!i->seat)
217 : 0 : continue;
218 : :
219 [ # # ]: 0 : if (first)
220 : 0 : first = false;
221 : : else
222 : 0 : fputc(' ', f);
223 : :
224 : 0 : fputs(i->seat->id, f);
225 : : }
226 : :
227 : 0 : fputs("\nACTIVE_SESSIONS=", f);
228 : 0 : first = true;
229 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
230 [ # # ]: 0 : if (!session_is_active(i))
231 : 0 : continue;
232 : :
233 [ # # ]: 0 : if (first)
234 : 0 : first = false;
235 : : else
236 : 0 : fputc(' ', f);
237 : :
238 : 0 : fputs(i->id, f);
239 : : }
240 : :
241 : 0 : fputs("\nONLINE_SESSIONS=", f);
242 : 0 : first = true;
243 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
244 [ # # ]: 0 : if (session_get_state(i) == SESSION_CLOSING)
245 : 0 : continue;
246 : :
247 [ # # ]: 0 : if (first)
248 : 0 : first = false;
249 : : else
250 : 0 : fputc(' ', f);
251 : :
252 : 0 : fputs(i->id, f);
253 : : }
254 : :
255 : 0 : fputs("\nACTIVE_SEATS=", f);
256 : 0 : first = true;
257 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
258 [ # # # # ]: 0 : if (!session_is_active(i) || !i->seat)
259 : 0 : continue;
260 : :
261 [ # # ]: 0 : if (first)
262 : 0 : first = false;
263 : : else
264 : 0 : fputc(' ', f);
265 : :
266 : 0 : fputs(i->seat->id, f);
267 : : }
268 : :
269 : 0 : fputs("\nONLINE_SEATS=", f);
270 : 0 : first = true;
271 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
272 [ # # # # ]: 0 : if (session_get_state(i) == SESSION_CLOSING || !i->seat)
273 : 0 : continue;
274 : :
275 [ # # ]: 0 : if (first)
276 : 0 : first = false;
277 : : else
278 : 0 : fputc(' ', f);
279 : :
280 : 0 : fputs(i->seat->id, f);
281 : : }
282 : 0 : fputc('\n', f);
283 : : }
284 : :
285 : 0 : r = fflush_and_check(f);
286 [ # # ]: 0 : if (r < 0)
287 : 0 : goto fail;
288 : :
289 [ # # ]: 0 : if (rename(temp_path, u->state_file) < 0) {
290 : 0 : r = -errno;
291 : 0 : goto fail;
292 : : }
293 : :
294 : 0 : return 0;
295 : :
296 : 0 : fail:
297 : 0 : (void) unlink(u->state_file);
298 : :
299 [ # # ]: 0 : if (temp_path)
300 : 0 : (void) unlink(temp_path);
301 : :
302 [ # # ]: 0 : return log_error_errno(r, "Failed to save user data %s: %m", u->state_file);
303 : : }
304 : :
305 : 0 : int user_save(User *u) {
306 [ # # ]: 0 : assert(u);
307 : :
308 [ # # ]: 0 : if (!u->started)
309 : 0 : return 0;
310 : :
311 : 0 : return user_save_internal(u);
312 : : }
313 : :
314 : 0 : int user_load(User *u) {
315 : 0 : _cleanup_free_ char *realtime = NULL, *monotonic = NULL, *stopping = NULL, *last_session_timestamp = NULL;
316 : : int r;
317 : :
318 [ # # ]: 0 : assert(u);
319 : :
320 : 0 : r = parse_env_file(NULL, u->state_file,
321 : : "SERVICE_JOB", &u->service_job,
322 : : "STOPPING", &stopping,
323 : : "REALTIME", &realtime,
324 : : "MONOTONIC", &monotonic,
325 : : "LAST_SESSION_TIMESTAMP", &last_session_timestamp);
326 [ # # ]: 0 : if (r == -ENOENT)
327 : 0 : return 0;
328 [ # # ]: 0 : if (r < 0)
329 [ # # ]: 0 : return log_error_errno(r, "Failed to read %s: %m", u->state_file);
330 : :
331 [ # # ]: 0 : if (stopping) {
332 : 0 : r = parse_boolean(stopping);
333 [ # # ]: 0 : if (r < 0)
334 [ # # ]: 0 : log_debug_errno(r, "Failed to parse 'STOPPING' boolean: %s", stopping);
335 : : else
336 : 0 : u->stopping = r;
337 : : }
338 : :
339 [ # # ]: 0 : if (realtime)
340 : 0 : (void) deserialize_usec(realtime, &u->timestamp.realtime);
341 [ # # ]: 0 : if (monotonic)
342 : 0 : (void) deserialize_usec(monotonic, &u->timestamp.monotonic);
343 [ # # ]: 0 : if (last_session_timestamp)
344 : 0 : (void) deserialize_usec(last_session_timestamp, &u->last_session_timestamp);
345 : :
346 : 0 : return 0;
347 : : }
348 : :
349 : 0 : static void user_start_service(User *u) {
350 : 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
351 : : int r;
352 : :
353 [ # # ]: 0 : assert(u);
354 : :
355 : : /* Start the service containing the "systemd --user" instance (user@.service). Note that we don't explicitly
356 : : * start the per-user slice or the systemd-runtime-dir@.service instance, as those are pulled in both by
357 : : * user@.service and the session scopes as dependencies. */
358 : :
359 : 0 : u->service_job = mfree(u->service_job);
360 : :
361 : 0 : r = manager_start_unit(u->manager, u->service, &error, &u->service_job);
362 [ # # ]: 0 : if (r < 0)
363 [ # # # # ]: 0 : log_full_errno(sd_bus_error_has_name(&error, BUS_ERROR_UNIT_MASKED) ? LOG_DEBUG : LOG_WARNING, r,
364 : : "Failed to start user service '%s', ignoring: %s", u->service, bus_error_message(&error, r));
365 : 0 : }
366 : :
367 : 0 : int user_start(User *u) {
368 [ # # ]: 0 : assert(u);
369 : :
370 [ # # # # ]: 0 : if (u->started && !u->stopping)
371 : 0 : return 0;
372 : :
373 : : /* If u->stopping is set, the user is marked for removal and service stop-jobs are queued. We have to clear
374 : : * that flag before queueing the start-jobs again. If they succeed, the user object can be re-used just fine
375 : : * (pid1 takes care of job-ordering and proper restart), but if they fail, we want to force another user_stop()
376 : : * so possibly pending units are stopped. */
377 : 0 : u->stopping = false;
378 : :
379 [ # # ]: 0 : if (!u->started)
380 [ # # ]: 0 : log_debug("Starting services for new user %s.", u->name);
381 : :
382 : : /* Save the user data so far, because pam_systemd will read the XDG_RUNTIME_DIR out of it while starting up
383 : : * systemd --user. We need to do user_save_internal() because we have not "officially" started yet. */
384 : 0 : user_save_internal(u);
385 : :
386 : : /* Start user@UID.service */
387 : 0 : user_start_service(u);
388 : :
389 [ # # ]: 0 : if (!u->started) {
390 [ # # ]: 0 : if (!dual_timestamp_is_set(&u->timestamp))
391 : 0 : dual_timestamp_get(&u->timestamp);
392 : 0 : user_send_signal(u, true);
393 : 0 : u->started = true;
394 : : }
395 : :
396 : : /* Save new user data */
397 : 0 : user_save(u);
398 : :
399 : 0 : return 0;
400 : : }
401 : :
402 : 0 : static void user_stop_service(User *u) {
403 : 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
404 : : int r;
405 : :
406 [ # # ]: 0 : assert(u);
407 [ # # ]: 0 : assert(u->service);
408 : :
409 : : /* The reverse of user_start_service(). Note that we only stop user@UID.service here, and let StopWhenUnneeded=
410 : : * deal with the slice and the user-runtime-dir@.service instance. */
411 : :
412 : 0 : u->service_job = mfree(u->service_job);
413 : :
414 : 0 : r = manager_stop_unit(u->manager, u->service, &error, &u->service_job);
415 [ # # ]: 0 : if (r < 0)
416 [ # # ]: 0 : log_warning_errno(r, "Failed to stop user service '%s', ignoring: %s", u->service, bus_error_message(&error, r));
417 : 0 : }
418 : :
419 : 0 : int user_stop(User *u, bool force) {
420 : : Session *s;
421 : 0 : int r = 0;
422 [ # # ]: 0 : assert(u);
423 : :
424 : : /* This is called whenever we begin with tearing down a user record. It's called in two cases: explicit API
425 : : * request to do so via the bus (in which case 'force' is true) and automatically due to GC, if there's no
426 : : * session left pinning it (in which case 'force' is false). Note that this just initiates tearing down of the
427 : : * user, the User object will remain in memory until user_finalize() is called, see below. */
428 : :
429 [ # # ]: 0 : if (!u->started)
430 : 0 : return 0;
431 : :
432 [ # # ]: 0 : if (u->stopping) { /* Stop jobs have already been queued */
433 : 0 : user_save(u);
434 : 0 : return 0;
435 : : }
436 : :
437 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, s, u->sessions) {
438 : : int k;
439 : :
440 : 0 : k = session_stop(s, force);
441 [ # # ]: 0 : if (k < 0)
442 : 0 : r = k;
443 : : }
444 : :
445 : 0 : user_stop_service(u);
446 : :
447 : 0 : u->stopping = true;
448 : :
449 : 0 : user_save(u);
450 : :
451 : 0 : return r;
452 : : }
453 : :
454 : 0 : int user_finalize(User *u) {
455 : : Session *s;
456 : 0 : int r = 0, k;
457 : :
458 [ # # ]: 0 : assert(u);
459 : :
460 : : /* Called when the user is really ready to be freed, i.e. when all unit stop jobs and suchlike for it are
461 : : * done. This is called as a result of an earlier user_done() when all jobs are completed. */
462 : :
463 [ # # ]: 0 : if (u->started)
464 [ # # ]: 0 : log_debug("User %s logged out.", u->name);
465 : :
466 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, s, u->sessions) {
467 : 0 : k = session_finalize(s);
468 [ # # ]: 0 : if (k < 0)
469 : 0 : r = k;
470 : : }
471 : :
472 : : /* Clean SysV + POSIX IPC objects, but only if this is not a system user. Background: in many setups cronjobs
473 : : * are run in full PAM and thus logind sessions, even if the code run doesn't belong to actual users but to
474 : : * system components. Since enable RemoveIPC= globally for all users, we need to be a bit careful with such
475 : : * cases, as we shouldn't accidentally remove a system service's IPC objects while it is running, just because
476 : : * a cronjob running as the same user just finished. Hence: exclude system users generally from IPC clean-up,
477 : : * and do it only for normal users. */
478 [ # # # # ]: 0 : if (u->manager->remove_ipc && !uid_is_system(u->uid)) {
479 : 0 : k = clean_ipc_by_uid(u->uid);
480 [ # # ]: 0 : if (k < 0)
481 : 0 : r = k;
482 : : }
483 : :
484 : 0 : (void) unlink(u->state_file);
485 : 0 : user_add_to_gc_queue(u);
486 : :
487 [ # # ]: 0 : if (u->started) {
488 : 0 : user_send_signal(u, false);
489 : 0 : u->started = false;
490 : : }
491 : :
492 : 0 : return r;
493 : : }
494 : :
495 : 0 : int user_get_idle_hint(User *u, dual_timestamp *t) {
496 : : Session *s;
497 : 0 : bool idle_hint = true;
498 : 0 : dual_timestamp ts = DUAL_TIMESTAMP_NULL;
499 : :
500 [ # # ]: 0 : assert(u);
501 : :
502 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, s, u->sessions) {
503 : : dual_timestamp k;
504 : : int ih;
505 : :
506 : 0 : ih = session_get_idle_hint(s, &k);
507 [ # # ]: 0 : if (ih < 0)
508 : 0 : return ih;
509 : :
510 [ # # ]: 0 : if (!ih) {
511 [ # # ]: 0 : if (!idle_hint) {
512 [ # # ]: 0 : if (k.monotonic < ts.monotonic)
513 : 0 : ts = k;
514 : : } else {
515 : 0 : idle_hint = false;
516 : 0 : ts = k;
517 : : }
518 [ # # ]: 0 : } else if (idle_hint) {
519 : :
520 [ # # ]: 0 : if (k.monotonic > ts.monotonic)
521 : 0 : ts = k;
522 : : }
523 : : }
524 : :
525 [ # # ]: 0 : if (t)
526 : 0 : *t = ts;
527 : :
528 : 0 : return idle_hint;
529 : : }
530 : :
531 : 0 : int user_check_linger_file(User *u) {
532 : 0 : _cleanup_free_ char *cc = NULL;
533 : 0 : char *p = NULL;
534 : :
535 : 0 : cc = cescape(u->name);
536 [ # # ]: 0 : if (!cc)
537 : 0 : return -ENOMEM;
538 : :
539 [ # # # # : 0 : p = strjoina("/var/lib/systemd/linger/", cc);
# # # # #
# # # ]
540 [ # # ]: 0 : if (access(p, F_OK) < 0) {
541 [ # # ]: 0 : if (errno != ENOENT)
542 : 0 : return -errno;
543 : :
544 : 0 : return false;
545 : : }
546 : :
547 : 0 : return true;
548 : : }
549 : :
550 : 0 : static bool user_unit_active(User *u) {
551 : : const char *i;
552 : : int r;
553 : :
554 [ # # ]: 0 : assert(u->service);
555 [ # # ]: 0 : assert(u->runtime_dir_service);
556 [ # # ]: 0 : assert(u->slice);
557 : :
558 [ # # ]: 0 : FOREACH_STRING(i, u->service, u->runtime_dir_service, u->slice) {
559 [ # # ]: 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
560 : :
561 : 0 : r = manager_unit_is_active(u->manager, i, &error);
562 [ # # ]: 0 : if (r < 0)
563 [ # # ]: 0 : log_debug_errno(r, "Failed to determine whether unit '%s' is active, ignoring: %s", u->service, bus_error_message(&error, r));
564 [ # # ]: 0 : if (r != 0)
565 : 0 : return true;
566 : : }
567 : :
568 : 0 : return false;
569 : : }
570 : :
571 : 0 : bool user_may_gc(User *u, bool drop_not_started) {
572 : : int r;
573 : :
574 [ # # ]: 0 : assert(u);
575 : :
576 [ # # # # ]: 0 : if (drop_not_started && !u->started)
577 : 0 : return true;
578 : :
579 [ # # ]: 0 : if (u->sessions)
580 : 0 : return false;
581 : :
582 [ # # ]: 0 : if (u->last_session_timestamp != USEC_INFINITY) {
583 : : /* All sessions have been closed. Let's see if we shall leave the user record around for a bit */
584 : :
585 [ # # ]: 0 : if (u->manager->user_stop_delay == USEC_INFINITY)
586 : 0 : return false; /* Leave it around forever! */
587 [ # # # # ]: 0 : if (u->manager->user_stop_delay > 0 &&
588 : 0 : now(CLOCK_MONOTONIC) < usec_add(u->last_session_timestamp, u->manager->user_stop_delay))
589 : 0 : return false; /* Leave it around for a bit longer. */
590 : : }
591 : :
592 : : /* Is this a user that shall stay around forever ("linger")? Before we say "no" to GC'ing for lingering users, let's check
593 : : * if any of the three units that we maintain for this user is still around. If none of them is,
594 : : * there's no need to keep this user around even if lingering is enabled. */
595 [ # # # # ]: 0 : if (user_check_linger_file(u) > 0 && user_unit_active(u))
596 : 0 : return false;
597 : :
598 : : /* Check if our job is still pending */
599 [ # # ]: 0 : if (u->service_job) {
600 [ # # ]: 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
601 : :
602 : 0 : r = manager_job_is_active(u->manager, u->service_job, &error);
603 [ # # ]: 0 : if (r < 0)
604 [ # # ]: 0 : log_debug_errno(r, "Failed to determine whether job '%s' is pending, ignoring: %s", u->service_job, bus_error_message(&error, r));
605 [ # # ]: 0 : if (r != 0)
606 : 0 : return false;
607 : : }
608 : :
609 : : /* Note that we don't care if the three units we manage for each user object are up or not, as we are managing
610 : : * their state rather than tracking it. */
611 : :
612 : 0 : return true;
613 : : }
614 : :
615 : 0 : void user_add_to_gc_queue(User *u) {
616 [ # # ]: 0 : assert(u);
617 : :
618 [ # # ]: 0 : if (u->in_gc_queue)
619 : 0 : return;
620 : :
621 [ # # # # ]: 0 : LIST_PREPEND(gc_queue, u->manager->user_gc_queue, u);
622 : 0 : u->in_gc_queue = true;
623 : : }
624 : :
625 : 0 : UserState user_get_state(User *u) {
626 : : Session *i;
627 : :
628 [ # # ]: 0 : assert(u);
629 : :
630 [ # # ]: 0 : if (u->stopping)
631 : 0 : return USER_CLOSING;
632 : :
633 [ # # # # ]: 0 : if (!u->started || u->service_job)
634 : 0 : return USER_OPENING;
635 : :
636 [ # # ]: 0 : if (u->sessions) {
637 : 0 : bool all_closing = true;
638 : :
639 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, i, u->sessions) {
640 : : SessionState state;
641 : :
642 : 0 : state = session_get_state(i);
643 [ # # ]: 0 : if (state == SESSION_ACTIVE)
644 : 0 : return USER_ACTIVE;
645 [ # # ]: 0 : if (state != SESSION_CLOSING)
646 : 0 : all_closing = false;
647 : : }
648 : :
649 [ # # ]: 0 : return all_closing ? USER_CLOSING : USER_ONLINE;
650 : : }
651 : :
652 [ # # # # ]: 0 : if (user_check_linger_file(u) > 0 && user_unit_active(u))
653 : 0 : return USER_LINGERING;
654 : :
655 : 0 : return USER_CLOSING;
656 : : }
657 : :
658 : 0 : int user_kill(User *u, int signo) {
659 [ # # ]: 0 : assert(u);
660 : :
661 : 0 : return manager_kill_unit(u->manager, u->slice, KILL_ALL, signo, NULL);
662 : : }
663 : :
664 : 0 : static bool elect_display_filter(Session *s) {
665 : : /* Return true if the session is a candidate for the user’s ‘primary session’ or ‘display’. */
666 [ # # ]: 0 : assert(s);
667 : :
668 [ # # # # : 0 : return IN_SET(s->class, SESSION_USER, SESSION_GREETER) && s->started && !s->stopping;
# # # # ]
669 : : }
670 : :
671 : 0 : static int elect_display_compare(Session *s1, Session *s2) {
672 : : /* Indexed by SessionType. Lower numbers mean more preferred. */
673 : : static const int type_ranks[_SESSION_TYPE_MAX] = {
674 : : [SESSION_UNSPECIFIED] = 0,
675 : : [SESSION_TTY] = -2,
676 : : [SESSION_X11] = -3,
677 : : [SESSION_WAYLAND] = -3,
678 : : [SESSION_MIR] = -3,
679 : : [SESSION_WEB] = -1,
680 : : };
681 : :
682 : : /* Calculate the partial order relationship between s1 and s2,
683 : : * returning < 0 if s1 is preferred as the user’s ‘primary session’,
684 : : * 0 if s1 and s2 are equally preferred or incomparable, or > 0 if s2
685 : : * is preferred.
686 : : *
687 : : * s1 or s2 may be NULL. */
688 [ # # # # ]: 0 : if (!s1 && !s2)
689 : 0 : return 0;
690 : :
691 [ # # ]: 0 : if ((s1 == NULL) != (s2 == NULL))
692 : 0 : return (s1 == NULL) - (s2 == NULL);
693 : :
694 [ # # ]: 0 : if (s1->stopping != s2->stopping)
695 : 0 : return s1->stopping - s2->stopping;
696 : :
697 [ # # ]: 0 : if ((s1->class != SESSION_USER) != (s2->class != SESSION_USER))
698 : 0 : return (s1->class != SESSION_USER) - (s2->class != SESSION_USER);
699 : :
700 [ # # ]: 0 : if ((s1->type == _SESSION_TYPE_INVALID) != (s2->type == _SESSION_TYPE_INVALID))
701 : 0 : return (s1->type == _SESSION_TYPE_INVALID) - (s2->type == _SESSION_TYPE_INVALID);
702 : :
703 [ # # ]: 0 : if (s1->type != s2->type)
704 : 0 : return type_ranks[s1->type] - type_ranks[s2->type];
705 : :
706 : 0 : return 0;
707 : : }
708 : :
709 : 0 : void user_elect_display(User *u) {
710 : : Session *s;
711 : :
712 [ # # ]: 0 : assert(u);
713 : :
714 : : /* This elects a primary session for each user, which we call the "display". We try to keep the assignment
715 : : * stable, but we "upgrade" to better choices. */
716 [ # # ]: 0 : log_debug("Electing new display for user %s", u->name);
717 : :
718 [ # # ]: 0 : LIST_FOREACH(sessions_by_user, s, u->sessions) {
719 [ # # ]: 0 : if (!elect_display_filter(s)) {
720 [ # # ]: 0 : log_debug("Ignoring session %s", s->id);
721 : 0 : continue;
722 : : }
723 : :
724 [ # # ]: 0 : if (elect_display_compare(s, u->display) < 0) {
725 [ # # # # ]: 0 : log_debug("Choosing session %s in preference to %s", s->id, u->display ? u->display->id : "-");
726 : 0 : u->display = s;
727 : : }
728 : : }
729 : 0 : }
730 : :
731 : 0 : static int user_stop_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
732 : 0 : User *u = userdata;
733 : :
734 [ # # ]: 0 : assert(u);
735 : 0 : user_add_to_gc_queue(u);
736 : :
737 : 0 : return 0;
738 : : }
739 : :
740 : 0 : void user_update_last_session_timer(User *u) {
741 : : int r;
742 : :
743 [ # # ]: 0 : assert(u);
744 : :
745 [ # # ]: 0 : if (u->sessions) {
746 : : /* There are sessions, turn off the timer */
747 : 0 : u->last_session_timestamp = USEC_INFINITY;
748 : 0 : u->timer_event_source = sd_event_source_unref(u->timer_event_source);
749 : 0 : return;
750 : : }
751 : :
752 [ # # ]: 0 : if (u->last_session_timestamp != USEC_INFINITY)
753 : 0 : return; /* Timer already started */
754 : :
755 : 0 : u->last_session_timestamp = now(CLOCK_MONOTONIC);
756 : :
757 [ # # ]: 0 : assert(!u->timer_event_source);
758 : :
759 [ # # # # ]: 0 : if (IN_SET(u->manager->user_stop_delay, 0, USEC_INFINITY))
760 : 0 : return;
761 : :
762 [ # # ]: 0 : if (sd_event_get_state(u->manager->event) == SD_EVENT_FINISHED) {
763 [ # # ]: 0 : log_debug("Not allocating user stop timeout, since we are already exiting.");
764 : 0 : return;
765 : : }
766 : :
767 : 0 : r = sd_event_add_time(u->manager->event,
768 : : &u->timer_event_source,
769 : : CLOCK_MONOTONIC,
770 : 0 : usec_add(u->last_session_timestamp, u->manager->user_stop_delay), 0,
771 : : user_stop_timeout_callback, u);
772 [ # # ]: 0 : if (r < 0)
773 [ # # ]: 0 : log_warning_errno(r, "Failed to enqueue user stop event source, ignoring: %m");
774 : :
775 [ # # ]: 0 : if (DEBUG_LOGGING) {
776 : : char s[FORMAT_TIMESPAN_MAX];
777 : :
778 [ # # ]: 0 : log_debug("Last session of user '%s' logged out, terminating user context in %s.",
779 : : u->name,
780 : : format_timespan(s, sizeof(s), u->manager->user_stop_delay, USEC_PER_MSEC));
781 : : }
782 : : }
783 : :
784 : : static const char* const user_state_table[_USER_STATE_MAX] = {
785 : : [USER_OFFLINE] = "offline",
786 : : [USER_OPENING] = "opening",
787 : : [USER_LINGERING] = "lingering",
788 : : [USER_ONLINE] = "online",
789 : : [USER_ACTIVE] = "active",
790 : : [USER_CLOSING] = "closing"
791 : : };
792 : :
793 [ + + + + ]: 64 : DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);
794 : :
795 : 0 : int config_parse_tmpfs_size(
796 : : const char* unit,
797 : : const char *filename,
798 : : unsigned line,
799 : : const char *section,
800 : : unsigned section_line,
801 : : const char *lvalue,
802 : : int ltype,
803 : : const char *rvalue,
804 : : void *data,
805 : : void *userdata) {
806 : :
807 : 0 : uint64_t *sz = data;
808 : : int r;
809 : :
810 [ # # ]: 0 : assert(filename);
811 [ # # ]: 0 : assert(lvalue);
812 [ # # ]: 0 : assert(rvalue);
813 [ # # ]: 0 : assert(data);
814 : :
815 : : /* First, try to parse as percentage */
816 : 0 : r = parse_permille(rvalue);
817 [ # # # # ]: 0 : if (r > 0 && r < 1000)
818 : 0 : *sz = physical_memory_scale(r, 1000U);
819 : : else {
820 : : uint64_t k;
821 : :
822 : : /* If the passed argument was not a percentage, or out of range, parse as byte size */
823 : :
824 : 0 : r = parse_size(rvalue, 1024, &k);
825 [ # # # # ]: 0 : if (r >= 0 && (k <= 0 || (uint64_t) (size_t) k != k))
826 : 0 : r = -ERANGE;
827 [ # # ]: 0 : if (r < 0) {
828 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse size value '%s', ignoring: %m", rvalue);
829 : 0 : return 0;
830 : : }
831 : :
832 : 0 : *sz = PAGE_ALIGN((size_t) k);
833 : : }
834 : :
835 : 0 : return 0;
836 : : }
837 : :
838 : 0 : int config_parse_compat_user_tasks_max(
839 : : const char *unit,
840 : : const char *filename,
841 : : unsigned line,
842 : : const char *section,
843 : : unsigned section_line,
844 : : const char *lvalue,
845 : : int ltype,
846 : : const char *rvalue,
847 : : void *data,
848 : : void *userdata) {
849 : :
850 [ # # ]: 0 : assert(filename);
851 [ # # ]: 0 : assert(lvalue);
852 [ # # ]: 0 : assert(rvalue);
853 [ # # ]: 0 : assert(data);
854 : :
855 [ # # ]: 0 : log_syntax(unit, LOG_NOTICE, filename, line, 0,
856 : : "Support for option %s= has been removed.",
857 : : lvalue);
858 [ # # ]: 0 : log_info("Hint: try creating /etc/systemd/system/user-.slice.d/50-limits.conf with:\n"
859 : : " [Slice]\n"
860 : : " TasksMax=%s",
861 : : rvalue);
862 : 0 : return 0;
863 : : }
|
