]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/busname.c
Merge pull request #1250 from g2p/master
[thirdparty/systemd.git] / src / core / busname.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <sys/mman.h>
23
24 #include "special.h"
25 #include "formats-util.h"
26 #include "signal-util.h"
27 #include "bus-kernel.h"
28 #include "bus-internal.h"
29 #include "bus-util.h"
30 #include "kdbus.h"
31 #include "bus-policy.h"
32 #include "service.h"
33 #include "dbus-busname.h"
34 #include "busname.h"
35
36 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
37 [BUSNAME_DEAD] = UNIT_INACTIVE,
38 [BUSNAME_MAKING] = UNIT_ACTIVATING,
39 [BUSNAME_REGISTERED] = UNIT_ACTIVE,
40 [BUSNAME_LISTENING] = UNIT_ACTIVE,
41 [BUSNAME_RUNNING] = UNIT_ACTIVE,
42 [BUSNAME_SIGTERM] = UNIT_DEACTIVATING,
43 [BUSNAME_SIGKILL] = UNIT_DEACTIVATING,
44 [BUSNAME_FAILED] = UNIT_FAILED
45 };
46
47 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
48 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
49
50 static void busname_init(Unit *u) {
51 BusName *n = BUSNAME(u);
52
53 assert(u);
54 assert(u->load_state == UNIT_STUB);
55
56 n->starter_fd = -1;
57 n->accept_fd = true;
58 n->activating = true;
59
60 n->timeout_usec = u->manager->default_timeout_start_usec;
61 }
62
63 static void busname_unwatch_control_pid(BusName *n) {
64 assert(n);
65
66 if (n->control_pid <= 0)
67 return;
68
69 unit_unwatch_pid(UNIT(n), n->control_pid);
70 n->control_pid = 0;
71 }
72
73 static void busname_free_policy(BusName *n) {
74 BusNamePolicy *p;
75
76 assert(n);
77
78 while ((p = n->policy)) {
79 LIST_REMOVE(policy, n->policy, p);
80
81 free(p->name);
82 free(p);
83 }
84 }
85
86 static void busname_close_fd(BusName *n) {
87 assert(n);
88
89 n->starter_event_source = sd_event_source_unref(n->starter_event_source);
90 n->starter_fd = safe_close(n->starter_fd);
91 }
92
93 static void busname_done(Unit *u) {
94 BusName *n = BUSNAME(u);
95
96 assert(n);
97
98 n->name = mfree(n->name);
99
100 busname_free_policy(n);
101 busname_unwatch_control_pid(n);
102 busname_close_fd(n);
103
104 unit_ref_unset(&n->service);
105
106 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
107 }
108
109 static int busname_arm_timer(BusName *n) {
110 int r;
111
112 assert(n);
113
114 if (n->timeout_usec <= 0) {
115 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
116 return 0;
117 }
118
119 if (n->timer_event_source) {
120 r = sd_event_source_set_time(n->timer_event_source, now(CLOCK_MONOTONIC) + n->timeout_usec);
121 if (r < 0)
122 return r;
123
124 return sd_event_source_set_enabled(n->timer_event_source, SD_EVENT_ONESHOT);
125 }
126
127 r = sd_event_add_time(
128 UNIT(n)->manager->event,
129 &n->timer_event_source,
130 CLOCK_MONOTONIC,
131 now(CLOCK_MONOTONIC) + n->timeout_usec, 0,
132 busname_dispatch_timer, n);
133 if (r < 0)
134 return r;
135
136 (void) sd_event_source_set_description(n->timer_event_source, "busname-timer");
137
138 return 0;
139 }
140
141 static int busname_add_default_default_dependencies(BusName *n) {
142 int r;
143
144 assert(n);
145
146 r = unit_add_dependency_by_name(UNIT(n), UNIT_BEFORE, SPECIAL_BUSNAMES_TARGET, NULL, true);
147 if (r < 0)
148 return r;
149
150 if (UNIT(n)->manager->running_as == MANAGER_SYSTEM) {
151 r = unit_add_two_dependencies_by_name(UNIT(n), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
152 if (r < 0)
153 return r;
154 }
155
156 return unit_add_two_dependencies_by_name(UNIT(n), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
157 }
158
159 static int busname_add_extras(BusName *n) {
160 Unit *u = UNIT(n);
161 int r;
162
163 assert(n);
164
165 if (!n->name) {
166 r = unit_name_to_prefix(u->id, &n->name);
167 if (r < 0)
168 return r;
169 }
170
171 if (!u->description) {
172 r = unit_set_description(u, n->name);
173 if (r < 0)
174 return r;
175 }
176
177 if (n->activating) {
178 if (!UNIT_DEREF(n->service)) {
179 Unit *x;
180
181 r = unit_load_related_unit(u, ".service", &x);
182 if (r < 0)
183 return r;
184
185 unit_ref_set(&n->service, x);
186 }
187
188 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(n->service), true);
189 if (r < 0)
190 return r;
191 }
192
193 if (u->default_dependencies) {
194 r = busname_add_default_default_dependencies(n);
195 if (r < 0)
196 return r;
197 }
198
199 return 0;
200 }
201
202 static int busname_verify(BusName *n) {
203 char *e;
204
205 assert(n);
206
207 if (UNIT(n)->load_state != UNIT_LOADED)
208 return 0;
209
210 if (!service_name_is_valid(n->name)) {
211 log_unit_error(UNIT(n), "Name= setting is not a valid service name Refusing.");
212 return -EINVAL;
213 }
214
215 e = strjoina(n->name, ".busname");
216 if (!unit_has_name(UNIT(n), e)) {
217 log_unit_error(UNIT(n), "Name= setting doesn't match unit name. Refusing.");
218 return -EINVAL;
219 }
220
221 return 0;
222 }
223
224 static int busname_load(Unit *u) {
225 BusName *n = BUSNAME(u);
226 int r;
227
228 assert(u);
229 assert(u->load_state == UNIT_STUB);
230
231 r = unit_load_fragment_and_dropin(u);
232 if (r < 0)
233 return r;
234
235 if (u->load_state == UNIT_LOADED) {
236 /* This is a new unit? Then let's add in some extras */
237 r = busname_add_extras(n);
238 if (r < 0)
239 return r;
240 }
241
242 return busname_verify(n);
243 }
244
245 static void busname_dump(Unit *u, FILE *f, const char *prefix) {
246 BusName *n = BUSNAME(u);
247
248 assert(n);
249 assert(f);
250
251 fprintf(f,
252 "%sBus Name State: %s\n"
253 "%sResult: %s\n"
254 "%sName: %s\n"
255 "%sActivating: %s\n"
256 "%sAccept FD: %s\n",
257 prefix, busname_state_to_string(n->state),
258 prefix, busname_result_to_string(n->result),
259 prefix, n->name,
260 prefix, yes_no(n->activating),
261 prefix, yes_no(n->accept_fd));
262
263 if (n->control_pid > 0)
264 fprintf(f,
265 "%sControl PID: "PID_FMT"\n",
266 prefix, n->control_pid);
267 }
268
269 static void busname_unwatch_fd(BusName *n) {
270 int r;
271
272 assert(n);
273
274 if (!n->starter_event_source)
275 return;
276
277 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_OFF);
278 if (r < 0)
279 log_unit_debug_errno(UNIT(n), r, "Failed to disable event source: %m");
280 }
281
282 static int busname_watch_fd(BusName *n) {
283 int r;
284
285 assert(n);
286
287 if (n->starter_fd < 0)
288 return 0;
289
290 if (n->starter_event_source) {
291 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_ON);
292 if (r < 0)
293 goto fail;
294 } else {
295 r = sd_event_add_io(UNIT(n)->manager->event, &n->starter_event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
296 if (r < 0)
297 goto fail;
298
299 (void) sd_event_source_set_description(n->starter_event_source, "busname-starter");
300 }
301
302 return 0;
303
304 fail:
305 log_unit_warning_errno(UNIT(n), r, "Failed to watch starter fd: %m");
306 busname_unwatch_fd(n);
307 return r;
308 }
309
310 static int busname_open_fd(BusName *n) {
311 _cleanup_free_ char *path = NULL;
312 const char *mode;
313
314 assert(n);
315
316 if (n->starter_fd >= 0)
317 return 0;
318
319 mode = UNIT(n)->manager->running_as == MANAGER_SYSTEM ? "system" : "user";
320 n->starter_fd = bus_kernel_open_bus_fd(mode, &path);
321 if (n->starter_fd < 0)
322 return log_unit_warning_errno(UNIT(n), n->starter_fd, "Failed to open %s: %m", path ?: "kdbus");
323
324 return 0;
325 }
326
327 static void busname_set_state(BusName *n, BusNameState state) {
328 BusNameState old_state;
329 assert(n);
330
331 old_state = n->state;
332 n->state = state;
333
334 if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
335 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
336 busname_unwatch_control_pid(n);
337 }
338
339 if (state != BUSNAME_LISTENING)
340 busname_unwatch_fd(n);
341
342 if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
343 busname_close_fd(n);
344
345 if (state != old_state)
346 log_unit_debug(UNIT(n), "Changed %s -> %s", busname_state_to_string(old_state), busname_state_to_string(state));
347
348 unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
349 }
350
351 static int busname_coldplug(Unit *u) {
352 BusName *n = BUSNAME(u);
353 int r;
354
355 assert(n);
356 assert(n->state == BUSNAME_DEAD);
357
358 if (n->deserialized_state == n->state)
359 return 0;
360
361 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
362
363 if (n->control_pid <= 0)
364 return -EBADMSG;
365
366 r = unit_watch_pid(UNIT(n), n->control_pid);
367 if (r < 0)
368 return r;
369
370 r = busname_arm_timer(n);
371 if (r < 0)
372 return r;
373 }
374
375 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
376 r = busname_open_fd(n);
377 if (r < 0)
378 return r;
379 }
380
381 if (n->deserialized_state == BUSNAME_LISTENING) {
382 r = busname_watch_fd(n);
383 if (r < 0)
384 return r;
385 }
386
387 busname_set_state(n, n->deserialized_state);
388 return 0;
389 }
390
391 static int busname_make_starter(BusName *n, pid_t *_pid) {
392 pid_t pid;
393 int r;
394
395 r = busname_arm_timer(n);
396 if (r < 0)
397 goto fail;
398
399 /* We have to resolve the user/group names out-of-process,
400 * hence let's fork here. It's messy, but well, what can we
401 * do? */
402
403 pid = fork();
404 if (pid < 0)
405 return -errno;
406
407 if (pid == 0) {
408 int ret;
409
410 (void) default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
411 (void) ignore_signals(SIGPIPE, -1);
412 log_forget_fds();
413
414 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
415 if (r < 0) {
416 ret = EXIT_MAKE_STARTER;
417 goto fail_child;
418 }
419
420 _exit(0);
421
422 fail_child:
423 log_open();
424 log_error_errno(r, "Failed to create starter connection at step %s: %m", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD));
425
426 _exit(ret);
427 }
428
429 r = unit_watch_pid(UNIT(n), pid);
430 if (r < 0)
431 goto fail;
432
433 *_pid = pid;
434 return 0;
435
436 fail:
437 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
438 return r;
439 }
440
441 static void busname_enter_dead(BusName *n, BusNameResult f) {
442 assert(n);
443
444 if (f != BUSNAME_SUCCESS)
445 n->result = f;
446
447 busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
448 }
449
450 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
451 KillContext kill_context = {};
452 int r;
453
454 assert(n);
455
456 if (f != BUSNAME_SUCCESS)
457 n->result = f;
458
459 kill_context_init(&kill_context);
460
461 r = unit_kill_context(UNIT(n),
462 &kill_context,
463 state != BUSNAME_SIGTERM ? KILL_KILL : KILL_TERMINATE,
464 -1,
465 n->control_pid,
466 false);
467 if (r < 0) {
468 log_unit_warning_errno(UNIT(n), r, "Failed to kill control process: %m");
469 goto fail;
470 }
471
472 if (r > 0) {
473 r = busname_arm_timer(n);
474 if (r < 0) {
475 log_unit_warning_errno(UNIT(n), r, "Failed to arm timer: %m");
476 goto fail;
477 }
478
479 busname_set_state(n, state);
480 } else if (state == BUSNAME_SIGTERM)
481 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
482 else
483 busname_enter_dead(n, BUSNAME_SUCCESS);
484
485 return;
486
487 fail:
488 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
489 }
490
491 static void busname_enter_listening(BusName *n) {
492 int r;
493
494 assert(n);
495
496 if (n->activating) {
497 r = busname_watch_fd(n);
498 if (r < 0) {
499 log_unit_warning_errno(UNIT(n), r, "Failed to watch names: %m");
500 goto fail;
501 }
502
503 busname_set_state(n, BUSNAME_LISTENING);
504 } else
505 busname_set_state(n, BUSNAME_REGISTERED);
506
507 return;
508
509 fail:
510 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
511 }
512
513 static void busname_enter_making(BusName *n) {
514 int r;
515
516 assert(n);
517
518 r = busname_open_fd(n);
519 if (r < 0)
520 goto fail;
521
522 if (n->policy) {
523 /* If there is a policy, we need to resolve user/group
524 * names, which we can't do from PID1, hence let's
525 * fork. */
526 busname_unwatch_control_pid(n);
527
528 r = busname_make_starter(n, &n->control_pid);
529 if (r < 0) {
530 log_unit_warning_errno(UNIT(n), r, "Failed to fork 'making' task: %m");
531 goto fail;
532 }
533
534 busname_set_state(n, BUSNAME_MAKING);
535 } else {
536 /* If there is no policy, we can do everything
537 * directly from PID 1, hence do so. */
538
539 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
540 if (r < 0) {
541 log_unit_warning_errno(UNIT(n), r, "Failed to make starter: %m");
542 goto fail;
543 }
544
545 busname_enter_listening(n);
546 }
547
548 return;
549
550 fail:
551 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
552 }
553
554 static void busname_enter_running(BusName *n) {
555 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
556 bool pending = false;
557 Unit *other;
558 Iterator i;
559 int r;
560
561 assert(n);
562
563 if (!n->activating)
564 return;
565
566 /* We don't take connections anymore if we are supposed to
567 * shut down anyway */
568
569 if (unit_stop_pending(UNIT(n))) {
570 log_unit_debug(UNIT(n), "Suppressing activation request since unit stop is scheduled.");
571
572 /* Flush all queued activation reqeuest by closing and reopening the connection */
573 bus_kernel_drop_one(n->starter_fd);
574
575 busname_enter_listening(n);
576 return;
577 }
578
579 /* If there's already a start pending don't bother to do
580 * anything */
581 SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
582 if (unit_active_or_pending(other)) {
583 pending = true;
584 break;
585 }
586
587 if (!pending) {
588 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
589 if (r < 0)
590 goto fail;
591 }
592
593 busname_set_state(n, BUSNAME_RUNNING);
594 return;
595
596 fail:
597 log_unit_warning(UNIT(n), "Failed to queue service startup job: %s", bus_error_message(&error, r));
598 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
599 }
600
601 static int busname_start(Unit *u) {
602 BusName *n = BUSNAME(u);
603
604 assert(n);
605
606 /* We cannot fulfill this request right now, try again later
607 * please! */
608 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
609 return -EAGAIN;
610
611 /* Already on it! */
612 if (n->state == BUSNAME_MAKING)
613 return 0;
614
615 if (n->activating && UNIT_ISSET(n->service)) {
616 Service *service;
617
618 service = SERVICE(UNIT_DEREF(n->service));
619
620 if (UNIT(service)->load_state != UNIT_LOADED) {
621 log_unit_error(u, "Bus service %s not loaded, refusing.", UNIT(service)->id);
622 return -ENOENT;
623 }
624 }
625
626 assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
627
628 n->result = BUSNAME_SUCCESS;
629 busname_enter_making(n);
630
631 return 1;
632 }
633
634 static int busname_stop(Unit *u) {
635 BusName *n = BUSNAME(u);
636
637 assert(n);
638
639 /* Already on it */
640 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
641 return 0;
642
643 /* If there's already something running, we go directly into
644 * kill mode. */
645
646 if (n->state == BUSNAME_MAKING) {
647 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
648 return -EAGAIN;
649 }
650
651 assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
652
653 busname_enter_dead(n, BUSNAME_SUCCESS);
654 return 1;
655 }
656
657 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
658 BusName *n = BUSNAME(u);
659
660 assert(n);
661 assert(f);
662 assert(fds);
663
664 unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
665 unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
666
667 if (n->control_pid > 0)
668 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
669
670 if (n->starter_fd >= 0) {
671 int copy;
672
673 copy = fdset_put_dup(fds, n->starter_fd);
674 if (copy < 0)
675 return copy;
676
677 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
678 }
679
680 return 0;
681 }
682
683 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
684 BusName *n = BUSNAME(u);
685
686 assert(n);
687 assert(key);
688 assert(value);
689
690 if (streq(key, "state")) {
691 BusNameState state;
692
693 state = busname_state_from_string(value);
694 if (state < 0)
695 log_unit_debug(u, "Failed to parse state value: %s", value);
696 else
697 n->deserialized_state = state;
698
699 } else if (streq(key, "result")) {
700 BusNameResult f;
701
702 f = busname_result_from_string(value);
703 if (f < 0)
704 log_unit_debug(u, "Failed to parse result value: %s", value);
705 else if (f != BUSNAME_SUCCESS)
706 n->result = f;
707
708 } else if (streq(key, "control-pid")) {
709 pid_t pid;
710
711 if (parse_pid(value, &pid) < 0)
712 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
713 else
714 n->control_pid = pid;
715 } else if (streq(key, "starter-fd")) {
716 int fd;
717
718 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
719 log_unit_debug(u, "Failed to parse starter fd value: %s", value);
720 else {
721 safe_close(n->starter_fd);
722 n->starter_fd = fdset_remove(fds, fd);
723 }
724 } else
725 log_unit_debug(u, "Unknown serialization key: %s", key);
726
727 return 0;
728 }
729
730 _pure_ static UnitActiveState busname_active_state(Unit *u) {
731 assert(u);
732
733 return state_translation_table[BUSNAME(u)->state];
734 }
735
736 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
737 assert(u);
738
739 return busname_state_to_string(BUSNAME(u)->state);
740 }
741
742 static int busname_peek_message(BusName *n) {
743 struct kdbus_cmd_recv cmd_recv = {
744 .size = sizeof(cmd_recv),
745 .flags = KDBUS_RECV_PEEK,
746 };
747 struct kdbus_cmd_free cmd_free = {
748 .size = sizeof(cmd_free),
749 };
750 const char *comm = NULL;
751 struct kdbus_item *d;
752 struct kdbus_msg *k;
753 size_t start, ps, sz, delta;
754 void *p = NULL;
755 pid_t pid = 0;
756 int r;
757
758 /* Generate a friendly debug log message about which process
759 * caused triggering of this bus name. This simply peeks the
760 * metadata of the first queued message and logs it. */
761
762 assert(n);
763
764 /* Let's shortcut things a bit, if debug logging is turned off
765 * anyway. */
766
767 if (log_get_max_level() < LOG_DEBUG)
768 return 0;
769
770 r = ioctl(n->starter_fd, KDBUS_CMD_RECV, &cmd_recv);
771 if (r < 0) {
772 if (errno == EINTR || errno == EAGAIN)
773 return 0;
774
775 return log_unit_error_errno(UNIT(n), errno, "Failed to query activation message: %m");
776 }
777
778 /* We map as late as possible, and unmap imemdiately after
779 * use. On 32bit address space is scarce and we want to be
780 * able to handle a lot of activator connections at the same
781 * time, and hence shouldn't keep the mmap()s around for
782 * longer than necessary. */
783
784 ps = page_size();
785 start = (cmd_recv.msg.offset / ps) * ps;
786 delta = cmd_recv.msg.offset - start;
787 sz = PAGE_ALIGN(delta + cmd_recv.msg.msg_size);
788
789 p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
790 if (p == MAP_FAILED) {
791 r = log_unit_error_errno(UNIT(n), errno, "Failed to map activation message: %m");
792 goto finish;
793 }
794
795 k = (struct kdbus_msg *) ((uint8_t *) p + delta);
796 KDBUS_ITEM_FOREACH(d, k, items) {
797 switch (d->type) {
798
799 case KDBUS_ITEM_PIDS:
800 pid = d->pids.pid;
801 break;
802
803 case KDBUS_ITEM_PID_COMM:
804 comm = d->str;
805 break;
806 }
807 }
808
809 if (pid > 0)
810 log_unit_debug(UNIT(n), "Activation triggered by process " PID_FMT " (%s)", pid, strna(comm));
811
812 r = 0;
813
814 finish:
815 if (p)
816 (void) munmap(p, sz);
817
818 cmd_free.offset = cmd_recv.msg.offset;
819 if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
820 log_unit_warning(UNIT(n), "Failed to free peeked message, ignoring: %m");
821
822 return r;
823 }
824
825 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
826 BusName *n = userdata;
827
828 assert(n);
829 assert(fd >= 0);
830
831 if (n->state != BUSNAME_LISTENING)
832 return 0;
833
834 log_unit_debug(UNIT(n), "Activation request");
835
836 if (revents != EPOLLIN) {
837 log_unit_error(UNIT(n), "Got unexpected poll event (0x%x) on starter fd.", revents);
838 goto fail;
839 }
840
841 busname_peek_message(n);
842 busname_enter_running(n);
843 return 0;
844 fail:
845
846 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
847 return 0;
848 }
849
850 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
851 BusName *n = BUSNAME(u);
852 BusNameResult f;
853
854 assert(n);
855 assert(pid >= 0);
856
857 if (pid != n->control_pid)
858 return;
859
860 n->control_pid = 0;
861
862 if (is_clean_exit(code, status, NULL))
863 f = BUSNAME_SUCCESS;
864 else if (code == CLD_EXITED)
865 f = BUSNAME_FAILURE_EXIT_CODE;
866 else if (code == CLD_KILLED)
867 f = BUSNAME_FAILURE_SIGNAL;
868 else if (code == CLD_DUMPED)
869 f = BUSNAME_FAILURE_CORE_DUMP;
870 else
871 assert_not_reached("Unknown sigchld code");
872
873 log_unit_full(u, f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
874 "Control process exited, code=%s status=%i", sigchld_code_to_string(code), status);
875
876 if (f != BUSNAME_SUCCESS)
877 n->result = f;
878
879 switch (n->state) {
880
881 case BUSNAME_MAKING:
882 if (f == BUSNAME_SUCCESS)
883 busname_enter_listening(n);
884 else
885 busname_enter_signal(n, BUSNAME_SIGTERM, f);
886 break;
887
888 case BUSNAME_SIGTERM:
889 case BUSNAME_SIGKILL:
890 busname_enter_dead(n, f);
891 break;
892
893 default:
894 assert_not_reached("Uh, control process died at wrong time.");
895 }
896
897 /* Notify clients about changed exit status */
898 unit_add_to_dbus_queue(u);
899 }
900
901 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
902 BusName *n = BUSNAME(userdata);
903
904 assert(n);
905 assert(n->timer_event_source == source);
906
907 switch (n->state) {
908
909 case BUSNAME_MAKING:
910 log_unit_warning(UNIT(n), "Making timed out. Terminating.");
911 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
912 break;
913
914 case BUSNAME_SIGTERM:
915 log_unit_warning(UNIT(n), "Stopping timed out. Killing.");
916 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
917 break;
918
919 case BUSNAME_SIGKILL:
920 log_unit_warning(UNIT(n), "Processes still around after SIGKILL. Ignoring.");
921 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
922 break;
923
924 default:
925 assert_not_reached("Timeout at wrong time.");
926 }
927
928 return 0;
929 }
930
931 static void busname_reset_failed(Unit *u) {
932 BusName *n = BUSNAME(u);
933
934 assert(n);
935
936 if (n->state == BUSNAME_FAILED)
937 busname_set_state(n, BUSNAME_DEAD);
938
939 n->result = BUSNAME_SUCCESS;
940 }
941
942 static void busname_trigger_notify(Unit *u, Unit *other) {
943 BusName *n = BUSNAME(u);
944 Service *s;
945
946 assert(n);
947 assert(other);
948
949 if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
950 return;
951
952 if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
953 return;
954
955 s = SERVICE(other);
956
957 if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
958 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
959 else if (IN_SET(s->state,
960 SERVICE_DEAD, SERVICE_FAILED,
961 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
962 SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
963 SERVICE_AUTO_RESTART))
964 busname_enter_listening(n);
965 }
966
967 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
968 return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
969 }
970
971 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
972 BusName *n = BUSNAME(u);
973 int r;
974
975 if (!n->timer_event_source)
976 return 0;
977
978 r = sd_event_source_get_time(n->timer_event_source, timeout);
979 if (r < 0)
980 return r;
981
982 return 1;
983 }
984
985 static bool busname_supported(void) {
986 static int supported = -1;
987
988 if (supported < 0)
989 supported = is_kdbus_available();
990
991 return supported;
992 }
993
994 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
995 [BUSNAME_DEAD] = "dead",
996 [BUSNAME_MAKING] = "making",
997 [BUSNAME_REGISTERED] = "registered",
998 [BUSNAME_LISTENING] = "listening",
999 [BUSNAME_RUNNING] = "running",
1000 [BUSNAME_SIGTERM] = "sigterm",
1001 [BUSNAME_SIGKILL] = "sigkill",
1002 [BUSNAME_FAILED] = "failed",
1003 };
1004
1005 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
1006
1007 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
1008 [BUSNAME_SUCCESS] = "success",
1009 [BUSNAME_FAILURE_RESOURCES] = "resources",
1010 [BUSNAME_FAILURE_TIMEOUT] = "timeout",
1011 [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
1012 [BUSNAME_FAILURE_SIGNAL] = "signal",
1013 [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
1014 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
1015 };
1016
1017 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
1018
1019 const UnitVTable busname_vtable = {
1020 .object_size = sizeof(BusName),
1021
1022 .sections =
1023 "Unit\0"
1024 "BusName\0"
1025 "Install\0",
1026 .private_section = "BusName",
1027
1028 .no_alias = true,
1029 .no_instances = true,
1030
1031 .init = busname_init,
1032 .done = busname_done,
1033 .load = busname_load,
1034
1035 .coldplug = busname_coldplug,
1036
1037 .dump = busname_dump,
1038
1039 .start = busname_start,
1040 .stop = busname_stop,
1041
1042 .kill = busname_kill,
1043
1044 .get_timeout = busname_get_timeout,
1045
1046 .serialize = busname_serialize,
1047 .deserialize_item = busname_deserialize_item,
1048
1049 .active_state = busname_active_state,
1050 .sub_state_to_string = busname_sub_state_to_string,
1051
1052 .sigchld_event = busname_sigchld_event,
1053
1054 .trigger_notify = busname_trigger_notify,
1055
1056 .reset_failed = busname_reset_failed,
1057
1058 .supported = busname_supported,
1059
1060 .bus_vtable = bus_busname_vtable,
1061
1062 .status_message_formats = {
1063 .finished_start_job = {
1064 [JOB_DONE] = "Listening on %s.",
1065 [JOB_FAILED] = "Failed to listen on %s.",
1066 },
1067 .finished_stop_job = {
1068 [JOB_DONE] = "Closed %s.",
1069 [JOB_FAILED] = "Failed stopping %s.",
1070 },
1071 },
1072 };