]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/dbus-manager.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
core: move pid watch/unwatch logic of the service manager to pidfd
[thirdparty/systemd.git] / src / core / dbus-manager.c
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
a7334b09 2
ea430986 3#include <errno.h>
eed67a30 4#include <sys/prctl.h>
ae57dad3 5#include <sys/statvfs.h>
871c44a7 6#include <unistd.h>
ea430986 7
b5efdb8a 8#include "alloc-util.h"
07630cea 9#include "architecture.h"
09bde77f 10#include "build.h"
07630cea 11#include "bus-common-errors.h"
40af3d02 12#include "bus-get-properties.h"
25141692 13#include "bus-log-control-api.h"
f461a28d 14#include "chase.h"
1257274a 15#include "confidential-virt.h"
6a818c3c 16#include "data-fd-util.h"
3a0f06c4 17#include "dbus-cgroup.h"
07630cea 18#include "dbus-execute.h"
2ea31e5b 19#include "dbus-job.h"
3ffd4af2 20#include "dbus-manager.h"
c20076a8 21#include "dbus-scope.h"
5e8deb94 22#include "dbus-service.h"
07630cea
LP		 23#include "dbus-unit.h"
24#include "dbus.h"
25#include "env-util.h"
3ffd4af2 26#include "fd-util.h"
0d39fa9c 27#include "fileio.h"
f97b34a6 28#include "format-util.h"
4da159bc 29#include "initrd-util.h"
07630cea
LP		 30#include "install.h"
31#include "log.h"
2a341bb9 32#include "manager-dump.h"
d58ad743 33#include "os-util.h"
ae57dad3 34#include "parse-util.h"
07630cea 35#include "path-util.h"
d4a402e4 36#include "process-util.h"
07630cea 37#include "selinux-access.h"
8fcde012 38#include "stat-util.h"
07630cea
LP		 39#include "string-util.h"
40#include "strv.h"
7ccbd1ae 41#include "syslog-util.h"
29206d46 42#include "user-util.h"
bdb577f5 43#include "version.h"
07630cea
LP		 44#include "virt.h"
45#include "watchdog.h"
ea430986 46
cb31470f
ZJS		 47/* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state
48 * there, and if we can't we'll fail badly. */
ae57dad3
LP		 49#define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
50
b3796dd8
JS		 51static UnitFileFlags unit_file_bools_to_flags(bool runtime, bool force) {
52 return (runtime ? UNIT_FILE_RUNTIME : 0) |
53 (force ? UNIT_FILE_FORCE : 0);
54}
55
afcfaa69 56BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_oom_policy, oom_policy, OOMPolicy);
c44a285c 57BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_emergency_action, emergency_action, EmergencyAction);
afcfaa69 58
681bd2c5 59static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version, "s", GIT_VERSION);
91b79ba8 60static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features, "s", systemd_features);
23c9a63a 61static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture, "s", architecture_to_string(uname_architecture()));
23c9a63a
YW		 62static BUS_DEFINE_PROPERTY_GET2(property_get_system_state, "s", Manager, manager_state, manager_state_to_string);
63static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec, "t", (uint64_t) prctl(PR_GET_TIMERSLACK));
92c23c5a
YW		 64static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "u", Hashmap *, hashmap_size);
65static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size, "u", Set *, set_size);
3bf0cb65 66static BUS_DEFINE_PROPERTY_GET(property_get_default_timeout_abort_usec, "t", Manager, manager_default_timeout_abort_usec);
10f3f4ed 67static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_device, "s", watchdog_get_device());
10f3f4ed
YW		 68static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_realtime, "t", watchdog_get_last_ping(CLOCK_REALTIME));
69static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_monotonic, "t", watchdog_get_last_ping(CLOCK_MONOTONIC));
718db961
LP		 70
71static int property_get_virtualization(
72 sd_bus *bus,
73 const char *path,
74 const char *interface,
75 const char *property,
76 sd_bus_message *reply,
ebcf1f97
LP		 77 void *userdata,
78 sd_bus_error *error) {
718db961 79
1b86c7c5 80 Virtualization v;
5c22925a 81
718db961
LP		 82 assert(bus);
83 assert(reply);
84
5c22925a
LP		 85 v = detect_virtualization();
86
87 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
88 *
89 * https://github.com/systemd/systemd/issues/1423
90 */
91
92 return sd_bus_message_append(
93 reply, "s",
79a60375 94 v == VIRTUALIZATION_NONE ? NULL : virtualization_to_string(v));
718db961
LP		 95}
96
1257274a
DB		 97static int property_get_confidential_virtualization(
98 sd_bus *bus,
99 const char *path,
100 const char *interface,
101 const char *property,
102 sd_bus_message *reply,
103 void *userdata,
104 sd_bus_error *error) {
105
106 ConfidentialVirtualization v;
107
108 assert(bus);
109 assert(reply);
110
111 v = detect_confidential_virtualization();
112
113 return sd_bus_message_append(
114 reply, "s",
115 v <= 0 ? NULL : confidential_virtualization_to_string(v));
116}
117
718db961
LP		 118static int property_get_tainted(
119 sd_bus *bus,
120 const char *path,
121 const char *interface,
122 const char *property,
123 sd_bus_message *reply,
ebcf1f97
LP		 124 void *userdata,
125 sd_bus_error *error) {
718db961 126
af6b0ecc 127 _cleanup_free_ char *s = NULL;
99534007 128 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 129
130 assert(bus);
131 assert(reply);
c5d34390 132
af6b0ecc
LP		 133 s = manager_taint_string(m);
134 if (!s)
135 return log_oom();
c5d34390 136
af6b0ecc 137 return sd_bus_message_append(reply, "s", s);
c5d34390
LP		 138}
139
718db961
LP		 140static int property_set_log_target(
141 sd_bus *bus,
142 const char *path,
143 const char *interface,
144 const char *property,
145 sd_bus_message *value,
ebcf1f97
LP		 146 void *userdata,
147 sd_bus_error *error) {
718db961 148
bda7d78b 149 Manager *m = userdata;
c826cda4 150 const char *t;
718db961 151 int r;
c826cda4 152
718db961
LP		 153 assert(bus);
154 assert(value);
c826cda4 155
718db961
LP		 156 r = sd_bus_message_read(value, "s", &t);
157 if (r < 0)
158 return r;
c826cda4 159
bda7d78b
FB		 160 if (isempty(t))
161 manager_restore_original_log_target(m);
162 else {
163 LogTarget target;
164
165 target = log_target_from_string(t);
166 if (target < 0)
167 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log target '%s'", t);
168
169 manager_override_log_target(m, target);
170 }
171
172 return 0;
c826cda4
AB		 173}
174
718db961
LP		 175static int property_set_log_level(
176 sd_bus *bus,
177 const char *path,
178 const char *interface,
179 const char *property,
180 sd_bus_message *value,
ebcf1f97
LP		 181 void *userdata,
182 sd_bus_error *error) {
718db961 183
a6ecbf83 184 Manager *m = userdata;
c826cda4 185 const char *t;
718db961 186 int r;
c826cda4 187
718db961
LP		 188 assert(bus);
189 assert(value);
c826cda4 190
718db961
LP		 191 r = sd_bus_message_read(value, "s", &t);
192 if (r < 0)
193 return r;
c826cda4 194
a6ecbf83
FB		 195 if (isempty(t))
196 manager_restore_original_log_level(m);
197 else {
198 int level;
199
200 level = log_level_from_string(t);
201 if (level < 0)
202 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
203
204 manager_override_log_level(m, level);
205 }
206
207 return 0;
c826cda4
AB		 208}
209
718db961
LP		 210static int property_get_progress(
211 sd_bus *bus,
212 const char *path,
213 const char *interface,
214 const char *property,
215 sd_bus_message *reply,
ebcf1f97
LP		 216 void *userdata,
217 sd_bus_error *error) {
718db961 218
99534007 219 Manager *m = ASSERT_PTR(userdata);
05d6a3b6
LP		 220 double d;
221
718db961
LP		 222 assert(bus);
223 assert(reply);
05d6a3b6 224
49d5666c 225 if (MANAGER_IS_FINISHED(m))
05d6a3b6
LP		 226 d = 1.0;
227 else
228 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
229
718db961
LP		 230 return sd_bus_message_append(reply, "d", d);
231}
232
1ad6e8b3
LP		 233static int property_get_environment(
234 sd_bus *bus,
235 const char *path,
236 const char *interface,
237 const char *property,
238 sd_bus_message *reply,
239 void *userdata,
240 sd_bus_error *error) {
241
242 _cleanup_strv_free_ char **l = NULL;
99534007 243 Manager *m = ASSERT_PTR(userdata);
1ad6e8b3
LP		 244 int r;
245
246 assert(bus);
247 assert(reply);
1ad6e8b3
LP		 248
249 r = manager_get_effective_environment(m, &l);
250 if (r < 0)
251 return r;
252
253 return sd_bus_message_append_strv(reply, l);
254}
255
52d2566a
ZJS		 256static int property_get_show_status(
257 sd_bus *bus,
258 const char *path,
259 const char *interface,
260 const char *property,
261 sd_bus_message *reply,
262 void *userdata,
263 sd_bus_error *error) {
264
99534007 265 Manager *m = ASSERT_PTR(userdata);
52d2566a
ZJS		 266
267 assert(bus);
268 assert(reply);
52d2566a 269
44a41954 270 return sd_bus_message_append(reply, "b", manager_get_show_status_on(m));
52d2566a
ZJS		 271}
272
986935cf 273static int property_get_runtime_watchdog(
718db961
LP		 274 sd_bus *bus,
275 const char *path,
276 const char *interface,
277 const char *property,
986935cf 278 sd_bus_message *reply,
ebcf1f97
LP		 279 void *userdata,
280 sd_bus_error *error) {
05d6a3b6 281
99534007 282 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 283
284 assert(bus);
986935cf
FB		 285 assert(reply);
286
287 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_RUNTIME));
288}
289
5717062e
CK		 290static int property_get_pretimeout_watchdog(
291 sd_bus *bus,
292 const char *path,
293 const char *interface,
294 const char *property,
295 sd_bus_message *reply,
296 void *userdata,
297 sd_bus_error *error) {
298
99534007 299 Manager *m = ASSERT_PTR(userdata);
5717062e 300
5717062e
CK		 301 assert(bus);
302 assert(reply);
303
304 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_PRETIMEOUT));
305}
306
aff3a9e1
LB		 307static int property_get_pretimeout_watchdog_governor(
308 sd_bus *bus,
309 const char *path,
310 const char *interface,
311 const char *property,
312 sd_bus_message *reply,
313 void *userdata,
314 sd_bus_error *error) {
315
99534007 316 Manager *m = ASSERT_PTR(userdata);
aff3a9e1 317
aff3a9e1
LB		 318 assert(bus);
319 assert(reply);
320
321 return sd_bus_message_append(reply, "s", m->watchdog_pretimeout_governor);
322}
323
986935cf
FB		 324static int property_get_reboot_watchdog(
325 sd_bus *bus,
326 const char *path,
327 const char *interface,
328 const char *property,
329 sd_bus_message *reply,
330 void *userdata,
331 sd_bus_error *error) {
332
99534007 333 Manager *m = ASSERT_PTR(userdata);
986935cf 334
986935cf
FB		 335 assert(bus);
336 assert(reply);
337
338 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_REBOOT));
339}
340
341static int property_get_kexec_watchdog(
342 sd_bus *bus,
343 const char *path,
344 const char *interface,
345 const char *property,
346 sd_bus_message *reply,
347 void *userdata,
348 sd_bus_error *error) {
349
99534007 350 Manager *m = ASSERT_PTR(userdata);
986935cf 351
986935cf
FB		 352 assert(bus);
353 assert(reply);
354
355 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_KEXEC));
356}
357
358static int property_set_watchdog(Manager *m, WatchdogType type, sd_bus_message *value) {
359 usec_t timeout;
360 int r;
361
362 assert(m);
718db961
LP		 363 assert(value);
364
365 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
366
986935cf 367 r = sd_bus_message_read(value, "t", &timeout);
718db961
LP		 368 if (r < 0)
369 return r;
370
aac47032
YW		 371 manager_override_watchdog(m, type, timeout);
372 return 0;
986935cf
FB		 373}
374
375static int property_set_runtime_watchdog(
376 sd_bus *bus,
377 const char *path,
378 const char *interface,
379 const char *property,
380 sd_bus_message *value,
381 void *userdata,
382 sd_bus_error *error) {
383
384 return property_set_watchdog(userdata, WATCHDOG_RUNTIME, value);
385}
386
5717062e
CK		 387static int property_set_pretimeout_watchdog(
388 sd_bus *bus,
389 const char *path,
390 const char *interface,
391 const char *property,
392 sd_bus_message *value,
393 void *userdata,
394 sd_bus_error *error) {
395
396 return property_set_watchdog(userdata, WATCHDOG_PRETIMEOUT, value);
397}
398
aff3a9e1
LB		 399static int property_set_pretimeout_watchdog_governor(
400 sd_bus *bus,
401 const char *path,
402 const char *interface,
403 const char *property,
404 sd_bus_message *value,
405 void *userdata,
406 sd_bus_error *error) {
407
99534007 408 Manager *m = ASSERT_PTR(userdata);
aff3a9e1
LB		 409 char *governor;
410 int r;
411
aff3a9e1
LB		 412 r = sd_bus_message_read(value, "s", &governor);
413 if (r < 0)
414 return r;
415 if (!string_is_safe(governor))
416 return -EINVAL;
417
418 return manager_override_watchdog_pretimeout_governor(m, governor);
419}
420
986935cf
FB		 421static int property_set_reboot_watchdog(
422 sd_bus *bus,
423 const char *path,
424 const char *interface,
425 const char *property,
426 sd_bus_message *value,
427 void *userdata,
428 sd_bus_error *error) {
429
430 return property_set_watchdog(userdata, WATCHDOG_REBOOT, value);
431}
432
433static int property_set_kexec_watchdog(
434 sd_bus *bus,
435 const char *path,
436 const char *interface,
437 const char *property,
438 sd_bus_message *value,
439 void *userdata,
440 sd_bus_error *error) {
441
99534007 442 _unused_ Manager *m = ASSERT_PTR(userdata);
986935cf 443
986935cf
FB		 444 assert(bus);
445 assert(value);
446
447 return property_set_watchdog(userdata, WATCHDOG_KEXEC, value);
05d6a3b6
LP		 448}
449
d4a402e4
LP		 450static int property_get_oom_score_adjust(
451 sd_bus *bus,
452 const char *path,
453 const char *interface,
454 const char *property,
455 sd_bus_message *reply,
456 void *userdata,
457 sd_bus_error *error) {
458
99534007 459 Manager *m = ASSERT_PTR(userdata);
d4a402e4
LP		 460 int r, n;
461
d4a402e4
LP		 462 assert(bus);
463 assert(reply);
464
c9e120e0
LP		 465 if (m->defaults.oom_score_adjust_set)
466 n = m->defaults.oom_score_adjust;
d4a402e4
LP		 467 else {
468 n = 0;
469 r = get_oom_score_adjust(&n);
470 if (r < 0)
471 log_debug_errno(r, "Failed to read current OOM score adjustment value, ignoring: %m");
472 }
473
474 return sd_bus_message_append(reply, "i", n);
475}
476
96cc4453 477static int bus_get_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
718db961
LP		 478 Unit *u;
479 int r;
dfae3488 480
dfae3488 481 assert(m);
96cc4453
LP		 482 assert(message);
483 assert(ret_unit);
dfae3488 484
cb31470f
ZJS		 485 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up
486 * its sleeve: if the name is specified empty we use the client's unit. */
dfae3488 487
1d22e906 488 if (isempty(name)) {
4afd3348 489 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1d22e906
LP		 490 pid_t pid;
491
492 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
493 if (r < 0)
494 return r;
495
496 r = sd_bus_creds_get_pid(creds, &pid);
497 if (r < 0)
498 return r;
499
500 u = manager_get_unit_by_pid(m, pid);
501 if (!u)
1b09b81c 502 return sd_bus_error_set(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
1d22e906
LP		 503 } else {
504 u = manager_get_unit(m, name);
505 if (!u)
506 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
507 }
dfae3488 508
96cc4453
LP		 509 *ret_unit = u;
510 return 0;
511}
512
513static int bus_load_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
514 assert(m);
515 assert(message);
516 assert(ret_unit);
517
518 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
519
520 if (isempty(name))
521 return bus_get_unit_by_name(m, message, name, ret_unit, error);
522
523 return manager_load_unit(m, name, NULL, error, ret_unit);
524}
525
4659bf6f 526static int reply_unit_path(Unit *u, sd_bus_message *message, sd_bus_error *error) {
96cc4453 527 _cleanup_free_ char *path = NULL;
4659bf6f
LP		 528 int r;
529
530 assert(u);
531 assert(message);
532
533 r = mac_selinux_unit_access_check(u, message, "status", error);
534 if (r < 0)
535 return r;
536
537 path = unit_dbus_path(u);
538 if (!path)
539 return log_oom();
540
541 return sd_bus_reply_method_return(message, "o", path);
542}
543
544static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 545 Manager *m = ASSERT_PTR(userdata);
96cc4453
LP		 546 const char *name;
547 Unit *u;
548 int r;
549
550 assert(message);
96cc4453
LP		 551
552 /* Anyone can call this method */
553
554 r = sd_bus_message_read(message, "s", &name);
555 if (r < 0)
556 return r;
557
558 r = bus_get_unit_by_name(m, message, name, &u, error);
559 if (r < 0)
560 return r;
561
4659bf6f 562 return reply_unit_path(u, message, error);
718db961 563}
c0576cd6 564
19070062 565static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 566 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 567 pid_t pid;
568 Unit *u;
569 int r;
c0576cd6 570
718db961 571 assert(message);
c0576cd6 572
718db961 573 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
729e3769 574
283868e1
SW		 575 /* Anyone can call this method */
576
718db961
LP		 577 r = sd_bus_message_read(message, "u", &pid);
578 if (r < 0)
ebcf1f97 579 return r;
07b38ba5 580 if (pid < 0)
1d22e906 581 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PID " PID_FMT, pid);
718db961
LP		 582
583 if (pid == 0) {
4afd3348 584 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
5b12334d
LP		 585
586 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
587 if (r < 0)
588 return r;
589
590 r = sd_bus_creds_get_pid(creds, &pid);
718db961 591 if (r < 0)
ebcf1f97 592 return r;
729e3769
LP		 593 }
594
718db961
LP		 595 u = manager_get_unit_by_pid(m, pid);
596 if (!u)
1fa2f38f 597 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pid);
c0576cd6 598
4659bf6f 599 return reply_unit_path(u, message, error);
718db961
LP		 600}
601
4b58153d
LP		 602static int method_get_unit_by_invocation_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
603 _cleanup_free_ char *path = NULL;
99534007 604 Manager *m = ASSERT_PTR(userdata);
4b58153d
LP		 605 sd_id128_t id;
606 const void *a;
607 Unit *u;
608 size_t sz;
609 int r;
610
611 assert(message);
4b58153d
LP		 612
613 /* Anyone can call this method */
614
615 r = sd_bus_message_read_array(message, 'y', &a, &sz);
616 if (r < 0)
617 return r;
618 if (sz == 0)
619 id = SD_ID128_NULL;
620 else if (sz == 16)
621 memcpy(&id, a, sz);
622 else
1b09b81c 623 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid invocation ID");
4b58153d
LP		 624
625 if (sd_id128_is_null(id)) {
626 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
627 pid_t pid;
628
629 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
630 if (r < 0)
631 return r;
632
633 r = sd_bus_creds_get_pid(creds, &pid);
634 if (r < 0)
635 return r;
636
637 u = manager_get_unit_by_pid(m, pid);
638 if (!u)
cb31470f
ZJS		 639 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
640 "Client " PID_FMT " not member of any unit.", pid);
4b58153d
LP		 641 } else {
642 u = hashmap_get(m->units_by_invocation_id, &id);
643 if (!u)
644 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(id));
645 }
646
647 r = mac_selinux_unit_access_check(u, message, "status", error);
648 if (r < 0)
649 return r;
650
cb31470f
ZJS		 651 /* So here's a special trick: the bus path we return actually references the unit by its invocation
652 * ID instead of the unit name. This means it stays valid only as long as the invocation ID stays the
653 * same. */
4b58153d
LP		 654 path = unit_dbus_path_invocation_id(u);
655 if (!path)
656 return -ENOMEM;
657
658 return sd_bus_reply_method_return(message, "o", path);
659}
660
267dd427 661static int method_get_unit_by_control_group(sd_bus_message *message, void *userdata, sd_bus_error *error) {
267dd427
LP		 662 Manager *m = userdata;
663 const char *cgroup;
664 Unit *u;
665 int r;
666
667 r = sd_bus_message_read(message, "s", &cgroup);
668 if (r < 0)
669 return r;
670
671 u = manager_get_unit_by_cgroup(m, cgroup);
672 if (!u)
cb31470f
ZJS		 673 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
674 "Control group '%s' is not valid or not managed by this instance",
675 cgroup);
267dd427 676
4659bf6f 677 return reply_unit_path(u, message, error);
267dd427
LP		 678}
679
e0e7bc82
LB		 680static int method_get_unit_by_pidfd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
681 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
495e75ed 682 _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
e0e7bc82
LB		 683 Manager *m = ASSERT_PTR(userdata);
684 _cleanup_free_ char *path = NULL;
685 int r, pidfd;
e0e7bc82
LB		 686 Unit *u;
687
688 assert(message);
689
690 r = sd_bus_message_read(message, "h", &pidfd);
691 if (r < 0)
692 return r;
693
495e75ed 694 r = pidref_set_pidfd(&pidref, pidfd);
e0e7bc82
LB		 695 if (r < 0)
696 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
697
495e75ed 698 u = manager_get_unit_by_pidref(m, &pidref);
e0e7bc82 699 if (!u)
495e75ed 700 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pidref.pid);
e0e7bc82
LB		 701
702 r = mac_selinux_unit_access_check(u, message, "status", error);
703 if (r < 0)
704 return r;
705
706 path = unit_dbus_path(u);
707 if (!path)
708 return log_oom();
709
710 r = sd_bus_message_new_method_return(message, &reply);
711 if (r < 0)
712 return r;
713
714 r = sd_bus_message_append(reply, "os", path, u->id);
715 if (r < 0)
716 return r;
717
718 r = sd_bus_message_append_array(reply, 'y', u->invocation_id.bytes, sizeof(u->invocation_id.bytes));
719 if (r < 0)
720 return r;
721
722 /* Double-check that the process is still alive and that the PID did not change before returning the
723 * answer. */
495e75ed 724 r = pidref_verify(&pidref);
f840c7d5 725 if (r == -ESRCH)
e0e7bc82
LB		 726 return sd_bus_error_setf(error,
727 BUS_ERROR_NO_SUCH_PROCESS,
f840c7d5 728 "The PIDFD's PID "PID_FMT" changed during the lookup operation.",
495e75ed 729 pidref.pid);
f840c7d5
LB		 730 if (r < 0)
731 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
e0e7bc82
LB		 732
733 return sd_bus_send(NULL, reply, NULL);
734}
735
19070062 736static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 737 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 738 const char *name;
739 Unit *u;
740 int r;
c0576cd6 741
718db961 742 assert(message);
718db961 743
283868e1
SW		 744 /* Anyone can call this method */
745
718db961
LP		 746 r = sd_bus_message_read(message, "s", &name);
747 if (r < 0)
ebcf1f97 748 return r;
c0576cd6 749
96cc4453
LP		 750 r = bus_load_unit_by_name(m, message, name, &u, error);
751 if (r < 0)
752 return r;
718db961 753
4659bf6f 754 return reply_unit_path(u, message, error);
c0576cd6
LP		 755}
756
19070062 757static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
718db961
LP		 758 const char *name;
759 Unit *u;
c0576cd6
LP		 760 int r;
761
718db961
LP		 762 assert(message);
763 assert(m);
c0576cd6 764
718db961
LP		 765 r = sd_bus_message_read(message, "s", &name);
766 if (r < 0)
ebcf1f97 767 return r;
c0576cd6 768
ebcf1f97 769 r = manager_load_unit(m, name, NULL, error, &u);
718db961 770 if (r < 0)
ebcf1f97 771 return r;
718db961 772
19070062 773 return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
c0576cd6
LP		 774}
775
19070062 776static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 777 return method_start_unit_generic(message, userdata, JOB_START, /* reload_if_possible = */ false, error);
718db961 778}
c757a65b 779
19070062 780static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 781 return method_start_unit_generic(message, userdata, JOB_STOP, /* reload_if_possible = */ false, error);
718db961 782}
c757a65b 783
19070062 784static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 785 return method_start_unit_generic(message, userdata, JOB_RELOAD, /* reload_if_possible = */ false, error);
718db961 786}
c757a65b 787
19070062 788static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 789 return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ false, error);
c757a65b
LP		 790}
791
19070062 792static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 793 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ false, error);
718db961 794}
d200735e 795
19070062 796static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 797 return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ true, error);
718db961 798}
d200735e 799
19070062 800static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 801 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ true, error);
718db961 802}
d200735e 803
42561fc9
LP		 804typedef enum GenericUnitOperationFlags {
805 GENERIC_UNIT_LOAD = 1 << 0, /* Load if the unit is not loaded yet */
806 GENERIC_UNIT_VALIDATE_LOADED = 1 << 1, /* Verify unit is properly loaded before forwarding call */
807} GenericUnitOperationFlags;
808
809static int method_generic_unit_operation(
810 sd_bus_message *message,
811 Manager *m,
812 sd_bus_error *error,
813 sd_bus_message_handler_t handler,
814 GenericUnitOperationFlags flags) {
815
50cbaba4
LP		 816 const char *name;
817 Unit *u;
818 int r;
819
820 assert(message);
821 assert(m);
822
42561fc9
LP		 823 /* Read the first argument from the command and pass the operation to the specified per-unit
824 * method. */
825
50cbaba4
LP		 826 r = sd_bus_message_read(message, "s", &name);
827 if (r < 0)
828 return r;
829
42561fc9
LP		 830 if (!isempty(name) && FLAGS_SET(flags, GENERIC_UNIT_LOAD))
831 r = manager_load_unit(m, name, NULL, error, &u);
832 else
833 r = bus_get_unit_by_name(m, message, name, &u, error);
50cbaba4
LP		 834 if (r < 0)
835 return r;
836
42561fc9
LP		 837 if (FLAGS_SET(flags, GENERIC_UNIT_VALIDATE_LOADED)) {
838 r = bus_unit_validate_load_state(u, error);
839 if (r < 0)
840 return r;
841 }
842
843 return handler(message, u, error);
844}
845
846static int method_enqueue_unit_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
847 /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
848 return method_generic_unit_operation(message, userdata, error, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
50cbaba4
LP		 849}
850
19070062 851static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 852 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 853 const char *old_name;
854 Unit *u;
1adf1049 855 int r;
ea430986 856
ea430986 857 assert(message);
ea430986 858
718db961
LP		 859 r = sd_bus_message_read(message, "s", &old_name);
860 if (r < 0)
ebcf1f97 861 return r;
ea430986 862
96cc4453
LP		 863 r = bus_get_unit_by_name(m, message, old_name, &u, error);
864 if (r < 0)
865 return r;
866 if (!u->job || u->job->type != JOB_START)
ebcf1f97 867 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
c0576cd6 868
2d8cc7a7 869 return method_start_unit_generic(message, m, JOB_START, /* reload_if_possible = */ false, error);
718db961 870}
ea430986 871
19070062 872static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 873 /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
874 * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
875 return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill, 0);
718db961 876}
8a0867d6 877
4d3bac56
LP		 878static int method_clean_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
879 /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
880 * cleaned */
881 return method_generic_unit_operation(message, userdata, error, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
882}
883
d9e45bc3
MS		 884static int method_freeze_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
885 return method_generic_unit_operation(message, userdata, error, bus_unit_method_freeze, 0);
886}
887
888static int method_thaw_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
889 return method_generic_unit_operation(message, userdata, error, bus_unit_method_thaw, 0);
890}
891
19070062 892static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 893 /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
894 * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
895 return method_generic_unit_operation(message, userdata, error, bus_unit_method_reset_failed, 0);
718db961 896}
5dd9014f 897
19070062 898static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 899 /* Only change properties on fully loaded units, and load them in order to set properties */
900 return method_generic_unit_operation(message, userdata, error, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
718db961
LP		 901}
902
5e8deb94
LB		 903static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
904 /* Only add mounts on fully loaded units */
905 return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
906}
907
af477139
LB		 908static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
909 /* Only add mounts on fully loaded units */
910 return method_generic_unit_operation(message, userdata, error, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
911}
912
05a98afd 913static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 914 /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
915 return method_generic_unit_operation(message, userdata, error, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
05a98afd
LP		 916}
917
918static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 919 /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
920 * loaded unit there's no need to load the unit for unreffing it. */
921 return method_generic_unit_operation(message, userdata, error, bus_unit_method_unref, 0);
05a98afd
LP		 922}
923
6900c740 924static int reply_unit_info(sd_bus_message *reply, Unit *u) {
925 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
926 Unit *following;
927
928 following = unit_following(u);
929
930 unit_path = unit_dbus_path(u);
931 if (!unit_path)
932 return -ENOMEM;
933
934 if (u->job) {
935 job_path = job_dbus_path(u->job);
936 if (!job_path)
937 return -ENOMEM;
938 }
939
940 return sd_bus_message_append(
941 reply, "(ssssssouso)",
942 u->id,
943 unit_description(u),
944 unit_load_state_to_string(u->load_state),
945 unit_active_state_to_string(unit_active_state(u)),
946 unit_sub_state_to_string(u),
947 following ? following->id : "",
948 unit_path,
949 u->job ? u->job->id : 0,
950 u->job ? job_type_to_string(u->job->type) : "",
c1d95b71 951 empty_to_root(job_path));
6900c740 952}
953
954static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
955 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 956 Manager *m = ASSERT_PTR(userdata);
6900c740 957 int r;
6900c740 958 _cleanup_strv_free_ char **units = NULL;
959
960 assert(message);
6900c740 961
962 r = sd_bus_message_read_strv(message, &units);
963 if (r < 0)
964 return r;
965
966 r = sd_bus_message_new_method_return(message, &reply);
967 if (r < 0)
968 return r;
969
970 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
971 if (r < 0)
972 return r;
973
974 STRV_FOREACH(unit, units) {
975 Unit *u;
976
977 if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
978 continue;
979
96cc4453 980 r = bus_load_unit_by_name(m, message, *unit, &u, error);
6900c740 981 if (r < 0)
982 return r;
983
984 r = reply_unit_info(reply, u);
985 if (r < 0)
986 return r;
987 }
988
989 r = sd_bus_message_close_container(reply);
990 if (r < 0)
991 return r;
992
993 return sd_bus_send(NULL, reply, NULL);
994}
995
291d565a 996static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 997 /* Don't load a unit (since it won't have any processes if it's not loaded), but don't insist on the
998 * unit being loaded (because even improperly loaded units might still have processes around */
999 return method_generic_unit_operation(message, userdata, error, bus_unit_method_get_processes, 0);
291d565a
LP		 1000}
1001
6592b975 1002static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 1003 /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
1004 * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
1005 * processes to stopped units anyway. */
1006 return method_generic_unit_operation(message, userdata, error, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
6592b975
LP		 1007}
1008
ab31f6b8
WC		 1009static int transient_unit_from_message(
1010 Manager *m,
1011 sd_bus_message *message,
1012 const char *name,
1013 Unit **unit,
1014 sd_bus_error *error) {
1015
06cc6afa 1016 UnitType t;
ab31f6b8
WC		 1017 Unit *u;
1018 int r;
1019
1020 assert(m);
1021 assert(message);
1022 assert(name);
1023
06cc6afa
LP		 1024 t = unit_name_to_type(name);
1025 if (t < 0)
cb31470f
ZJS		 1026 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1027 "Invalid unit name or type.");
06cc6afa
LP		 1028
1029 if (!unit_vtable[t]->can_transient)
cb31470f
ZJS		 1030 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1031 "Unit type %s does not support transient units.",
1032 unit_type_to_string(t));
06cc6afa 1033
ab31f6b8
WC		 1034 r = manager_load_unit(m, name, NULL, error, &u);
1035 if (r < 0)
1036 return r;
1037
0f13f3bd 1038 if (!unit_is_pristine(u))
cb31470f 1039 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
1f832446 1040 "Unit %s was already loaded or has a fragment file.", name);
ab31f6b8
WC		 1041
1042 /* OK, the unit failed to load and is unreferenced, now let's
1043 * fill in the transient data instead */
1044 r = unit_make_transient(u);
1045 if (r < 0)
1046 return r;
1047
1048 /* Set our properties */
1049 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
1050 if (r < 0)
1051 return r;
1052
05a98afd
LP		 1053 /* If the client asked for it, automatically add a reference to this unit. */
1054 if (u->bus_track_add) {
1055 r = bus_unit_track_add_sender(u, message);
1056 if (r < 0)
1057 return log_error_errno(r, "Failed to watch sender: %m");
1058 }
1059
97329d20 1060 /* Now load the missing bits of the unit we just created */
4f952a3f 1061 unit_add_to_load_queue(u);
97329d20
LP		 1062 manager_dispatch_load_queue(m);
1063
ab31f6b8
WC		 1064 *unit = u;
1065
1066 return 0;
1067}
1068
1069static int transient_aux_units_from_message(
1070 Manager *m,
1071 sd_bus_message *message,
1072 sd_bus_error *error) {
1073
ab31f6b8
WC		 1074 int r;
1075
1076 assert(m);
1077 assert(message);
1078
1079 r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
1080 if (r < 0)
1081 return r;
1082
1083 while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
97329d20
LP		 1084 const char *name = NULL;
1085 Unit *u;
1086
ab31f6b8
WC		 1087 r = sd_bus_message_read(message, "s", &name);
1088 if (r < 0)
1089 return r;
1090
1091 r = transient_unit_from_message(m, message, name, &u, error);
97329d20 1092 if (r < 0)
ab31f6b8
WC		 1093 return r;
1094
ab31f6b8
WC		 1095 r = sd_bus_message_exit_container(message);
1096 if (r < 0)
1097 return r;
1098 }
1099 if (r < 0)
1100 return r;
1101
1102 r = sd_bus_message_exit_container(message);
1103 if (r < 0)
1104 return r;
1105
1106 return 0;
1107}
1108
19070062 1109static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1110 const char *name, *smode;
99534007 1111 Manager *m = ASSERT_PTR(userdata);
718db961 1112 JobMode mode;
718db961
LP		 1113 Unit *u;
1114 int r;
ea430986 1115
718db961 1116 assert(message);
ea430986 1117
1d22e906 1118 r = mac_selinux_access_check(message, "start", error);
283868e1
SW		 1119 if (r < 0)
1120 return r;
283868e1 1121
718db961
LP		 1122 r = sd_bus_message_read(message, "ss", &name, &smode);
1123 if (r < 0)
ebcf1f97 1124 return r;
5632e374 1125
718db961
LP		 1126 mode = job_mode_from_string(smode);
1127 if (mode < 0)
ebcf1f97 1128 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
5632e374 1129
1d22e906 1130 r = bus_verify_manage_units_async(m, message, error);
718db961 1131 if (r < 0)
ebcf1f97 1132 return r;
1d22e906
LP		 1133 if (r == 0)
1134 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
5632e374 1135
ab31f6b8 1136 r = transient_unit_from_message(m, message, name, &u, error);
ebcf1f97
LP		 1137 if (r < 0)
1138 return r;
5632e374 1139
ab31f6b8 1140 r = transient_aux_units_from_message(m, message, error);
718db961 1141 if (r < 0)
ebcf1f97 1142 return r;
ea430986 1143
718db961 1144 /* Finally, start it */
50cbaba4 1145 return bus_unit_queue_job(message, u, JOB_START, mode, 0, error);
718db961 1146}
ea430986 1147
19070062 1148static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1149 _cleanup_free_ char *path = NULL;
99534007 1150 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1151 uint32_t id;
1152 Job *j;
1153 int r;
ea430986 1154
718db961 1155 assert(message);
ea430986 1156
283868e1
SW		 1157 /* Anyone can call this method */
1158
718db961
LP		 1159 r = sd_bus_message_read(message, "u", &id);
1160 if (r < 0)
ebcf1f97 1161 return r;
ea430986 1162
718db961
LP		 1163 j = manager_get_job(m, id);
1164 if (!j)
ebcf1f97 1165 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1166
8a188de9 1167 r = mac_selinux_unit_access_check(j->unit, message, "status", error);
ebcf1f97
LP		 1168 if (r < 0)
1169 return r;
ea430986 1170
718db961
LP		 1171 path = job_dbus_path(j);
1172 if (!path)
ebcf1f97 1173 return -ENOMEM;
ea430986 1174
df2d202e 1175 return sd_bus_reply_method_return(message, "o", path);
718db961 1176}
ea430986 1177
19070062 1178static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1179 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1180 uint32_t id;
1181 Job *j;
1182 int r;
ea430986 1183
718db961 1184 assert(message);
ea430986 1185
718db961
LP		 1186 r = sd_bus_message_read(message, "u", &id);
1187 if (r < 0)
ebcf1f97 1188 return r;
ea430986 1189
718db961
LP		 1190 j = manager_get_job(m, id);
1191 if (!j)
ebcf1f97 1192 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1193
19070062 1194 return bus_job_method_cancel(message, j, error);
718db961 1195}
c1e1601e 1196
19070062 1197static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1198 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1199 int r;
c1e1601e 1200
718db961 1201 assert(message);
c1e1601e 1202
1d22e906 1203 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1204 if (r < 0)
1205 return r;
1206
1d22e906
LP		 1207 r = bus_verify_manage_units_async(m, message, error);
1208 if (r < 0)
1209 return r;
1210 if (r == 0)
1211 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1212
718db961 1213 manager_clear_jobs(m);
c1e1601e 1214
df2d202e 1215 return sd_bus_reply_method_return(message, NULL);
718db961 1216}
c1e1601e 1217
19070062 1218static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1219 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1220 int r;
cad45ba1 1221
718db961 1222 assert(message);
718db961 1223
8a188de9 1224 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1225 if (r < 0)
1226 return r;
1227
1d22e906
LP		 1228 r = bus_verify_manage_units_async(m, message, error);
1229 if (r < 0)
1230 return r;
1231 if (r == 0)
1232 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1233
718db961 1234 manager_reset_failed(m);
c1e1601e 1235
df2d202e 1236 return sd_bus_reply_method_return(message, NULL);
718db961 1237}
c1e1601e 1238
313fe66f 1239static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 1240 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1241 Manager *m = ASSERT_PTR(userdata);
718db961 1242 const char *k;
718db961
LP		 1243 Unit *u;
1244 int r;
c1e1601e 1245
718db961 1246 assert(message);
b152adec 1247
283868e1
SW		 1248 /* Anyone can call this method */
1249
8a188de9 1250 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1251 if (r < 0)
1252 return r;
cad45ba1 1253
df2d202e 1254 r = sd_bus_message_new_method_return(message, &reply);
718db961 1255 if (r < 0)
ebcf1f97 1256 return r;
b152adec 1257
718db961
LP		 1258 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
1259 if (r < 0)
ebcf1f97 1260 return r;
b152adec 1261
90e74a66 1262 HASHMAP_FOREACH_KEY(u, k, m->units) {
718db961
LP		 1263 if (k != u->id)
1264 continue;
b152adec 1265
cdc06ed7
DS		 1266 if (!strv_isempty(states) &&
1267 !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
1268 !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
1269 !strv_contains(states, unit_sub_state_to_string(u)))
1270 continue;
1271
313fe66f 1272 if (!strv_isempty(patterns) &&
1273 !strv_fnmatch_or_empty(patterns, u->id, FNM_NOESCAPE))
1274 continue;
1275
6900c740 1276 r = reply_unit_info(reply, u);
718db961 1277 if (r < 0)
ebcf1f97 1278 return r;
718db961 1279 }
4139c1b2 1280
718db961
LP		 1281 r = sd_bus_message_close_container(reply);
1282 if (r < 0)
ebcf1f97 1283 return r;
cad45ba1 1284
9030ca46 1285 return sd_bus_send(NULL, reply, NULL);
718db961 1286}
4139c1b2 1287
19070062 1288static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
313fe66f 1289 return list_units_filtered(message, userdata, error, NULL, NULL);
cdc06ed7
DS		 1290}
1291
19070062 1292static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cdc06ed7
DS		 1293 _cleanup_strv_free_ char **states = NULL;
1294 int r;
1295
1296 r = sd_bus_message_read_strv(message, &states);
1297 if (r < 0)
1298 return r;
1299
313fe66f 1300 return list_units_filtered(message, userdata, error, states, NULL);
1301}
1302
1303static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1304 _cleanup_strv_free_ char **states = NULL;
1305 _cleanup_strv_free_ char **patterns = NULL;
1306 int r;
1307
1308 r = sd_bus_message_read_strv(message, &states);
1309 if (r < 0)
1310 return r;
1311
1312 r = sd_bus_message_read_strv(message, &patterns);
1313 if (r < 0)
1314 return r;
1315
1316 return list_units_filtered(message, userdata, error, states, patterns);
cdc06ed7
DS		 1317}
1318
19070062 1319static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
4afd3348 1320 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1321 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1322 Job *j;
1323 int r;
4139c1b2 1324
718db961 1325 assert(message);
718db961 1326
283868e1
SW		 1327 /* Anyone can call this method */
1328
8a188de9 1329 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1330 if (r < 0)
1331 return r;
718db961 1332
df2d202e 1333 r = sd_bus_message_new_method_return(message, &reply);
718db961 1334 if (r < 0)
ebcf1f97 1335 return r;
718db961
LP		 1336
1337 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
1338 if (r < 0)
ebcf1f97 1339 return r;
718db961 1340
90e74a66 1341 HASHMAP_FOREACH(j, m->jobs) {
718db961
LP		 1342 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
1343
1344 job_path = job_dbus_path(j);
1345 if (!job_path)
ebcf1f97 1346 return -ENOMEM;
718db961
LP		 1347
1348 unit_path = unit_dbus_path(j->unit);
1349 if (!unit_path)
ebcf1f97 1350 return -ENOMEM;
718db961
LP		 1351
1352 r = sd_bus_message_append(
1353 reply, "(usssoo)",
1354 j->id,
1302759d 1355 j->unit->id,
718db961 1356 job_type_to_string(j->type),
1302759d 1357 job_state_to_string(j->state),
718db961
LP		 1358 job_path,
1359 unit_path);
cad45ba1 1360 if (r < 0)
ebcf1f97 1361 return r;
718db961 1362 }
5dd9014f 1363
718db961
LP		 1364 r = sd_bus_message_close_container(reply);
1365 if (r < 0)
ebcf1f97 1366 return r;
5dd9014f 1367
9030ca46 1368 return sd_bus_send(NULL, reply, NULL);
718db961 1369}
5dd9014f 1370
19070062 1371static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1372 Manager *m = ASSERT_PTR(userdata);
718db961 1373 int r;
5dd9014f 1374
718db961 1375 assert(message);
ea430986 1376
283868e1
SW		 1377 /* Anyone can call this method */
1378
8a188de9 1379 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1380 if (r < 0)
1381 return r;
cad45ba1 1382
19070062 1383 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1384
1385 /* Note that direct bus connection subscribe by
1386 * default, we only track peers on the API bus here */
1387
1388 if (!m->subscribed) {
19070062 1389 r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
8f8f05a9
LP		 1390 if (r < 0)
1391 return r;
1392 }
1393
1394 r = sd_bus_track_add_sender(m->subscribed, message);
1395 if (r < 0)
1396 return r;
1397 if (r == 0)
1b09b81c 1398 return sd_bus_error_set(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
8f8f05a9 1399 }
ea430986 1400
df2d202e 1401 return sd_bus_reply_method_return(message, NULL);
718db961 1402}
ea430986 1403
19070062 1404static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1405 Manager *m = ASSERT_PTR(userdata);
718db961 1406 int r;
ea430986 1407
718db961 1408 assert(message);
ea430986 1409
283868e1
SW		 1410 /* Anyone can call this method */
1411
8a188de9 1412 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1413 if (r < 0)
1414 return r;
ea430986 1415
19070062 1416 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1417 r = sd_bus_track_remove_sender(m->subscribed, message);
1418 if (r < 0)
1419 return r;
1420 if (r == 0)
1b09b81c 1421 return sd_bus_error_set(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
8f8f05a9 1422 }
ea430986 1423
df2d202e 1424 return sd_bus_reply_method_return(message, NULL);
718db961 1425}
ea430986 1426
d1d8786c
FB		 1427static int dump_impl(
1428 sd_bus_message *message,
1429 void *userdata,
1430 sd_bus_error *error,
1431 char **patterns,
1432 int (*reply)(sd_bus_message *, char *)) {
1433
718db961 1434 _cleanup_free_ char *dump = NULL;
99534007 1435 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1436 int r;
ea430986 1437
718db961 1438 assert(message);
ea430986 1439
d9365956
LB		 1440 /* 'status' access is the bare minimum always needed for this, as the policy might straight out
1441 * forbid a client from querying any information from systemd, regardless of any rate limiting. */
8a188de9 1442 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1443 if (r < 0)
1444 return r;
ea430986 1445
d9365956
LB		 1446 /* Rate limit reached? Check if the caller is privileged/allowed by policy to bypass this. We
1447 * check the rate limit first to avoid the expensive roundtrip to polkit when not needed. */
1448 if (!ratelimit_below(&m->dump_ratelimit)) {
1449 /* We need a way for SELinux to constrain the operation when the rate limit is active, even
1450 * if polkit would allow it, but we cannot easily add new named permissions, so we need to
1451 * use an existing one. Reload/reexec are also slow but non-destructive/modifying
1452 * operations, and can cause PID1 to stall. So it seems similar enough in terms of security
1453 * considerations and impact, and thus use the same access check for dumps which, given the
1454 * large amount of data to fetch, can stall PID1 for quite some time. */
1455 r = mac_selinux_access_check(message, "reload", error);
1456 if (r < 0)
1457 goto ratelimited;
1458
1459 r = bus_verify_bypass_dump_ratelimit_async(m, message, error);
1460 if (r < 0)
1461 goto ratelimited;
1462 if (r == 0)
1463 /* No authorization for now, but the async polkit stuff will call us again when it
1464 * has it */
1465 return 1;
1466 }
1467
d1d8786c 1468 r = manager_get_dump_string(m, patterns, &dump);
dacd6cee
LP		 1469 if (r < 0)
1470 return r;
a16e1123 1471
c0a1bfac 1472 return reply(message, dump);
d9365956
LB		 1473
1474ratelimited:
1475 log_warning("Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1476 FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
1477 return sd_bus_error_setf(error,
1478 SD_BUS_ERROR_LIMITS_EXCEEDED,
1479 "Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1480 FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
c0a1bfac
DT		 1481}
1482
1483static int reply_dump(sd_bus_message *message, char *dump) {
df2d202e 1484 return sd_bus_reply_method_return(message, "s", dump);
718db961 1485}
cad45ba1 1486
c0a1bfac 1487static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c 1488 return dump_impl(message, userdata, error, NULL, reply_dump);
c0a1bfac
DT		 1489}
1490
1491static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
254d1313 1492 _cleanup_close_ int fd = -EBADF;
c0a1bfac
DT		 1493
1494 fd = acquire_data_fd(dump, strlen(dump), 0);
1495 if (fd < 0)
1496 return fd;
1497
1498 return sd_bus_reply_method_return(message, "h", fd);
1499}
1500
1501static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c
FB		 1502 return dump_impl(message, userdata, error, NULL, reply_dump_by_fd);
1503}
1504
f6cce15b
ZJS		 1505static int dump_units_matching_patterns(
1506 sd_bus_message *message,
1507 void *userdata,
1508 sd_bus_error *error,
1509 int (*reply)(sd_bus_message *, char *)) {
d1d8786c
FB		 1510 _cleanup_strv_free_ char **patterns = NULL;
1511 int r;
1512
1513 r = sd_bus_message_read_strv(message, &patterns);
1514 if (r < 0)
1515 return r;
1516
f6cce15b
ZJS		 1517 return dump_impl(message, userdata, error, patterns, reply);
1518}
1519
1520static int method_dump_units_matching_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1521 return dump_units_matching_patterns(message, userdata, error, reply_dump);
1522}
1523
1524static int method_dump_units_matching_patterns_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1525 return dump_units_matching_patterns(message, userdata, error, reply_dump_by_fd);
c0a1bfac
DT		 1526}
1527
36b4a7ba 1528static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1b09b81c 1529 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
718db961 1530}
cad45ba1 1531
c23e9b6a 1532static int get_run_space(uint64_t *ret, sd_bus_error *error) {
ae57dad3 1533 struct statvfs svfs;
c23e9b6a
LP		 1534
1535 assert(ret);
ae57dad3
LP		 1536
1537 if (statvfs("/run/systemd", &svfs) < 0)
1538 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1539
c23e9b6a
LP		 1540 *ret = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1541 return 0;
1542}
1543
1544static int verify_run_space(const char *message, sd_bus_error *error) {
1545 uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1546 int r;
1547
1548 assert(message);
1549
1550 r = get_run_space(&available, error);
1551 if (r < 0)
1552 return r;
ae57dad3 1553
2b59bf51 1554 if (available < RELOAD_DISK_SPACE_MIN)
ae57dad3
LP		 1555 return sd_bus_error_setf(error,
1556 BUS_ERROR_DISK_FULL,
c23e9b6a 1557 "%s, not enough space available on /run/systemd/. "
ae57dad3
LP		 1558 "Currently, %s are free, but a safety buffer of %s is enforced.",
1559 message,
2b59bf51
ZJS		 1560 FORMAT_BYTES(available),
1561 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3
LP		 1562
1563 return 0;
1564}
1565
1566int verify_run_space_and_log(const char *message) {
4dae8ae6 1567 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ae57dad3
LP		 1568 int r;
1569
c23e9b6a
LP		 1570 assert(message);
1571
ae57dad3
LP		 1572 r = verify_run_space(message, &error);
1573 if (r < 0)
4ae25393 1574 return log_error_errno(r, "%s", bus_error_message(&error, r));
ae57dad3 1575
4ae25393 1576 return 0;
ae57dad3
LP		 1577}
1578
c23e9b6a
LP		 1579static int verify_run_space_permissive(const char *message, sd_bus_error *error) {
1580 uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1581 int r;
1582
1583 assert(message);
1584
1585 r = get_run_space(&available, error);
1586 if (r < 0)
1587 return r;
1588
1589 if (available < RELOAD_DISK_SPACE_MIN)
1590 log_warning("Dangerously low amount of free space on /run/systemd/, %s.\n"
1591 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1592 message,
1593 FORMAT_BYTES(available),
1594 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
1595
1596 return 0;
1597}
1598
4895bacc 1599static void log_caller(sd_bus_message *message, Manager *manager, const char *method) {
9524c2fd
LB		 1600 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1601 const char *comm = NULL;
1602 Unit *caller;
1603 pid_t pid;
1604
1605 assert(message);
1606 assert(manager);
4895bacc 1607 assert(method);
9524c2fd
LB		 1608
1609 if (sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID|SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_COMM, &creds) < 0)
1610 return;
1611
1612 /* We need at least the PID, otherwise there's nothing to log, the rest is optional */
1613 if (sd_bus_creds_get_pid(creds, &pid) < 0)
1614 return;
1615
1616 (void) sd_bus_creds_get_comm(creds, &comm);
1617 caller = manager_get_unit_by_pid(manager, pid);
1618
1980a25d
ZJS		 1619 log_info("%s requested from client PID " PID_FMT "%s%s%s%s%s%s...",
1620 method, pid,
1621 comm ? " ('" : "", strempty(comm), comm ? "')" : "",
add74820 1622 caller ? " (unit " : "", caller ? caller->id : "", caller ? ")" : "");
9524c2fd
LB		 1623}
1624
19070062 1625static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1626 Manager *m = ASSERT_PTR(userdata);
718db961 1627 int r;
6652a2b9 1628
718db961 1629 assert(message);
6652a2b9 1630
ae57dad3
LP		 1631 r = verify_run_space("Refusing to reload", error);
1632 if (r < 0)
1633 return r;
1634
1d22e906 1635 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1636 if (r < 0)
1637 return r;
283868e1 1638
1d22e906 1639 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1640 if (r < 0)
1641 return r;
1d22e906
LP		 1642 if (r == 0)
1643 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
6652a2b9 1644
9524c2fd 1645 /* Write a log message noting the unit or process who requested the Reload() */
4895bacc 1646 log_caller(message, m, "Reloading");
9524c2fd 1647
856bfaeb
LB		 1648 /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1649 if (!ratelimit_below(&m->reload_ratelimit)) {
1650 log_warning("Reloading request rejected due to rate limit.");
1651 return sd_bus_error_setf(error,
1652 SD_BUS_ERROR_LIMITS_EXCEEDED,
1653 "Reload() request rejected due to rate limit.");
1654 }
1655
718db961
LP		 1656 /* Instead of sending the reply back right away, we just
1657 * remember that we need to and then send it after the reload
1658 * is finished. That way the caller knows when the reload
1659 * finished. */
6652a2b9 1660
209de525
LP		 1661 assert(!m->pending_reload_message);
1662 r = sd_bus_message_new_method_return(message, &m->pending_reload_message);
718db961 1663 if (r < 0)
ebcf1f97 1664 return r;
cad45ba1 1665
af41e508 1666 m->objective = MANAGER_RELOAD;
6652a2b9 1667
718db961
LP		 1668 return 1;
1669}
6652a2b9 1670
19070062 1671static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1672 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1673 int r;
6652a2b9 1674
718db961 1675 assert(message);
6652a2b9 1676
ae57dad3
LP		 1677 r = verify_run_space("Refusing to reexecute", error);
1678 if (r < 0)
1679 return r;
1680
1d22e906 1681 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1682 if (r < 0)
1683 return r;
283868e1 1684
1d22e906 1685 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1686 if (r < 0)
1687 return r;
1d22e906
LP		 1688 if (r == 0)
1689 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
cad45ba1 1690
4895bacc
LB		 1691 /* Write a log message noting the unit or process who requested the Reexecute() */
1692 log_caller(message, m, "Reexecuting");
1693
718db961
LP		 1694 /* We don't send a reply back here, the client should
1695 * just wait for us disconnecting. */
6652a2b9 1696
af41e508 1697 m->objective = MANAGER_REEXECUTE;
718db961
LP		 1698 return 1;
1699}
6652a2b9 1700
19070062 1701static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1702 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1703 int r;
6652a2b9 1704
718db961 1705 assert(message);
6652a2b9 1706
8a188de9 1707 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1708 if (r < 0)
1709 return r;
cad45ba1 1710
287419c1
AC		 1711 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1712 * we are running on the host. It will fall back on reboot() in
1713 * systemd-shutdown if it cannot do the exit() because it isn't a
1714 * container. */
6652a2b9 1715
af41e508 1716 m->objective = MANAGER_EXIT;
6652a2b9 1717
df2d202e 1718 return sd_bus_reply_method_return(message, NULL);
718db961 1719}
6652a2b9 1720
19070062 1721static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1722 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1723 int r;
664f88a7 1724
718db961 1725 assert(message);
cad45ba1 1726
8a188de9 1727 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1728 if (r < 0)
1729 return r;
664f88a7 1730
463d0d15 1731 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1732 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1733 "Reboot is only supported for system managers.");
664f88a7 1734
af41e508 1735 m->objective = MANAGER_REBOOT;
664f88a7 1736
df2d202e 1737 return sd_bus_reply_method_return(message, NULL);
718db961 1738}
664f88a7 1739
13ffc607
LP		 1740static int method_soft_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1741 _cleanup_free_ char *rt = NULL;
1742 Manager *m = ASSERT_PTR(userdata);
1743 const char *root;
1744 int r;
1745
1746 assert(message);
1747
1748 r = verify_run_space_permissive("soft reboot may fail", error);
1749 if (r < 0)
1750 return r;
1751
1752 r = mac_selinux_access_check(message, "reboot", error);
1753 if (r < 0)
1754 return r;
1755
1756 r = sd_bus_message_read(message, "s", &root);
1757 if (r < 0)
1758 return r;
1759
1760 if (!isempty(root)) {
1761 if (!path_is_valid(root))
1762 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1763 "New root directory '%s' must be a valid path.", root);
1764 if (!path_is_absolute(root))
1765 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1766 "New root directory path '%s' is not absolute.", root);
1767
1768 rt = strdup(root);
1769 if (!rt)
1770 return -ENOMEM;
1771 }
1772
1773 free_and_replace(m->switch_root, rt);
1774 m->objective = MANAGER_SOFT_REBOOT;
1775
1776 return sd_bus_reply_method_return(message, NULL);
1777}
1778
19070062 1779static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1780 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1781 int r;
50913bc0 1782
718db961 1783 assert(message);
1137a57c 1784
8a188de9 1785 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1786 if (r < 0)
1787 return r;
1137a57c 1788
463d0d15 1789 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1790 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1791 "Powering off is only supported for system managers.");
1137a57c 1792
af41e508 1793 m->objective = MANAGER_POWEROFF;
1137a57c 1794
df2d202e 1795 return sd_bus_reply_method_return(message, NULL);
718db961 1796}
1137a57c 1797
19070062 1798static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1799 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1800 int r;
1137a57c 1801
718db961 1802 assert(message);
8d0e38a2 1803
8a188de9 1804 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1805 if (r < 0)
1806 return r;
cad45ba1 1807
463d0d15 1808 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1809 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1810 "Halt is only supported for system managers.");
8d0e38a2 1811
af41e508 1812 m->objective = MANAGER_HALT;
8d0e38a2 1813
df2d202e 1814 return sd_bus_reply_method_return(message, NULL);
718db961 1815}
8d0e38a2 1816
19070062 1817static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1818 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1819 int r;
8d0e38a2 1820
718db961 1821 assert(message);
c0576cd6 1822
8a188de9 1823 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1824 if (r < 0)
1825 return r;
cad45ba1 1826
463d0d15 1827 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1828 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1829 "KExec is only supported for system managers.");
c0576cd6 1830
af41e508 1831 m->objective = MANAGER_KEXEC;
c0576cd6 1832
df2d202e 1833 return sd_bus_reply_method_return(message, NULL);
718db961 1834}
c0576cd6 1835
19070062 1836static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
87a19bfe 1837 _cleanup_free_ char *ri = NULL, *rt = NULL;
99534007 1838 Manager *m = ASSERT_PTR(userdata);
13ffc607 1839 const char *root, *init;
718db961 1840 int r;
c0576cd6 1841
718db961 1842 assert(message);
c0576cd6 1843
c23e9b6a
LP		 1844 r = verify_run_space_permissive("root switching may fail", error);
1845 if (r < 0)
1846 return r;
ae57dad3 1847
8a188de9 1848 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1849 if (r < 0)
1850 return r;
c0576cd6 1851
463d0d15 1852 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1853 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1854 "Root switching is only supported by system manager.");
c0576cd6 1855
718db961
LP		 1856 r = sd_bus_message_read(message, "ss", &root, &init);
1857 if (r < 0)
ebcf1f97 1858 return r;
c0576cd6 1859
5ae89ef3
LP		 1860 if (isempty(root))
1861 /* If path is not specified, default to "/sysroot" which is what we generally expect initrds
1862 * to use */
1863 root = "/sysroot";
1864 else {
1865 if (!path_is_valid(root))
1866 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1867 "New root directory must be a valid path.");
b0c5f0e1 1868
5ae89ef3
LP		 1869 if (!path_is_absolute(root))
1870 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1871 "New root path '%s' is not absolute.", root);
b0c5f0e1
MY		 1872
1873 r = path_is_root(root);
1874 if (r < 0)
1875 return sd_bus_error_set_errnof(error, r,
1876 "Failed to check if new root directory '%s' is the same as old root: %m",
1877 root);
1878 if (r > 0)
5ae89ef3
LP		 1879 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1880 "New root directory cannot be the old root directory.");
1881 }
c0576cd6 1882
718db961 1883 /* Safety check */
4da159bc
MY		 1884 if (!in_initrd())
1885 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1886 "Not in initrd, refusing switch-root operation.");
1887
1888 r = path_is_os_tree(root);
1889 if (r < 0)
1890 return sd_bus_error_set_errnof(error, r,
1891 "Failed to determine whether root path '%s' contains an OS tree: %m",
1892 root);
1893 if (r == 0)
1894 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1895 "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1896 root);
1897
1898 if (!isempty(init)) {
5f4c9c27
LP		 1899 if (!path_is_valid(init))
1900 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1901 "Path to init binary '%s' is not a valid path.", init);
1902
718db961 1903 if (!path_is_absolute(init))
cb31470f
ZJS		 1904 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1905 "Path to init binary '%s' not absolute.", init);
c0576cd6 1906
f461a28d 1907 r = chase_and_access(init, root, CHASE_PREFIX_ROOT, X_OK, NULL);
e10086ac
LP		 1908 if (r == -EACCES)
1909 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1910 "Init binary %s is not executable.", init);
710028b4 1911 if (r < 0)
cb31470f
ZJS		 1912 return sd_bus_error_set_errnof(error, r,
1913 "Could not resolve init executable %s: %m", init);
718db961
LP		 1914 }
1915
1916 rt = strdup(root);
1917 if (!rt)
ebcf1f97 1918 return -ENOMEM;
718db961
LP		 1919
1920 if (!isempty(init)) {
1921 ri = strdup(init);
87a19bfe 1922 if (!ri)
ebcf1f97 1923 return -ENOMEM;
718db961 1924 }
c0576cd6 1925
87a19bfe
YW		 1926 free_and_replace(m->switch_root, rt);
1927 free_and_replace(m->switch_root_init, ri);
c0576cd6 1928
af41e508 1929 m->objective = MANAGER_SWITCH_ROOT;
92b315df 1930
df2d202e 1931 return sd_bus_reply_method_return(message, NULL);
718db961 1932}
c0576cd6 1933
19070062 1934static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1935 _cleanup_strv_free_ char **plus = NULL;
99534007 1936 Manager *m = ASSERT_PTR(userdata);
718db961 1937 int r;
c0576cd6 1938
718db961 1939 assert(message);
cad45ba1 1940
8a188de9 1941 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1942 if (r < 0)
1943 return r;
c0576cd6 1944
718db961
LP		 1945 r = sd_bus_message_read_strv(message, &plus);
1946 if (r < 0)
ebcf1f97 1947 return r;
718db961 1948 if (!strv_env_is_valid(plus))
1b09b81c 1949 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
c0576cd6 1950
1d22e906
LP		 1951 r = bus_verify_set_environment_async(m, message, error);
1952 if (r < 0)
1953 return r;
1954 if (r == 0)
1955 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1956
1ad6e8b3 1957 r = manager_client_environment_modify(m, NULL, plus);
718db961 1958 if (r < 0)
ebcf1f97 1959 return r;
c0576cd6 1960
df2d202e 1961 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1962}
1963
19070062 1964static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1965 _cleanup_strv_free_ char **minus = NULL;
99534007 1966 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1967 int r;
1968
718db961 1969 assert(message);
718db961 1970
8a188de9 1971 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1972 if (r < 0)
1973 return r;
c0576cd6 1974
718db961
LP		 1975 r = sd_bus_message_read_strv(message, &minus);
1976 if (r < 0)
ebcf1f97 1977 return r;
718db961
LP		 1978
1979 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1980 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1981 "Invalid environment variable names or assignments");
718db961 1982
1d22e906
LP		 1983 r = bus_verify_set_environment_async(m, message, error);
1984 if (r < 0)
1985 return r;
1986 if (r == 0)
1987 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1988
1ad6e8b3 1989 r = manager_client_environment_modify(m, minus, NULL);
718db961 1990 if (r < 0)
ebcf1f97 1991 return r;
718db961 1992
df2d202e 1993 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1994}
1995
19070062 1996static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1997 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
99534007 1998 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1999 int r;
2000
718db961 2001 assert(message);
718db961 2002
8a188de9 2003 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 2004 if (r < 0)
2005 return r;
718db961 2006
eb6c7d20 2007 r = sd_bus_message_read_strv(message, &minus);
718db961 2008 if (r < 0)
ebcf1f97 2009 return r;
718db961 2010
eb6c7d20 2011 r = sd_bus_message_read_strv(message, &plus);
718db961 2012 if (r < 0)
ebcf1f97 2013 return r;
718db961 2014
718db961 2015 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 2016 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2017 "Invalid environment variable names or assignments");
eb6c7d20 2018 if (!strv_env_is_valid(plus))
cb31470f
ZJS		 2019 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2020 "Invalid environment assignments");
718db961 2021
1d22e906
LP		 2022 r = bus_verify_set_environment_async(m, message, error);
2023 if (r < 0)
2024 return r;
2025 if (r == 0)
2026 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2027
1ad6e8b3 2028 r = manager_client_environment_modify(m, minus, plus);
718db961 2029 if (r < 0)
ebcf1f97 2030 return r;
718db961 2031
df2d202e 2032 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 2033}
2034
287419c1 2035static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2036 Manager *m = ASSERT_PTR(userdata);
29206d46 2037 uint8_t code;
287419c1
AC		 2038 int r;
2039
2040 assert(message);
287419c1
AC		 2041
2042 r = mac_selinux_access_check(message, "exit", error);
2043 if (r < 0)
2044 return r;
2045
2046 r = sd_bus_message_read_basic(message, 'y', &code);
2047 if (r < 0)
2048 return r;
2049
287419c1
AC		 2050 m->return_value = code;
2051
2052 return sd_bus_reply_method_return(message, NULL);
2053}
2054
29206d46 2055static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2056 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 2057 const char *name;
2058 uid_t uid;
2059 int r;
2060
2061 assert(message);
29206d46
LP		 2062
2063 r = sd_bus_message_read_basic(message, 's', &name);
2064 if (r < 0)
2065 return r;
2066
2067 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2068 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2069 "Dynamic users are only supported in the system instance.");
7a8867ab 2070 if (!valid_user_group_name(name, VALID_USER_RELAX))
cb31470f
ZJS		 2071 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2072 "User name invalid: %s", name);
29206d46
LP		 2073
2074 r = dynamic_user_lookup_name(m, name, &uid);
2075 if (r == -ESRCH)
cb31470f
ZJS		 2076 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2077 "Dynamic user %s does not exist.", name);
29206d46
LP		 2078 if (r < 0)
2079 return r;
2080
2081 return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
2082}
2083
2084static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2085 _cleanup_free_ char *name = NULL;
99534007 2086 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 2087 uid_t uid;
2088 int r;
2089
2090 assert(message);
29206d46 2091
60d0a509 2092 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
29206d46
LP		 2093 r = sd_bus_message_read_basic(message, 'u', &uid);
2094 if (r < 0)
2095 return r;
2096
2097 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2098 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2099 "Dynamic users are only supported in the system instance.");
29206d46 2100 if (!uid_is_valid(uid))
cb31470f
ZJS		 2101 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2102 "User ID invalid: " UID_FMT, uid);
29206d46
LP		 2103
2104 r = dynamic_user_lookup_uid(m, uid, &name);
2105 if (r == -ESRCH)
cb31470f
ZJS		 2106 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2107 "Dynamic user ID " UID_FMT " does not exist.", uid);
29206d46
LP		 2108 if (r < 0)
2109 return r;
2110
2111 return sd_bus_reply_method_return(message, "s", name);
2112}
2113
f9bfa696
YW		 2114static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2115 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 2116 Manager *m = ASSERT_PTR(userdata);
f9bfa696 2117 DynamicUser *d;
f9bfa696
YW		 2118 int r;
2119
2120 assert(message);
f9bfa696
YW		 2121
2122 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
2123
2124 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2125 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2126 "Dynamic users are only supported in the system instance.");
f9bfa696
YW		 2127
2128 r = sd_bus_message_new_method_return(message, &reply);
2129 if (r < 0)
2130 return r;
2131
2132 r = sd_bus_message_open_container(reply, 'a', "(us)");
2133 if (r < 0)
2134 return r;
2135
90e74a66 2136 HASHMAP_FOREACH(d, m->dynamic_users) {
f9bfa696
YW		 2137 uid_t uid;
2138
2139 r = dynamic_user_current(d, &uid);
2140 if (r == -EAGAIN) /* not realized yet? */
2141 continue;
2142 if (r < 0)
cb31470f
ZJS		 2143 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED,
2144 "Failed to look up a dynamic user.");
f9bfa696
YW		 2145
2146 r = sd_bus_message_append(reply, "(us)", uid, d->name);
2147 if (r < 0)
2148 return r;
2149 }
2150
2151 r = sd_bus_message_close_container(reply);
2152 if (r < 0)
2153 return r;
2154
2155 return sd_bus_send(NULL, reply, NULL);
2156}
2157
70666e28 2158static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2159 Manager *m = ASSERT_PTR(userdata);
70666e28
ZJS		 2160 int r;
2161
2162 assert(message);
70666e28
ZJS		 2163
2164 r = mac_selinux_access_check(message, "start", error);
2165 if (r < 0)
2166 return r;
2167
2168 r = bus_verify_manage_units_async(m, message, error);
2169 if (r < 0)
2170 return r;
2171 if (r == 0)
2172 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2173
28e5e1e9 2174 log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS));
70666e28
ZJS		 2175
2176 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2177 r = sd_bus_message_new_method_return(message, &reply);
2178 if (r < 0)
2179 return r;
2180
2181 r = sd_bus_message_open_container(reply, 'a', "o");
2182 if (r < 0)
2183 return r;
2184
2185 Unit *u;
2186 char *k;
2187 int ret = 0;
2188 HASHMAP_FOREACH_KEY(u, k, m->units) {
2189 /* ignore aliases */
2190 if (u->id != k)
2191 continue;
2192
2193 BusUnitQueueFlags flags;
2194 if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RESTART))
2195 flags = 0;
2196 else if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RELOAD))
2197 flags = BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE;
2198 else
2199 continue;
2200
2201 r = mac_selinux_unit_access_check(u, message, "start", error);
2202 if (r >= 0)
2203 r = bus_unit_queue_job_one(message, u,
2204 JOB_TRY_RESTART, JOB_FAIL, flags,
2205 reply, error);
bb44fd07
ZJS		 2206 if (ERRNO_IS_NEG_RESOURCE(r))
2207 return r;
70666e28 2208 if (r < 0) {
70666e28
ZJS		 2209 if (ret >= 0)
2210 ret = r;
2211 sd_bus_error_free(error);
2212 }
2213 }
2214
2215 if (ret < 0)
2216 return sd_bus_error_set_errnof(error, ret,
2217 "Failed to enqueue some jobs, see logs for details: %m");
2218
2219 r = sd_bus_message_close_container(reply);
2220 if (r < 0)
2221 return r;
2222
2223 return sd_bus_send(NULL, reply, NULL);
2224}
2225
313fe66f 2226static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 2227 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 2228 Manager *m = ASSERT_PTR(userdata);
718db961 2229 UnitFileList *item;
5d2a48da 2230 _cleanup_hashmap_free_ Hashmap *h = NULL;
718db961
LP		 2231 int r;
2232
718db961 2233 assert(message);
718db961 2234
283868e1
SW		 2235 /* Anyone can call this method */
2236
8a188de9 2237 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2238 if (r < 0)
2239 return r;
718db961 2240
df2d202e 2241 r = sd_bus_message_new_method_return(message, &reply);
718db961 2242 if (r < 0)
ebcf1f97 2243 return r;
c0576cd6 2244
066ba68e 2245 h = hashmap_new(&unit_file_list_hash_ops_free);
718db961 2246 if (!h)
ebcf1f97 2247 return -ENOMEM;
c0576cd6 2248
4870133b 2249 r = unit_file_get_list(m->runtime_scope, NULL, h, states, patterns);
ebcf1f97 2250 if (r < 0)
066ba68e 2251 return r;
718db961
LP		 2252
2253 r = sd_bus_message_open_container(reply, 'a', "(ss)");
ebcf1f97 2254 if (r < 0)
066ba68e 2255 return r;
718db961 2256
90e74a66 2257 HASHMAP_FOREACH(item, h) {
718db961
LP		 2258
2259 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
ebcf1f97 2260 if (r < 0)
066ba68e 2261 return r;
718db961 2262 }
c0576cd6 2263
718db961
LP		 2264 r = sd_bus_message_close_container(reply);
2265 if (r < 0)
ebcf1f97 2266 return r;
8d0e38a2 2267
9030ca46 2268 return sd_bus_send(NULL, reply, NULL);
718db961 2269}
99504dd4 2270
313fe66f 2271static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2272 return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
2273}
2274
2275static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2276 _cleanup_strv_free_ char **states = NULL;
2277 _cleanup_strv_free_ char **patterns = NULL;
2278 int r;
2279
2280 r = sd_bus_message_read_strv(message, &states);
2281 if (r < 0)
2282 return r;
2283
2284 r = sd_bus_message_read_strv(message, &patterns);
2285 if (r < 0)
2286 return r;
2287
2288 return list_unit_files_by_patterns(message, userdata, error, states, patterns);
2289}
2290
19070062 2291static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2292 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2293 const char *name;
2294 UnitFileState state;
718db961 2295 int r;
99504dd4 2296
718db961 2297 assert(message);
8e2af478 2298
283868e1
SW		 2299 /* Anyone can call this method */
2300
8a188de9 2301 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2302 if (r < 0)
2303 return r;
8e2af478 2304
718db961
LP		 2305 r = sd_bus_message_read(message, "s", &name);
2306 if (r < 0)
ebcf1f97 2307 return r;
8e2af478 2308
4870133b 2309 r = unit_file_get_state(m->runtime_scope, NULL, name, &state);
0ec0deaa
LP		 2310 if (r < 0)
2311 return r;
8e2af478 2312
df2d202e 2313 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
718db961 2314}
8e2af478 2315
19070062 2316static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 2317 _cleanup_free_ char *default_target = NULL;
99534007 2318 Manager *m = ASSERT_PTR(userdata);
718db961 2319 int r;
c2756a68 2320
718db961 2321 assert(message);
c2756a68 2322
283868e1
SW		 2323 /* Anyone can call this method */
2324
8a188de9 2325 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2326 if (r < 0)
2327 return r;
c2756a68 2328
4870133b 2329 r = unit_file_get_default(m->runtime_scope, NULL, &default_target);
7c78a193
DT		 2330 if (r == -ERFKILL)
2331 sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
718db961 2332 if (r < 0)
ebcf1f97 2333 return r;
c2756a68 2334
df2d202e 2335 return sd_bus_reply_method_return(message, "s", default_target);
718db961 2336}
c2756a68 2337
8f8f05a9 2338static int send_unit_files_changed(sd_bus *bus, void *userdata) {
4afd3348 2339 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 2340 int r;
2341
2342 assert(bus);
2343
cb31470f
ZJS		 2344 r = sd_bus_message_new_signal(bus, &message,
2345 "/org/freedesktop/systemd1",
2346 "org.freedesktop.systemd1.Manager",
2347 "UnitFilesChanged");
718db961
LP		 2348 if (r < 0)
2349 return r;
2350
8f8f05a9 2351 return sd_bus_send(bus, message, NULL);
718db961
LP		 2352}
2353
af3d8113
ZJS		 2354/* Create an error reply, using the error information from changes[]
2355 * if possible, and fall back to generating an error from error code c.
2356 * The error message only describes the first error.
af3d8113
ZJS		 2357 */
2358static int install_error(
2359 sd_bus_error *error,
2360 int c,
cd44ec5a 2361 InstallChange *changes,
da6053d0
LP		 2362 size_t n_changes) {
2363
f8888b9a 2364 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
8e20adca 2365
fe96c0f8 2366 for (size_t i = 0; i < n_changes; i++)
637d6e5b 2367
5ad58fea 2368 /* When making changes here, make sure to also change install_changes_dump() in install.c. */
637d6e5b 2369
5ad58fea 2370 switch (changes[i].type) {
f8662fee
LP		 2371 case 0 ... _INSTALL_CHANGE_TYPE_MAX: /* not errors */
2372 break;
637d6e5b 2373
af3d8113
ZJS		 2374 case -EEXIST:
2375 if (changes[i].source)
f8888b9a
DT		 2376 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2377 "File %s already exists and is a symlink to %s.",
2378 changes[i].path, changes[i].source);
2379 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2380 "File %s already exists.",
2381 changes[i].path);
637d6e5b 2382
af3d8113 2383 case -ERFKILL:
f8888b9a
DT		 2384 return sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED,
2385 "Unit file %s is masked.", changes[i].path);
637d6e5b 2386
af3d8113 2387 case -EADDRNOTAVAIL:
f8888b9a
DT		 2388 return sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED,
2389 "Unit %s is transient or generated.", changes[i].path);
637d6e5b 2390
a6f318a5 2391 case -ETXTBSY:
f8888b9a
DT		 2392 return sd_bus_error_setf(error, BUS_ERROR_UNIT_BAD_PATH,
2393 "File %s is under the systemd unit hierarchy already.", changes[i].path);
a6f318a5 2394
c89d0c3b 2395 case -EBADSLT:
f8888b9a
DT		 2396 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2397 "Invalid specifier in %s.", changes[i].path);
c89d0c3b
JM		 2398
2399 case -EIDRM:
f8888b9a
DT		 2400 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2401 "Destination unit %s is a non-template unit.", changes[i].path);
c89d0c3b 2402
d7ceaf72 2403 case -EUCLEAN:
f8888b9a
DT		 2404 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2405 "\"%s\" is not a valid unit name.",
2406 changes[i].path);
d7ceaf72 2407
af3d8113 2408 case -ELOOP:
f8888b9a
DT		 2409 return sd_bus_error_setf(error, BUS_ERROR_UNIT_LINKED,
2410 "Refusing to operate on alias name or linked unit file: %s",
2411 changes[i].path);
637d6e5b 2412
c89d0c3b
JM		 2413 case -EXDEV:
2414 if (changes[i].source)
f8888b9a
DT		 2415 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2416 "Cannot alias %s as %s.",
2417 changes[i].source, changes[i].path);
2418 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2419 "Invalid unit reference %s.", changes[i].path);
c89d0c3b 2420
637d6e5b 2421 case -ENOENT:
f8888b9a
DT		 2422 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
2423 "Unit file %s does not exist.", changes[i].path);
637d6e5b 2424
c89d0c3b 2425 case -EUNATCH:
f8888b9a
DT		 2426 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2427 "Cannot resolve specifiers in %s.", changes[i].path);
c89d0c3b 2428
af3d8113 2429 default:
f8662fee 2430 assert(changes[i].type < 0); /* other errors */
f8888b9a 2431 return sd_bus_error_set_errnof(error, changes[i].type, "File %s: %m", changes[i].path);
af3d8113 2432 }
8e20adca 2433
f8888b9a 2434 return c < 0 ? c : -EINVAL;
8e20adca
LP		 2435}
2436
cd44ec5a 2437static int reply_install_changes_and_free(
637d6e5b
LP		 2438 Manager *m,
2439 sd_bus_message *message,
2440 int carries_install_info,
cd44ec5a 2441 InstallChange *changes,
da6053d0 2442 size_t n_changes,
637d6e5b
LP		 2443 sd_bus_error *error) {
2444
2445 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2446 bool bad = false, good = false;
637d6e5b
LP		 2447 int r;
2448
8c2d0d3a
LP		 2449 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2450
cd44ec5a 2451 if (install_changes_have_modification(changes, n_changes)) {
637d6e5b
LP		 2452 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
2453 if (r < 0)
2454 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
2455 }
2456
2457 r = sd_bus_message_new_method_return(message, &reply);
2458 if (r < 0)
8c2d0d3a 2459 return r;
637d6e5b
LP		 2460
2461 if (carries_install_info >= 0) {
2462 r = sd_bus_message_append(reply, "b", carries_install_info);
2463 if (r < 0)
8c2d0d3a 2464 return r;
637d6e5b
LP		 2465 }
2466
2467 r = sd_bus_message_open_container(reply, 'a', "(sss)");
2468 if (r < 0)
8c2d0d3a 2469 return r;
637d6e5b 2470
fe96c0f8 2471 for (size_t i = 0; i < n_changes; i++) {
637d6e5b 2472
f8662fee 2473 if (changes[i].type < 0) {
637d6e5b
LP		 2474 bad = true;
2475 continue;
2476 }
2477
2478 r = sd_bus_message_append(
2479 reply, "(sss)",
f8662fee 2480 install_change_type_to_string(changes[i].type),
637d6e5b
LP		 2481 changes[i].path,
2482 changes[i].source);
2483 if (r < 0)
8c2d0d3a 2484 return r;
637d6e5b
LP		 2485
2486 good = true;
2487 }
2488
cb31470f
ZJS		 2489 /* If there was a failed change, and no successful change, then return the first failure as proper
2490 * method call error. */
637d6e5b 2491 if (bad && !good)
8c2d0d3a 2492 return install_error(error, 0, TAKE_PTR(changes), n_changes);
637d6e5b
LP		 2493
2494 r = sd_bus_message_close_container(reply);
2495 if (r < 0)
8c2d0d3a 2496 return r;
637d6e5b 2497
637d6e5b 2498 return sd_bus_send(NULL, reply, NULL);
637d6e5b
LP		 2499}
2500
718db961 2501static int method_enable_unit_files_generic(
718db961 2502 sd_bus_message *message,
d309c1c3 2503 Manager *m,
4870133b 2504 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
ebcf1f97
LP		 2505 bool carries_install_info,
2506 sd_bus_error *error) {
718db961
LP		 2507
2508 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2509 InstallChange *changes = NULL;
da6053d0 2510 size_t n_changes = 0;
b3796dd8 2511 UnitFileFlags flags;
83654007 2512 int r;
718db961 2513
718db961
LP		 2514 assert(message);
2515 assert(m);
cad45ba1 2516
718db961
LP		 2517 r = sd_bus_message_read_strv(message, &l);
2518 if (r < 0)
ebcf1f97 2519 return r;
90bb85e1 2520
83654007
LB		 2521 if (sd_bus_message_is_method_call(message, NULL, "EnableUnitFilesWithFlags")) {
2522 uint64_t raw_flags;
d309c1c3 2523
83654007
LB		 2524 r = sd_bus_message_read(message, "t", &raw_flags);
2525 if (r < 0)
2526 return r;
2527 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0)
2528 return -EINVAL;
2529 flags = raw_flags;
2530 } else {
2531 int runtime, force;
2532
2533 r = sd_bus_message_read(message, "bb", &runtime, &force);
2534 if (r < 0)
2535 return r;
2536 flags = unit_file_bools_to_flags(runtime, force);
2537 }
b3796dd8 2538
1d22e906
LP		 2539 r = bus_verify_manage_unit_files_async(m, message, error);
2540 if (r < 0)
2541 return r;
2542 if (r == 0)
2543 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2544
4870133b 2545 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
a82b8b3d 2546 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2547 if (r < 0)
2548 return install_error(error, r, changes, n_changes);
718db961 2549
cd44ec5a 2550 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2551}
c87eba54 2552
83654007 2553static int method_enable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2554 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
83654007
LB		 2555}
2556
19070062 2557static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2558 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
718db961 2559}
ea430986 2560
19070062 2561static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2562 return method_enable_unit_files_generic(message, userdata, unit_file_reenable, /* carries_install_info = */ true, error);
718db961
LP		 2563}
2564
19070062 2565static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2566 return method_enable_unit_files_generic(message, userdata, unit_file_link, /* carries_install_info = */ false, error);
718db961
LP		 2567}
2568
4870133b 2569static int unit_file_preset_without_mode(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char **files, InstallChange **changes, size_t *n_changes) {
b3796dd8 2570 return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
d309c1c3
LP		 2571}
2572
19070062 2573static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2574 return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, /* carries_install_info = */ true, error);
718db961
LP		 2575}
2576
19070062 2577static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2578 return method_enable_unit_files_generic(message, userdata, unit_file_mask, /* carries_install_info = */ false, error);
718db961 2579}
ea430986 2580
19070062 2581static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d309c1c3
LP		 2582
2583 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2584 InstallChange *changes = NULL;
da6053d0 2585 size_t n_changes = 0;
99534007 2586 Manager *m = ASSERT_PTR(userdata);
8331b221 2587 UnitFilePresetMode preset_mode;
d309c1c3 2588 int runtime, force, r;
b3796dd8 2589 UnitFileFlags flags;
d309c1c3
LP		 2590 const char *mode;
2591
d309c1c3 2592 assert(message);
d309c1c3
LP		 2593
2594 r = sd_bus_message_read_strv(message, &l);
2595 if (r < 0)
2596 return r;
2597
2598 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2599 if (r < 0)
2600 return r;
2601
b3796dd8
JS		 2602 flags = unit_file_bools_to_flags(runtime, force);
2603
d309c1c3 2604 if (isempty(mode))
8331b221 2605 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2606 else {
8331b221
ZJS		 2607 preset_mode = unit_file_preset_mode_from_string(mode);
2608 if (preset_mode < 0)
d309c1c3
LP		 2609 return -EINVAL;
2610 }
2611
1d22e906
LP		 2612 r = bus_verify_manage_unit_files_async(m, message, error);
2613 if (r < 0)
2614 return r;
2615 if (r == 0)
2616 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2617
4870133b 2618 r = unit_file_preset(m->runtime_scope, flags, NULL, l, preset_mode, &changes, &n_changes);
a82b8b3d 2619 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2620 if (r < 0)
2621 return install_error(error, r, changes, n_changes);
d309c1c3 2622
cd44ec5a 2623 return reply_install_changes_and_free(m, message, r, changes, n_changes, error);
d309c1c3
LP		 2624}
2625
718db961 2626static int method_disable_unit_files_generic(
718db961 2627 sd_bus_message *message,
596fc263 2628 Manager *m,
4870133b 2629 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
bf1bea43 2630 bool carries_install_info,
ebcf1f97 2631 sd_bus_error *error) {
718db961
LP		 2632
2633 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2634 InstallChange *changes = NULL;
83654007 2635 UnitFileFlags flags;
da6053d0 2636 size_t n_changes = 0;
83654007 2637 int r;
718db961 2638
718db961
LP		 2639 assert(message);
2640 assert(m);
2641
df823e23 2642 r = sd_bus_message_read_strv(message, &l);
ebcf1f97
LP		 2643 if (r < 0)
2644 return r;
718db961 2645
bf1bea43
MY		 2646 if (sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlags") ||
2647 sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlagsAndInstallInfo")) {
83654007
LB		 2648 uint64_t raw_flags;
2649
2650 r = sd_bus_message_read(message, "t", &raw_flags);
2651 if (r < 0)
2652 return r;
2653 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0 ||
2654 FLAGS_SET(raw_flags, UNIT_FILE_FORCE))
2655 return -EINVAL;
2656 flags = raw_flags;
2657 } else {
2658 int runtime;
2659
2660 r = sd_bus_message_read(message, "b", &runtime);
2661 if (r < 0)
2662 return r;
2663 flags = unit_file_bools_to_flags(runtime, false);
2664 }
718db961 2665
1d22e906
LP		 2666 r = bus_verify_manage_unit_files_async(m, message, error);
2667 if (r < 0)
2668 return r;
2669 if (r == 0)
2670 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2671
4870133b 2672 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
a82b8b3d 2673 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2674 if (r < 0)
2675 return install_error(error, r, changes, n_changes);
718db961 2676
bf1bea43 2677 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2678}
ea430986 2679
83654007 2680static int method_disable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43
MY		 2681 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
2682}
2683
2684static int method_disable_unit_files_with_flags_and_install_info(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2685 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ true, error);
83654007
LB		 2686}
2687
19070062 2688static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2689 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
ea430986
LP		 2690}
2691
19070062 2692static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2693 return method_disable_unit_files_generic(message, userdata, unit_file_unmask, /* carries_install_info = */ false, error);
718db961
LP		 2694}
2695
344ca755
LP		 2696static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2697 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2698 InstallChange *changes = NULL;
da6053d0 2699 size_t n_changes = 0;
99534007 2700 Manager *m = ASSERT_PTR(userdata);
344ca755
LP		 2701 int r;
2702
2703 assert(message);
344ca755
LP		 2704
2705 r = sd_bus_message_read_strv(message, &l);
2706 if (r < 0)
2707 return r;
2708
2709 r = bus_verify_manage_unit_files_async(m, message, error);
2710 if (r < 0)
2711 return r;
2712 if (r == 0)
2713 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2714
4870133b 2715 r = unit_file_revert(m->runtime_scope, NULL, l, &changes, &n_changes);
a82b8b3d 2716 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2717 if (r < 0)
2718 return install_error(error, r, changes, n_changes);
344ca755 2719
cd44ec5a 2720 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
344ca755
LP		 2721}
2722
19070062 2723static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2724 InstallChange *changes = NULL;
da6053d0 2725 size_t n_changes = 0;
99534007 2726 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2727 const char *name;
2728 int force, r;
2729
718db961 2730 assert(message);
718db961 2731
1d22e906 2732 r = mac_selinux_access_check(message, "enable", error);
283868e1
SW		 2733 if (r < 0)
2734 return r;
283868e1 2735
1d22e906 2736 r = sd_bus_message_read(message, "sb", &name, &force);
ebcf1f97
LP		 2737 if (r < 0)
2738 return r;
718db961 2739
1d22e906 2740 r = bus_verify_manage_unit_files_async(m, message, error);
718db961 2741 if (r < 0)
ebcf1f97 2742 return r;
1d22e906
LP		 2743 if (r == 0)
2744 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
718db961 2745
4870133b 2746 r = unit_file_set_default(m->runtime_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
af3d8113
ZJS		 2747 if (r < 0)
2748 return install_error(error, r, changes, n_changes);
718db961 2749
cd44ec5a 2750 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
718db961
LP		 2751}
2752
19070062 2753static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2754 InstallChange *changes = NULL;
da6053d0 2755 size_t n_changes = 0;
99534007 2756 Manager *m = ASSERT_PTR(userdata);
8331b221 2757 UnitFilePresetMode preset_mode;
d309c1c3 2758 const char *mode;
b3796dd8 2759 UnitFileFlags flags;
d309c1c3
LP		 2760 int force, runtime, r;
2761
d309c1c3 2762 assert(message);
d309c1c3 2763
8a188de9 2764 r = mac_selinux_access_check(message, "enable", error);
d309c1c3
LP		 2765 if (r < 0)
2766 return r;
2767
2768 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2769 if (r < 0)
2770 return r;
2771
b3796dd8
JS		 2772 flags = unit_file_bools_to_flags(runtime, force);
2773
d309c1c3 2774 if (isempty(mode))
8331b221 2775 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2776 else {
8331b221
ZJS		 2777 preset_mode = unit_file_preset_mode_from_string(mode);
2778 if (preset_mode < 0)
d309c1c3
LP		 2779 return -EINVAL;
2780 }
2781
1d22e906
LP		 2782 r = bus_verify_manage_unit_files_async(m, message, error);
2783 if (r < 0)
2784 return r;
2785 if (r == 0)
2786 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2787
4870133b 2788 r = unit_file_preset_all(m->runtime_scope, flags, NULL, preset_mode, &changes, &n_changes);
a82b8b3d 2789 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2790 if (r < 0)
2791 return install_error(error, r, changes, n_changes);
d309c1c3 2792
cd44ec5a 2793 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
d309c1c3
LP		 2794}
2795
19070062 2796static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
e94937df 2797 _cleanup_strv_free_ char **l = NULL;
99534007 2798 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2799 InstallChange *changes = NULL;
da6053d0 2800 size_t n_changes = 0;
e94937df 2801 int runtime, force, r;
596fc263 2802 char *target, *type;
e94937df 2803 UnitDependency dep;
b3796dd8 2804 UnitFileFlags flags;
e94937df 2805
e94937df 2806 assert(message);
e94937df
LN		 2807
2808 r = bus_verify_manage_unit_files_async(m, message, error);
2809 if (r < 0)
2810 return r;
2811 if (r == 0)
2812 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2813
2814 r = sd_bus_message_read_strv(message, &l);
2815 if (r < 0)
2816 return r;
2817
2818 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2819 if (r < 0)
2820 return r;
2821
b3796dd8
JS		 2822 flags = unit_file_bools_to_flags(runtime, force);
2823
e94937df
LN		 2824 dep = unit_dependency_from_string(type);
2825 if (dep < 0)
2826 return -EINVAL;
2827
4870133b 2828 r = unit_file_add_dependency(m->runtime_scope, flags, NULL, l, target, dep, &changes, &n_changes);
a82b8b3d 2829 m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
af3d8113
ZJS		 2830 if (r < 0)
2831 return install_error(error, r, changes, n_changes);
e94937df 2832
cd44ec5a 2833 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
e94937df
LN		 2834}
2835
3b3557c4
JS		 2836static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2837 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
47c57b48 2838 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2839 InstallChange *changes = NULL;
da6053d0 2840 size_t n_changes = 0, i;
3b3557c4 2841 const char *name;
3b3557c4
JS		 2842 int runtime, r;
2843
2a711edd
DT		 2844 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2845
3b3557c4
JS		 2846 r = sd_bus_message_read(message, "sb", &name, &runtime);
2847 if (r < 0)
2848 return r;
2849
2850 r = sd_bus_message_new_method_return(message, &reply);
2851 if (r < 0)
2852 return r;
2853
2854 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2855 if (r < 0)
2856 return r;
2857
4870133b 2858 r = unit_file_disable(m->runtime_scope,
47c57b48
YW		 2859 UNIT_FILE_DRY_RUN | (runtime ? UNIT_FILE_RUNTIME : 0),
2860 NULL, STRV_MAKE(name), &changes, &n_changes);
2a711edd
DT		 2861 if (r < 0)
2862 return log_error_errno(r, "Failed to get file links for %s: %m", name);
3b3557c4
JS		 2863
2864 for (i = 0; i < n_changes; i++)
f8662fee 2865 if (changes[i].type == INSTALL_CHANGE_UNLINK) {
3b3557c4
JS		 2866 r = sd_bus_message_append(reply, "s", changes[i].path);
2867 if (r < 0)
2a711edd 2868 return r;
3b3557c4
JS		 2869 }
2870
2871 r = sd_bus_message_close_container(reply);
2872 if (r < 0)
2a711edd 2873 return r;
a12ba535 2874
2a711edd 2875 return sd_bus_send(NULL, reply, NULL);
3b3557c4
JS		 2876}
2877
15ea79f8 2878static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2879 Manager *m = ASSERT_PTR(userdata);
15ea79f8
LP		 2880 uint32_t id;
2881 Job *j;
2882 int r;
2883
2884 assert(message);
15ea79f8
LP		 2885
2886 r = sd_bus_message_read(message, "u", &id);
2887 if (r < 0)
2888 return r;
2889
2890 j = manager_get_job(m, id);
2891 if (!j)
2892 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2893
2894 return bus_job_method_get_waiting_jobs(message, j, error);
2895}
2896
c20076a8 2897static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2898 Manager *m = ASSERT_PTR(userdata);
c20076a8
LP		 2899 const char *name;
2900 Unit *u;
2901 int r;
2902
2903 assert(message);
c20076a8
LP		 2904
2905 r = sd_bus_message_read(message, "s", &name);
2906 if (r < 0)
2907 return r;
2908
2909 r = bus_get_unit_by_name(m, message, name, &u, error);
2910 if (r < 0)
2911 return r;
2912
2913 if (u->type != UNIT_SCOPE)
cb31470f
ZJS		 2914 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2915 "Unit '%s' is not a scope unit, refusing.", name);
c20076a8
LP		 2916
2917 return bus_scope_method_abandon(message, u, error);
2918}
2919
0bb007f7 2920static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2921 Manager *m = ASSERT_PTR(userdata);
0bb007f7
FB		 2922 ShowStatus mode = _SHOW_STATUS_INVALID;
2923 const char *t;
2924 int r;
2925
0bb007f7
FB		 2926 assert(message);
2927
4db62561
ZJS		 2928 r = mac_selinux_access_check(message, "reload", error);
2929 if (r < 0)
2930 return r;
2931
2932 r = bus_verify_set_environment_async(m, message, error);
2933 if (r < 0)
2934 return r;
2935 if (r == 0)
2936 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2937
0bb007f7
FB		 2938 r = sd_bus_message_read(message, "s", &t);
2939 if (r < 0)
2940 return r;
2941
2942 if (!isempty(t)) {
2943 mode = show_status_from_string(t);
2944 if (mode < 0)
cb31470f
ZJS		 2945 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2946 "Invalid show status '%s'", t);
0bb007f7
FB		 2947 }
2948
43bba15a 2949 manager_override_show_status(m, mode, "bus");
0bb007f7
FB		 2950
2951 return sd_bus_reply_method_return(message, NULL);
2952}
2953
2ea24611
LP		 2954static int method_dump_unit_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2955 return method_generic_unit_operation(message, userdata, error, bus_service_method_dump_file_descriptor_store, 0);
2956}
2957
718db961
LP		 2958const sd_bus_vtable bus_manager_vtable[] = {
2959 SD_BUS_VTABLE_START(0),
2960
556089dc
LP		 2961 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2962 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2963 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1257274a 2964 SD_BUS_PROPERTY("ConfidentialVirtualization", "s", property_get_confidential_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
7452394e 2965 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2966 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
9f9f0342
LP		 2967 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
2968 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
2969 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
2970 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
2971 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
2972 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2973 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2974 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2975 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2976 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2977 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2978 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
49fbe940 2979 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD]), SD_BUS_VTABLE_PROPERTY_CONST),
665a9774
YW		 2980 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2981 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2982 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2983 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2984 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2985 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
25141692
LP		 2986 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
2987 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3ff52e8f
YW		 2988 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
2989 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2990 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
718db961
LP		 2991 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
2992 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
2993 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1ad6e8b3 2994 SD_BUS_PROPERTY("Environment", "as", property_get_environment, 0, 0),
556089dc 2995 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
52d2566a 2996 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
a3c4eb07 2997 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
c9e120e0
LP		 2998 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, defaults.std_output), SD_BUS_VTABLE_PROPERTY_CONST),
2999 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, defaults.std_error), SD_BUS_VTABLE_PROPERTY_CONST),
3e911a0d
YW		 3000 SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3001 SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime, 0, 0),
3002 SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic, 0, 0),
986935cf 3003 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog, property_set_runtime_watchdog, 0, 0),
5717062e 3004 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog, property_set_pretimeout_watchdog, 0, 0),
aff3a9e1 3005 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor, property_set_pretimeout_watchdog_governor, 0, 0),
986935cf 3006 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, 0),
65224c1d 3007 /* The following item is an obsolete alias */
986935cf
FB		 3008 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, SD_BUS_VTABLE_HIDDEN),
3009 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog, property_set_kexec_watchdog, 0, 0),
2a12e32e 3010 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
b272b74d 3011 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
f755e3b7 3012 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
287419c1 3013 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
c9e120e0
LP		 3014 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3015 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3016 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
dc653bf4 3017 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec, 0, 0),
c9e120e0
LP		 3018 SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.device_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3019 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3020 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
c075f5fc 3021 /* The following two items are obsolete alias */
c9e120e0
LP		 3022 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
3023 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
3024 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, defaults.start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
3025 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3026 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3027 SD_BUS_PROPERTY("DefaultIOAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.io_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3028 SD_BUS_PROPERTY("DefaultIPAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.ip_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3029 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3030 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3031 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
3032 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
3033 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
3034 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
3035 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
3036 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
3037 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
3038 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
3039 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
3040 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
3041 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
3042 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
3043 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
3044 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
3045 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
3046 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
3047 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
3048 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
3049 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
3050 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
3051 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
3052 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
3053 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
3054 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
3055 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
3056 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
3057 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
3058 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
3059 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
3060 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
3061 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3062 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3063 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max, offsetof(Manager, defaults.tasks_max), 0),
3064 SD_BUS_PROPERTY("DefaultMemoryPressureThresholdUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.memory_pressure_threshold_usec), 0),
3065 SD_BUS_PROPERTY("DefaultMemoryPressureWatch", "s", bus_property_get_cgroup_pressure_watch, offsetof(Manager, defaults.memory_pressure_watch), 0),
eed67a30 3066 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
c9e120e0 3067 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy, offsetof(Manager, defaults.oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
d4a402e4 3068 SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
c44a285c 3069 SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 3070
a008b6d7 3071 SD_BUS_METHOD_WITH_ARGS("GetUnit",
3072 SD_BUS_ARGS("s", name),
3073 SD_BUS_RESULT("o", unit),
3074 method_get_unit,
3075 SD_BUS_VTABLE_UNPRIVILEGED),
3076 SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
3077 SD_BUS_ARGS("u", pid),
3078 SD_BUS_RESULT("o", unit),
3079 method_get_unit_by_pid,
3080 SD_BUS_VTABLE_UNPRIVILEGED),
3081 SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
3082 SD_BUS_ARGS("ay", invocation_id),
3083 SD_BUS_RESULT("o", unit),
3084 method_get_unit_by_invocation_id,
3085 SD_BUS_VTABLE_UNPRIVILEGED),
3086 SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
3087 SD_BUS_ARGS("s", cgroup),
3088 SD_BUS_RESULT("o", unit),
3089 method_get_unit_by_control_group,
3090 SD_BUS_VTABLE_UNPRIVILEGED),
e0e7bc82
LB		 3091 SD_BUS_METHOD_WITH_ARGS("GetUnitByPIDFD",
3092 SD_BUS_ARGS("h", pidfd),
3093 SD_BUS_RESULT("o", unit, "s", unit_id, "ay", invocation_id),
3094 method_get_unit_by_pidfd,
3095 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3096 SD_BUS_METHOD_WITH_ARGS("LoadUnit",
3097 SD_BUS_ARGS("s", name),
3098 SD_BUS_RESULT("o", unit),
3099 method_load_unit,
3100 SD_BUS_VTABLE_UNPRIVILEGED),
3101 SD_BUS_METHOD_WITH_ARGS("StartUnit",
3102 SD_BUS_ARGS("s", name, "s", mode),
3103 SD_BUS_RESULT("o", job),
3104 method_start_unit,
3105 SD_BUS_VTABLE_UNPRIVILEGED),
3106 SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
3107 SD_BUS_ARGS("s", name, "s", mode, "t", flags),
3108 SD_BUS_RESULT("o", job),
3109 method_start_unit,
3110 SD_BUS_VTABLE_UNPRIVILEGED),
3111 SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
3112 SD_BUS_ARGS("s", old_unit, "s", new_unit, "s", mode),
3113 SD_BUS_RESULT("o", job),
3114 method_start_unit_replace,
3115 SD_BUS_VTABLE_UNPRIVILEGED),
3116 SD_BUS_METHOD_WITH_ARGS("StopUnit",
3117 SD_BUS_ARGS("s", name, "s", mode),
3118 SD_BUS_RESULT("o", job),
3119 method_stop_unit,
3120 SD_BUS_VTABLE_UNPRIVILEGED),
3121 SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
3122 SD_BUS_ARGS("s", name, "s", mode),
3123 SD_BUS_RESULT("o", job),
3124 method_reload_unit,
3125 SD_BUS_VTABLE_UNPRIVILEGED),
3126 SD_BUS_METHOD_WITH_ARGS("RestartUnit",
3127 SD_BUS_ARGS("s", name, "s", mode),
3128 SD_BUS_RESULT("o", job),
3129 method_restart_unit,
3130 SD_BUS_VTABLE_UNPRIVILEGED),
3131 SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
3132 SD_BUS_ARGS("s", name, "s", mode),
3133 SD_BUS_RESULT("o", job),
3134 method_try_restart_unit,
3135 SD_BUS_VTABLE_UNPRIVILEGED),
3136 SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
3137 SD_BUS_ARGS("s", name, "s", mode),
3138 SD_BUS_RESULT("o", job),
3139 method_reload_or_restart_unit,
3140 SD_BUS_VTABLE_UNPRIVILEGED),
3141 SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
3142 SD_BUS_ARGS("s", name, "s", mode),
3143 SD_BUS_RESULT("o", job),
3144 method_reload_or_try_restart_unit,
3145 SD_BUS_VTABLE_UNPRIVILEGED),
3146 SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
3147 SD_BUS_ARGS("s", name, "s", job_type, "s", job_mode),
3148 SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
3149 method_enqueue_unit_job,
3150 SD_BUS_VTABLE_UNPRIVILEGED),
3151 SD_BUS_METHOD_WITH_ARGS("KillUnit",
3152 SD_BUS_ARGS("s", name, "s", whom, "i", signal),
3153 SD_BUS_NO_RESULT,
a721cd00
LP		 3154 method_kill_unit,
3155 SD_BUS_VTABLE_UNPRIVILEGED),
3156 SD_BUS_METHOD_WITH_ARGS("QueueSignalUnit",
3157 SD_BUS_ARGS("s", name, "s", whom, "i", signal, "i", value),
3158 SD_BUS_NO_RESULT,
a008b6d7 3159 method_kill_unit,
3160 SD_BUS_VTABLE_UNPRIVILEGED),
3161 SD_BUS_METHOD_WITH_ARGS("CleanUnit",
3162 SD_BUS_ARGS("s", name, "as", mask),
3163 SD_BUS_NO_RESULT,
3164 method_clean_unit,
3165 SD_BUS_VTABLE_UNPRIVILEGED),
3166 SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
3167 SD_BUS_ARGS("s", name),
3168 SD_BUS_NO_RESULT,
3169 method_freeze_unit,
3170 SD_BUS_VTABLE_UNPRIVILEGED),
3171 SD_BUS_METHOD_WITH_ARGS("ThawUnit",
3172 SD_BUS_ARGS("s", name),
3173 SD_BUS_NO_RESULT,
3174 method_thaw_unit,
3175 SD_BUS_VTABLE_UNPRIVILEGED),
3176 SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
3177 SD_BUS_ARGS("s", name),
3178 SD_BUS_NO_RESULT,
3179 method_reset_failed_unit,
3180 SD_BUS_VTABLE_UNPRIVILEGED),
3181 SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
3182 SD_BUS_ARGS("s", name, "b", runtime, "a(sv)", properties),
3183 SD_BUS_NO_RESULT,
3184 method_set_unit_properties,
3185 SD_BUS_VTABLE_UNPRIVILEGED),
3186 SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
3187 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir),
3188 SD_BUS_NO_RESULT,
3189 method_bind_mount_unit,
3190 SD_BUS_VTABLE_UNPRIVILEGED),
3191 SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
3192 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
3193 SD_BUS_NO_RESULT,
3194 method_mount_image_unit,
3195 SD_BUS_VTABLE_UNPRIVILEGED),
3196 SD_BUS_METHOD_WITH_ARGS("RefUnit",
3197 SD_BUS_ARGS("s", name),
3198 SD_BUS_NO_RESULT,
3199 method_ref_unit,
3200 SD_BUS_VTABLE_UNPRIVILEGED),
3201 SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
3202 SD_BUS_ARGS("s", name),
3203 SD_BUS_NO_RESULT,
3204 method_unref_unit,
3205 SD_BUS_VTABLE_UNPRIVILEGED),
3206 SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
3207 SD_BUS_ARGS("s", name, "s", mode, "a(sv)", properties, "a(sa(sv))", aux),
3208 SD_BUS_RESULT("o", job),
3209 method_start_transient_unit,
3210 SD_BUS_VTABLE_UNPRIVILEGED),
3211 SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
3212 SD_BUS_ARGS("s", name),
3213 SD_BUS_RESULT("a(sus)", processes),
3214 method_get_unit_processes,
3215 SD_BUS_VTABLE_UNPRIVILEGED),
3216 SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
3217 SD_BUS_ARGS("s", unit_name, "s", subcgroup, "au", pids),
3218 SD_BUS_NO_RESULT,
3219 method_attach_processes_to_unit,
3220 SD_BUS_VTABLE_UNPRIVILEGED),
3221 SD_BUS_METHOD_WITH_ARGS("AbandonScope",
3222 SD_BUS_ARGS("s", name),
3223 SD_BUS_NO_RESULT,
3224 method_abandon_scope,
3225 SD_BUS_VTABLE_UNPRIVILEGED),
3226 SD_BUS_METHOD_WITH_ARGS("GetJob",
3227 SD_BUS_ARGS("u", id),
3228 SD_BUS_RESULT("o", job),
3229 method_get_job,
3230 SD_BUS_VTABLE_UNPRIVILEGED),
3231 SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
3232 SD_BUS_ARGS("u", id),
3233 SD_BUS_RESULT("a(usssoo)", jobs),
3234 method_get_job_waiting,
3235 SD_BUS_VTABLE_UNPRIVILEGED),
3236 SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
3237 SD_BUS_ARGS("u", id),
3238 SD_BUS_RESULT("a(usssoo)", jobs),
3239 method_get_job_waiting,
3240 SD_BUS_VTABLE_UNPRIVILEGED),
3241 SD_BUS_METHOD_WITH_ARGS("CancelJob",
3242 SD_BUS_ARGS("u", id),
3243 SD_BUS_NO_RESULT,
3244 method_cancel_job,
3245 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3246 SD_BUS_METHOD("ClearJobs",
3247 NULL,
3248 NULL,
3249 method_clear_jobs,
3250 SD_BUS_VTABLE_UNPRIVILEGED),
3251 SD_BUS_METHOD("ResetFailed",
3252 NULL,
3253 NULL,
3254 method_reset_failed,
3255 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3256 SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
3257 SD_BUS_ARGS("s", mode),
3258 SD_BUS_NO_RESULT,
3259 method_set_show_status,
3260 SD_BUS_VTABLE_UNPRIVILEGED),
3261 SD_BUS_METHOD_WITH_ARGS("ListUnits",
3262 SD_BUS_NO_ARGS,
3263 SD_BUS_RESULT("a(ssssssouso)", units),
3264 method_list_units,
3265 SD_BUS_VTABLE_UNPRIVILEGED),
3266 SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
3267 SD_BUS_ARGS("as", states),
3268 SD_BUS_RESULT("a(ssssssouso)", units),
3269 method_list_units_filtered,
3270 SD_BUS_VTABLE_UNPRIVILEGED),
3271 SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3272 SD_BUS_ARGS("as", states, "as", patterns),
3273 SD_BUS_RESULT("a(ssssssouso)", units),
3274 method_list_units_by_patterns,
3275 SD_BUS_VTABLE_UNPRIVILEGED),
3276 SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3277 SD_BUS_ARGS("as", names),
3278 SD_BUS_RESULT("a(ssssssouso)", units),
3279 method_list_units_by_names,
3280 SD_BUS_VTABLE_UNPRIVILEGED),
3281 SD_BUS_METHOD_WITH_ARGS("ListJobs",
3282 SD_BUS_NO_ARGS,
3283 SD_BUS_RESULT("a(usssoo)", jobs),
3284 method_list_jobs,
3285 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3286 SD_BUS_METHOD("Subscribe",
3287 NULL,
3288 NULL,
3289 method_subscribe,
3290 SD_BUS_VTABLE_UNPRIVILEGED),
3291 SD_BUS_METHOD("Unsubscribe",
3292 NULL,
3293 NULL,
3294 method_unsubscribe,
3295 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3296 SD_BUS_METHOD_WITH_ARGS("Dump",
3297 SD_BUS_NO_ARGS,
3298 SD_BUS_RESULT("s", output),
3299 method_dump,
3300 SD_BUS_VTABLE_UNPRIVILEGED),
293b9aa3 3301 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatterns",
d1d8786c
FB		 3302 SD_BUS_ARGS("as", patterns),
3303 SD_BUS_RESULT("s", output),
293b9aa3 3304 method_dump_units_matching_patterns,
d1d8786c 3305 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3306 SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3307 SD_BUS_NO_ARGS,
3308 SD_BUS_RESULT("h", fd),
3309 method_dump_by_fd,
3310 SD_BUS_VTABLE_UNPRIVILEGED),
f6cce15b
ZJS		 3311 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatternsByFileDescriptor",
3312 SD_BUS_ARGS("as", patterns),
3313 SD_BUS_RESULT("h", fd),
3314 method_dump_units_matching_patterns_by_fd,
3315 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3316 SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3317 SD_BUS_ARGS("s", name, "b", cleanup),
3318 SD_BUS_RESULT("o", unit),
3319 method_refuse_snapshot,
3320 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3321 SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3322 SD_BUS_ARGS("s", name),
3323 SD_BUS_NO_RESULT,
3324 method_refuse_snapshot,
3325 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
dad97f04
ZJS		 3326 SD_BUS_METHOD("Reload",
3327 NULL,
3328 NULL,
3329 method_reload,
3330 SD_BUS_VTABLE_UNPRIVILEGED),
3331 SD_BUS_METHOD("Reexecute",
3332 NULL,
3333 NULL,
3334 method_reexecute,
624f685f 3335 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_METHOD_NO_REPLY),
dad97f04
ZJS		 3336 SD_BUS_METHOD("Exit",
3337 NULL,
3338 NULL,
3339 method_exit,
3340 0),
3341 SD_BUS_METHOD("Reboot",
3342 NULL,
3343 NULL,
3344 method_reboot,
3345 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
13ffc607
LP		 3346 SD_BUS_METHOD_WITH_ARGS("SoftReboot",
3347 SD_BUS_ARGS("s", new_root),
3348 SD_BUS_NO_RESULT,
3349 method_soft_reboot,
3350 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
dad97f04
ZJS		 3351 SD_BUS_METHOD("PowerOff",
3352 NULL,
3353 NULL,
3354 method_poweroff,
3355 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3356 SD_BUS_METHOD("Halt",
3357 NULL,
3358 NULL,
3359 method_halt,
3360 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3361 SD_BUS_METHOD("KExec",
3362 NULL,
3363 NULL,
3364 method_kexec,
3365 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
a008b6d7 3366 SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3367 SD_BUS_ARGS("s", new_root, "s", init),
3368 SD_BUS_NO_RESULT,
3369 method_switch_root,
3370 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3371 SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3372 SD_BUS_ARGS("as", assignments),
3373 SD_BUS_NO_RESULT,
3374 method_set_environment,
3375 SD_BUS_VTABLE_UNPRIVILEGED),
3376 SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3377 SD_BUS_ARGS("as", names),
3378 SD_BUS_NO_RESULT,
3379 method_unset_environment,
3380 SD_BUS_VTABLE_UNPRIVILEGED),
3381 SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3382 SD_BUS_ARGS("as", names, "as", assignments),
3383 SD_BUS_NO_RESULT,
3384 method_unset_and_set_environment,
3385 SD_BUS_VTABLE_UNPRIVILEGED),
3386 SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3387 SD_BUS_NO_ARGS,
3388 SD_BUS_RESULT("ao", jobs),
3389 method_enqueue_marked_jobs,
3390 SD_BUS_VTABLE_UNPRIVILEGED),
3391 SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3392 SD_BUS_NO_ARGS,
3393 SD_BUS_RESULT("a(ss)", unit_files),
3394 method_list_unit_files,
3395 SD_BUS_VTABLE_UNPRIVILEGED),
3396 SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3397 SD_BUS_ARGS("as", states, "as", patterns),
3398 SD_BUS_RESULT("a(ss)", unit_files),
3399 method_list_unit_files_by_patterns,
3400 SD_BUS_VTABLE_UNPRIVILEGED),
3401 SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3402 SD_BUS_ARGS("s", file),
3403 SD_BUS_RESULT("s", state),
3404 method_get_unit_file_state,
3405 SD_BUS_VTABLE_UNPRIVILEGED),
3406 SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3407 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3408 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3409 method_enable_unit_files,
3410 SD_BUS_VTABLE_UNPRIVILEGED),
3411 SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3412 SD_BUS_ARGS("as", files, "b", runtime),
3413 SD_BUS_RESULT("a(sss)", changes),
3414 method_disable_unit_files,
3415 SD_BUS_VTABLE_UNPRIVILEGED),
3416 SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3417 SD_BUS_ARGS("as", files, "t", flags),
3418 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3419 method_enable_unit_files_with_flags,
3420 SD_BUS_VTABLE_UNPRIVILEGED),
3421 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3422 SD_BUS_ARGS("as", files, "t", flags),
3423 SD_BUS_RESULT("a(sss)", changes),
3424 method_disable_unit_files_with_flags,
3425 SD_BUS_VTABLE_UNPRIVILEGED),
bf1bea43
MY		 3426 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlagsAndInstallInfo",
3427 SD_BUS_ARGS("as", files, "t", flags),
3428 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3429 method_disable_unit_files_with_flags_and_install_info,
3430 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3431 SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3432 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3433 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3434 method_reenable_unit_files,
3435 SD_BUS_VTABLE_UNPRIVILEGED),
3436 SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3437 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3438 SD_BUS_RESULT("a(sss)", changes),
3439 method_link_unit_files,
3440 SD_BUS_VTABLE_UNPRIVILEGED),
3441 SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3442 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3443 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3444 method_preset_unit_files,
3445 SD_BUS_VTABLE_UNPRIVILEGED),
3446 SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3447 SD_BUS_ARGS("as", files, "s", mode, "b", runtime, "b", force),
3448 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3449 method_preset_unit_files_with_mode,
3450 SD_BUS_VTABLE_UNPRIVILEGED),
3451 SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3452 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3453 SD_BUS_RESULT("a(sss)", changes),
3454 method_mask_unit_files,
3455 SD_BUS_VTABLE_UNPRIVILEGED),
3456 SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3457 SD_BUS_ARGS("as", files, "b", runtime),
3458 SD_BUS_RESULT("a(sss)", changes),
3459 method_unmask_unit_files,
3460 SD_BUS_VTABLE_UNPRIVILEGED),
3461 SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3462 SD_BUS_ARGS("as", files),
3463 SD_BUS_RESULT("a(sss)", changes),
3464 method_revert_unit_files,
3465 SD_BUS_VTABLE_UNPRIVILEGED),
3466 SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3467 SD_BUS_ARGS("s", name, "b", force),
3468 SD_BUS_RESULT("a(sss)", changes),
3469 method_set_default_target,
3470 SD_BUS_VTABLE_UNPRIVILEGED),
3471 SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3472 SD_BUS_NO_ARGS,
3473 SD_BUS_RESULT("s", name),
3474 method_get_default_target,
3475 SD_BUS_VTABLE_UNPRIVILEGED),
3476 SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3477 SD_BUS_ARGS("s", mode, "b", runtime, "b", force),
3478 SD_BUS_RESULT("a(sss)", changes),
3479 method_preset_all_unit_files,
3480 SD_BUS_VTABLE_UNPRIVILEGED),
3481 SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3482 SD_BUS_ARGS("as", files, "s", target, "s", type, "b", runtime, "b", force),
3483 SD_BUS_RESULT("a(sss)", changes),
3484 method_add_dependency_unit_files,
3485 SD_BUS_VTABLE_UNPRIVILEGED),
3486 SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3487 SD_BUS_ARGS("s", name, "b", runtime),
3488 SD_BUS_RESULT("as", links),
3489 method_get_unit_file_links,
3490 SD_BUS_VTABLE_UNPRIVILEGED),
3491 SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3492 SD_BUS_ARGS("y", number),
3493 SD_BUS_NO_RESULT,
3494 method_set_exit_code,
3495 SD_BUS_VTABLE_UNPRIVILEGED),
3496 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3497 SD_BUS_ARGS("s", name),
3498 SD_BUS_RESULT("u", uid),
3499 method_lookup_dynamic_user_by_name,
3500 SD_BUS_VTABLE_UNPRIVILEGED),
3501 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3502 SD_BUS_ARGS("u", uid),
3503 SD_BUS_RESULT("s", name),
3504 method_lookup_dynamic_user_by_uid,
3505 SD_BUS_VTABLE_UNPRIVILEGED),
3506 SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3507 SD_BUS_NO_ARGS,
3508 SD_BUS_RESULT("a(us)", users),
3509 method_get_dynamic_users,
3510 SD_BUS_VTABLE_UNPRIVILEGED),
2ea24611
LP		 3511 SD_BUS_METHOD_WITH_ARGS("DumpUnitFileDescriptorStore",
3512 SD_BUS_ARGS("s", name),
3513 SD_BUS_RESULT("a(suuutuusu)", entries),
3514 method_dump_unit_descriptor_store,
3515 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3516
3517 SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3518 SD_BUS_ARGS("s", id, "o", unit),
3519 0),
3520 SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3521 SD_BUS_ARGS("s", id, "o", unit),
3522 0),
3523 SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3524 SD_BUS_ARGS("u", id, "o", job, "s", unit),
3525 0),
3526 SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3527 SD_BUS_ARGS("u", id, "o", job, "s", unit, "s", result),
3528 0),
3529 SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3530 SD_BUS_ARGS("t", firmware, "t", loader, "t", kernel, "t", initrd, "t", userspace, "t", total),
3531 0),
718db961 3532 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
a008b6d7 3533 SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3534 SD_BUS_ARGS("b", active),
3535 0),
718db961
LP		 3536
3537 SD_BUS_VTABLE_END
ea430986 3538};
718db961 3539
893f801d
LP		 3540const sd_bus_vtable bus_manager_log_control_vtable[] = {
3541 SD_BUS_VTABLE_START(0),
3542
3543 /* We define a private version of this interface here, since we want slightly different
3544 * implementations for the setters. We'll still use the generic getters however, and we share the
3545 * setters with the implementations for the Manager interface above (which pre-dates the generic
3546 * service API interface). */
3547
3548 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3549 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3550 SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier, 0, 0),
3551
3552 SD_BUS_VTABLE_END,
3553};
3554
8f8f05a9 3555static int send_finished(sd_bus *bus, void *userdata) {
4afd3348 3556 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
99534007 3557 usec_t *times = ASSERT_PTR(userdata);
718db961
LP		 3558 int r;
3559
3560 assert(bus);
718db961 3561
cb31470f
ZJS		 3562 r = sd_bus_message_new_signal(bus,
3563 &message,
3564 "/org/freedesktop/systemd1",
3565 "org.freedesktop.systemd1.Manager",
3566 "StartupFinished");
718db961
LP		 3567 if (r < 0)
3568 return r;
3569
3570 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
3571 if (r < 0)
3572 return r;
3573
8f8f05a9 3574 return sd_bus_send(bus, message, NULL);
718db961
LP		 3575}
3576
39abcaee 3577void bus_manager_send_finished(
718db961
LP		 3578 Manager *m,
3579 usec_t firmware_usec,
3580 usec_t loader_usec,
3581 usec_t kernel_usec,
3582 usec_t initrd_usec,
3583 usec_t userspace_usec,
3584 usec_t total_usec) {
3585
39abcaee
LP		 3586 int r;
3587
718db961
LP		 3588 assert(m);
3589
8f8f05a9
LP		 3590 r = bus_foreach_bus(
3591 m,
3592 NULL,
3593 send_finished,
3594 (usec_t[6]) {
3595 firmware_usec,
3596 loader_usec,
3597 kernel_usec,
3598 initrd_usec,
3599 userspace_usec,
3600 total_usec
3601 });
39abcaee 3602 if (r < 0)
da927ba9 3603 log_debug_errno(r, "Failed to send finished signal: %m");
718db961
LP		 3604}
3605
8f8f05a9 3606static int send_reloading(sd_bus *bus, void *userdata) {
4afd3348 3607 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 3608 int r;
3609
3610 assert(bus);
3611
151b9b96 3612 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
718db961
LP		 3613 if (r < 0)
3614 return r;
3615
3616 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
3617 if (r < 0)
3618 return r;
3619
8f8f05a9 3620 return sd_bus_send(bus, message, NULL);
718db961
LP		 3621}
3622
39abcaee
LP		 3623void bus_manager_send_reloading(Manager *m, bool active) {
3624 int r;
3625
718db961
LP		 3626 assert(m);
3627
8f8f05a9 3628 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
39abcaee 3629 if (r < 0)
da927ba9 3630 log_debug_errno(r, "Failed to send reloading signal: %m");
03455c28
LDM		 3631}
3632
3633static int send_changed_signal(sd_bus *bus, void *userdata) {
3634 assert(bus);
3635
3636 return sd_bus_emit_properties_changed_strv(bus,
3637 "/org/freedesktop/systemd1",
3638 "org.freedesktop.systemd1.Manager",
3639 NULL);
3640}
39abcaee 3641
03455c28
LDM		 3642void bus_manager_send_change_signal(Manager *m) {
3643 int r;
3644
3645 assert(m);
3646
3647 r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
3648 if (r < 0)
3649 log_debug_errno(r, "Failed to send manager change signal: %m");
718db961 3650}
Unnamed repository; edit this file 'description' to name the repository.