]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/core/service.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
man: add not to not use -x in bug reports
[thirdparty/systemd.git] / src / core / service.c
... / ...
CommitLineData
1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2010 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 <errno.h>
23#include <signal.h>
24#include <dirent.h>
25#include <unistd.h>
26#include <sys/reboot.h>
27
28#include "manager.h"
29#include "unit.h"
30#include "service.h"
31#include "load-fragment.h"
32#include "load-dropin.h"
33#include "log.h"
34#include "strv.h"
35#include "unit-name.h"
36#include "unit-printf.h"
37#include "dbus-service.h"
38#include "special.h"
39#include "dbus-common.h"
40#include "exit-status.h"
41#include "def.h"
42#include "path-util.h"
43#include "util.h"
44#include "utf8.h"
45#include "env-util.h"
46#include "fileio.h"
47
48#ifdef HAVE_SYSV_COMPAT
49
50#define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
51
52typedef enum RunlevelType {
53 RUNLEVEL_UP,
54 RUNLEVEL_DOWN
55} RunlevelType;
56
57static const struct {
58 const char *path;
59 const char *target;
60 const RunlevelType type;
61} rcnd_table[] = {
62 /* Standard SysV runlevels for start-up */
63 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
64 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
65 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
66 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
67 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
68
69 /* Standard SysV runlevels for shutdown */
70 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
71 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
72
73 /* Note that the order here matters, as we read the
74 directories in this order, and we want to make sure that
75 sysv_start_priority is known when we first load the
76 unit. And that value we only know from S links. Hence
77 UP must be read before DOWN */
78};
79
80#define RUNLEVELS_UP "12345"
81#endif
82
83static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
84 [SERVICE_DEAD] = UNIT_INACTIVE,
85 [SERVICE_START_PRE] = UNIT_ACTIVATING,
86 [SERVICE_START] = UNIT_ACTIVATING,
87 [SERVICE_START_POST] = UNIT_ACTIVATING,
88 [SERVICE_RUNNING] = UNIT_ACTIVE,
89 [SERVICE_EXITED] = UNIT_ACTIVE,
90 [SERVICE_RELOAD] = UNIT_RELOADING,
91 [SERVICE_STOP] = UNIT_DEACTIVATING,
92 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
93 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
94 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
95 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
96 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
97 [SERVICE_FAILED] = UNIT_FAILED,
98 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
99};
100
101/* For Type=idle we never want to delay any other jobs, hence we
102 * consider idle jobs active as soon as we start working on them */
103static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
104 [SERVICE_DEAD] = UNIT_INACTIVE,
105 [SERVICE_START_PRE] = UNIT_ACTIVE,
106 [SERVICE_START] = UNIT_ACTIVE,
107 [SERVICE_START_POST] = UNIT_ACTIVE,
108 [SERVICE_RUNNING] = UNIT_ACTIVE,
109 [SERVICE_EXITED] = UNIT_ACTIVE,
110 [SERVICE_RELOAD] = UNIT_RELOADING,
111 [SERVICE_STOP] = UNIT_DEACTIVATING,
112 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
113 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
114 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
115 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
116 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
117 [SERVICE_FAILED] = UNIT_FAILED,
118 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
119};
120
121static void service_init(Unit *u) {
122 Service *s = SERVICE(u);
123
124 assert(u);
125 assert(u->load_state == UNIT_STUB);
126
127 s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
128 s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
129 s->restart_usec = DEFAULT_RESTART_USEC;
130 s->type = _SERVICE_TYPE_INVALID;
131
132 watch_init(&s->watchdog_watch);
133 watch_init(&s->timer_watch);
134
135#ifdef HAVE_SYSV_COMPAT
136 s->sysv_start_priority = -1;
137 s->sysv_start_priority_from_rcnd = -1;
138#endif
139 s->socket_fd = -1;
140 s->guess_main_pid = true;
141
142 exec_context_init(&s->exec_context);
143 kill_context_init(&s->kill_context);
144 cgroup_context_init(&s->cgroup_context);
145
146 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
147
148 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
149}
150
151static void service_unwatch_control_pid(Service *s) {
152 assert(s);
153
154 if (s->control_pid <= 0)
155 return;
156
157 unit_unwatch_pid(UNIT(s), s->control_pid);
158 s->control_pid = 0;
159}
160
161static void service_unwatch_main_pid(Service *s) {
162 assert(s);
163
164 if (s->main_pid <= 0)
165 return;
166
167 unit_unwatch_pid(UNIT(s), s->main_pid);
168 s->main_pid = 0;
169}
170
171static void service_unwatch_pid_file(Service *s) {
172 if (!s->pid_file_pathspec)
173 return;
174
175 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
176 UNIT(s)->id, s->pid_file_pathspec->path);
177 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
178 path_spec_done(s->pid_file_pathspec);
179 free(s->pid_file_pathspec);
180 s->pid_file_pathspec = NULL;
181}
182
183static int service_set_main_pid(Service *s, pid_t pid) {
184 pid_t ppid;
185
186 assert(s);
187
188 if (pid <= 1)
189 return -EINVAL;
190
191 if (pid == getpid())
192 return -EINVAL;
193
194 service_unwatch_main_pid(s);
195
196 s->main_pid = pid;
197 s->main_pid_known = true;
198
199 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
200 log_warning_unit(UNIT(s)->id,
201 "%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
202 UNIT(s)->id, (unsigned long) pid);
203
204 s->main_pid_alien = true;
205 } else
206 s->main_pid_alien = false;
207
208 exec_status_start(&s->main_exec_status, pid);
209
210 return 0;
211}
212
213static void service_close_socket_fd(Service *s) {
214 assert(s);
215
216 if (s->socket_fd < 0)
217 return;
218
219 close_nointr_nofail(s->socket_fd);
220 s->socket_fd = -1;
221}
222
223static void service_connection_unref(Service *s) {
224 assert(s);
225
226 if (!UNIT_ISSET(s->accept_socket))
227 return;
228
229 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
230 unit_ref_unset(&s->accept_socket);
231}
232
233static void service_stop_watchdog(Service *s) {
234 assert(s);
235
236 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
237 s->watchdog_timestamp.realtime = 0;
238 s->watchdog_timestamp.monotonic = 0;
239}
240
241static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
242
243static void service_handle_watchdog(Service *s) {
244 usec_t offset;
245 int r;
246
247 assert(s);
248
249 if (s->watchdog_usec == 0)
250 return;
251
252 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
253 if (offset >= s->watchdog_usec) {
254 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
255 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_WATCHDOG);
256 return;
257 }
258
259 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->watchdog_usec - offset, &s->watchdog_watch);
260 if (r < 0)
261 log_warning_unit(UNIT(s)->id,
262 "%s failed to install watchdog timer: %s",
263 UNIT(s)->id, strerror(-r));
264}
265
266static void service_reset_watchdog(Service *s) {
267 assert(s);
268
269 dual_timestamp_get(&s->watchdog_timestamp);
270 service_handle_watchdog(s);
271}
272
273static void service_done(Unit *u) {
274 Service *s = SERVICE(u);
275
276 assert(s);
277
278 free(s->pid_file);
279 s->pid_file = NULL;
280
281#ifdef HAVE_SYSV_COMPAT
282 free(s->sysv_runlevels);
283 s->sysv_runlevels = NULL;
284#endif
285
286 free(s->status_text);
287 s->status_text = NULL;
288
289 cgroup_context_done(&s->cgroup_context);
290 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
291 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
292 s->control_command = NULL;
293 s->main_command = NULL;
294
295 set_free(s->restart_ignore_status.code);
296 s->restart_ignore_status.code = NULL;
297 set_free(s->restart_ignore_status.signal);
298 s->restart_ignore_status.signal = NULL;
299
300 set_free(s->success_status.code);
301 s->success_status.code = NULL;
302 set_free(s->success_status.signal);
303 s->success_status.signal = NULL;
304
305 /* This will leak a process, but at least no memory or any of
306 * our resources */
307 service_unwatch_main_pid(s);
308 service_unwatch_control_pid(s);
309 service_unwatch_pid_file(s);
310
311 if (s->bus_name) {
312 unit_unwatch_bus_name(u, s->bus_name);
313 free(s->bus_name);
314 s->bus_name = NULL;
315 }
316
317 service_close_socket_fd(s);
318 service_connection_unref(s);
319
320 unit_ref_unset(&s->accept_socket);
321
322 service_stop_watchdog(s);
323
324 unit_unwatch_timer(u, &s->timer_watch);
325}
326
327#ifdef HAVE_SYSV_COMPAT
328static char *sysv_translate_name(const char *name) {
329 char *r;
330
331 r = new(char, strlen(name) + sizeof(".service"));
332 if (!r)
333 return NULL;
334
335 if (endswith(name, ".sh"))
336 /* Drop .sh suffix */
337 strcpy(stpcpy(r, name) - 3, ".service");
338 else
339 /* Normal init script name */
340 strcpy(stpcpy(r, name), ".service");
341
342 return r;
343}
344
345static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
346
347 /* We silently ignore the $ prefix here. According to the LSB
348 * spec it simply indicates whether something is a
349 * standardized name or a distribution-specific one. Since we
350 * just follow what already exists and do not introduce new
351 * uses or names we don't care who introduced a new name. */
352
353 static const char * const table[] = {
354 /* LSB defined facilities */
355 "local_fs", NULL,
356 "network", SPECIAL_NETWORK_TARGET,
357 "named", SPECIAL_NSS_LOOKUP_TARGET,
358 "portmap", SPECIAL_RPCBIND_TARGET,
359 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
360 "syslog", NULL,
361 "time", SPECIAL_TIME_SYNC_TARGET,
362 };
363
364 unsigned i;
365 char *r;
366 const char *n;
367
368 assert(name);
369 assert(_r);
370
371 n = *name == '$' ? name + 1 : name;
372
373 for (i = 0; i < ELEMENTSOF(table); i += 2) {
374
375 if (!streq(table[i], n))
376 continue;
377
378 if (!table[i+1])
379 return 0;
380
381 r = strdup(table[i+1]);
382 if (!r)
383 return log_oom();
384
385 goto finish;
386 }
387
388 /* If we don't know this name, fallback heuristics to figure
389 * out whether something is a target or a service alias. */
390
391 if (*name == '$') {
392 if (!unit_prefix_is_valid(n))
393 return -EINVAL;
394
395 /* Facilities starting with $ are most likely targets */
396 r = unit_name_build(n, NULL, ".target");
397 } else if (filename && streq(name, filename))
398 /* Names equaling the file name of the services are redundant */
399 return 0;
400 else
401 /* Everything else we assume to be normal service names */
402 r = sysv_translate_name(n);
403
404 if (!r)
405 return -ENOMEM;
406
407finish:
408 *_r = r;
409
410 return 1;
411}
412
413static int sysv_fix_order(Service *s) {
414 Unit *other;
415 int r;
416
417 assert(s);
418
419 if (s->sysv_start_priority < 0)
420 return 0;
421
422 /* For each pair of services where at least one lacks a LSB
423 * header, we use the start priority value to order things. */
424
425 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
426 Service *t;
427 UnitDependency d;
428 bool special_s, special_t;
429
430 t = SERVICE(other);
431
432 if (s == t)
433 continue;
434
435 if (UNIT(t)->load_state != UNIT_LOADED)
436 continue;
437
438 if (t->sysv_start_priority < 0)
439 continue;
440
441 /* If both units have modern headers we don't care
442 * about the priorities */
443 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
444 (UNIT(t)->fragment_path || t->sysv_has_lsb))
445 continue;
446
447 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
448 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
449
450 if (special_t && !special_s)
451 d = UNIT_AFTER;
452 else if (special_s && !special_t)
453 d = UNIT_BEFORE;
454 else if (t->sysv_start_priority < s->sysv_start_priority)
455 d = UNIT_AFTER;
456 else if (t->sysv_start_priority > s->sysv_start_priority)
457 d = UNIT_BEFORE;
458 else
459 continue;
460
461 /* FIXME: Maybe we should compare the name here lexicographically? */
462
463 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
464 return r;
465 }
466
467 return 0;
468}
469
470static ExecCommand *exec_command_new(const char *path, const char *arg1) {
471 ExecCommand *c;
472
473 if (!(c = new0(ExecCommand, 1)))
474 return NULL;
475
476 if (!(c->path = strdup(path))) {
477 free(c);
478 return NULL;
479 }
480
481 if (!(c->argv = strv_new(path, arg1, NULL))) {
482 free(c->path);
483 free(c);
484 return NULL;
485 }
486
487 return c;
488}
489
490static int sysv_exec_commands(Service *s, const bool supports_reload) {
491 ExecCommand *c;
492
493 assert(s);
494 assert(s->is_sysv);
495 assert(UNIT(s)->source_path);
496
497 c = exec_command_new(UNIT(s)->source_path, "start");
498 if (!c)
499 return -ENOMEM;
500 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
501
502 c = exec_command_new(UNIT(s)->source_path, "stop");
503 if (!c)
504 return -ENOMEM;
505 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
506
507 if (supports_reload) {
508 c = exec_command_new(UNIT(s)->source_path, "reload");
509 if (!c)
510 return -ENOMEM;
511 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
512 }
513
514 return 0;
515}
516
517static bool usage_contains_reload(const char *line) {
518 return (strcasestr(line, "{reload|") ||
519 strcasestr(line, "{reload}") ||
520 strcasestr(line, "{reload\"") ||
521 strcasestr(line, "|reload|") ||
522 strcasestr(line, "|reload}") ||
523 strcasestr(line, "|reload\""));
524}
525
526static int service_load_sysv_path(Service *s, const char *path) {
527 FILE *f;
528 Unit *u;
529 unsigned line = 0;
530 int r;
531 enum {
532 NORMAL,
533 DESCRIPTION,
534 LSB,
535 LSB_DESCRIPTION,
536 USAGE_CONTINUATION
537 } state = NORMAL;
538 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
539 struct stat st;
540 bool supports_reload = false;
541
542 assert(s);
543 assert(path);
544
545 u = UNIT(s);
546
547 f = fopen(path, "re");
548 if (!f) {
549 r = errno == ENOENT ? 0 : -errno;
550 goto finish;
551 }
552
553 if (fstat(fileno(f), &st) < 0) {
554 r = -errno;
555 goto finish;
556 }
557
558 free(u->source_path);
559 u->source_path = strdup(path);
560 if (!u->source_path) {
561 r = -ENOMEM;
562 goto finish;
563 }
564 u->source_mtime = timespec_load(&st.st_mtim);
565
566 if (null_or_empty(&st)) {
567 u->load_state = UNIT_MASKED;
568 r = 0;
569 goto finish;
570 }
571
572 s->is_sysv = true;
573
574 while (!feof(f)) {
575 char l[LINE_MAX], *t;
576
577 if (!fgets(l, sizeof(l), f)) {
578 if (feof(f))
579 break;
580
581 r = -errno;
582 log_error_unit(u->id,
583 "Failed to read configuration file '%s': %s",
584 path, strerror(-r));
585 goto finish;
586 }
587
588 line++;
589
590 t = strstrip(l);
591 if (*t != '#') {
592 /* Try to figure out whether this init script supports
593 * the reload operation. This heuristic looks for
594 * "Usage" lines which include the reload option. */
595 if ( state == USAGE_CONTINUATION ||
596 (state == NORMAL && strcasestr(t, "usage"))) {
597 if (usage_contains_reload(t)) {
598 supports_reload = true;
599 state = NORMAL;
600 } else if (t[strlen(t)-1] == '\\')
601 state = USAGE_CONTINUATION;
602 else
603 state = NORMAL;
604 }
605
606 continue;
607 }
608
609 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
610 state = LSB;
611 s->sysv_has_lsb = true;
612 continue;
613 }
614
615 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
616 state = NORMAL;
617 continue;
618 }
619
620 t++;
621 t += strspn(t, WHITESPACE);
622
623 if (state == NORMAL) {
624
625 /* Try to parse Red Hat style chkconfig headers */
626
627 if (startswith_no_case(t, "chkconfig:")) {
628 int start_priority;
629 char runlevels[16], *k;
630
631 state = NORMAL;
632
633 if (sscanf(t+10, "%15s %i %*i",
634 runlevels,
635 &start_priority) != 2) {
636
637 log_warning_unit(u->id,
638 "[%s:%u] Failed to parse chkconfig line. Ignoring.",
639 path, line);
640 continue;
641 }
642
643 /* A start priority gathered from the
644 * symlink farms is preferred over the
645 * data from the LSB header. */
646 if (start_priority < 0 || start_priority > 99)
647 log_warning_unit(u->id,
648 "[%s:%u] Start priority out of range. Ignoring.",
649 path, line);
650 else
651 s->sysv_start_priority = start_priority;
652
653 char_array_0(runlevels);
654 k = delete_chars(runlevels, WHITESPACE "-");
655
656 if (k[0]) {
657 char *d;
658
659 if (!(d = strdup(k))) {
660 r = -ENOMEM;
661 goto finish;
662 }
663
664 free(s->sysv_runlevels);
665 s->sysv_runlevels = d;
666 }
667
668 } else if (startswith_no_case(t, "description:")) {
669
670 size_t k = strlen(t);
671 char *d;
672 const char *j;
673
674 if (t[k-1] == '\\') {
675 state = DESCRIPTION;
676 t[k-1] = 0;
677 }
678
679 if ((j = strstrip(t+12)) && *j) {
680 if (!(d = strdup(j))) {
681 r = -ENOMEM;
682 goto finish;
683 }
684 } else
685 d = NULL;
686
687 free(chkconfig_description);
688 chkconfig_description = d;
689
690 } else if (startswith_no_case(t, "pidfile:")) {
691
692 char *fn;
693
694 state = NORMAL;
695
696 fn = strstrip(t+8);
697 if (!path_is_absolute(fn)) {
698 log_warning_unit(u->id,
699 "[%s:%u] PID file not absolute. Ignoring.",
700 path, line);
701 continue;
702 }
703
704 if (!(fn = strdup(fn))) {
705 r = -ENOMEM;
706 goto finish;
707 }
708
709 free(s->pid_file);
710 s->pid_file = fn;
711 }
712
713 } else if (state == DESCRIPTION) {
714
715 /* Try to parse Red Hat style description
716 * continuation */
717
718 size_t k = strlen(t);
719 char *j;
720
721 if (t[k-1] == '\\')
722 t[k-1] = 0;
723 else
724 state = NORMAL;
725
726 if ((j = strstrip(t)) && *j) {
727 char *d = NULL;
728
729 if (chkconfig_description)
730 d = strjoin(chkconfig_description, " ", j, NULL);
731 else
732 d = strdup(j);
733
734 if (!d) {
735 r = -ENOMEM;
736 goto finish;
737 }
738
739 free(chkconfig_description);
740 chkconfig_description = d;
741 }
742
743 } else if (state == LSB || state == LSB_DESCRIPTION) {
744
745 if (startswith_no_case(t, "Provides:")) {
746 char *i, *w;
747 size_t z;
748
749 state = LSB;
750
751 FOREACH_WORD_QUOTED(w, z, t+9, i) {
752 char *n, *m;
753
754 if (!(n = strndup(w, z))) {
755 r = -ENOMEM;
756 goto finish;
757 }
758
759 r = sysv_translate_facility(n, path_get_file_name(path), &m);
760 free(n);
761
762 if (r < 0)
763 goto finish;
764
765 if (r == 0)
766 continue;
767
768 if (unit_name_to_type(m) == UNIT_SERVICE)
769 r = unit_merge_by_name(u, m);
770 else
771 /* NB: SysV targets
772 * which are provided
773 * by a service are
774 * pulled in by the
775 * services, as an
776 * indication that the
777 * generic service is
778 * now available. This
779 * is strictly
780 * one-way. The
781 * targets do NOT pull
782 * in the SysV
783 * services! */
784 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
785
786 if (r < 0)
787 log_error_unit(u->id,
788 "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
789 path, line, m, strerror(-r));
790
791 free(m);
792 }
793
794 } else if (startswith_no_case(t, "Required-Start:") ||
795 startswith_no_case(t, "Should-Start:") ||
796 startswith_no_case(t, "X-Start-Before:") ||
797 startswith_no_case(t, "X-Start-After:")) {
798 char *i, *w;
799 size_t z;
800
801 state = LSB;
802
803 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
804 char *n, *m;
805
806 if (!(n = strndup(w, z))) {
807 r = -ENOMEM;
808 goto finish;
809 }
810
811 r = sysv_translate_facility(n, path_get_file_name(path), &m);
812 if (r < 0) {
813 log_error_unit(u->id,
814 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
815 path, line, n, strerror(-r));
816 free(n);
817 continue;
818 }
819
820 free(n);
821
822 if (r == 0)
823 continue;
824
825 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
826
827 if (r < 0)
828 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
829 path, line, m, strerror(-r));
830
831 free(m);
832 }
833 } else if (startswith_no_case(t, "Default-Start:")) {
834 char *k, *d;
835
836 state = LSB;
837
838 k = delete_chars(t+14, WHITESPACE "-");
839
840 if (k[0] != 0) {
841 if (!(d = strdup(k))) {
842 r = -ENOMEM;
843 goto finish;
844 }
845
846 free(s->sysv_runlevels);
847 s->sysv_runlevels = d;
848 }
849
850 } else if (startswith_no_case(t, "Description:")) {
851 char *d, *j;
852
853 state = LSB_DESCRIPTION;
854
855 if ((j = strstrip(t+12)) && *j) {
856 if (!(d = strdup(j))) {
857 r = -ENOMEM;
858 goto finish;
859 }
860 } else
861 d = NULL;
862
863 free(long_description);
864 long_description = d;
865
866 } else if (startswith_no_case(t, "Short-Description:")) {
867 char *d, *j;
868
869 state = LSB;
870
871 if ((j = strstrip(t+18)) && *j) {
872 if (!(d = strdup(j))) {
873 r = -ENOMEM;
874 goto finish;
875 }
876 } else
877 d = NULL;
878
879 free(short_description);
880 short_description = d;
881
882 } else if (state == LSB_DESCRIPTION) {
883
884 if (startswith(l, "#\t") || startswith(l, "# ")) {
885 char *j;
886
887 if ((j = strstrip(t)) && *j) {
888 char *d = NULL;
889
890 if (long_description)
891 d = strjoin(long_description, " ", t, NULL);
892 else
893 d = strdup(j);
894
895 if (!d) {
896 r = -ENOMEM;
897 goto finish;
898 }
899
900 free(long_description);
901 long_description = d;
902 }
903
904 } else
905 state = LSB;
906 }
907 }
908 }
909
910 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
911 goto finish;
912
913 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
914 /* If there a runlevels configured for this service
915 * but none of the standard ones, then we assume this
916 * is some special kind of service (which might be
917 * needed for early boot) and don't create any links
918 * to it. */
919
920 UNIT(s)->default_dependencies = false;
921
922 /* Don't timeout special services during boot (like fsck) */
923 s->timeout_start_usec = 0;
924 s->timeout_stop_usec = 0;
925 } else {
926 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
927 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
928 }
929
930 /* Special setting for all SysV services */
931 s->type = SERVICE_FORKING;
932 s->remain_after_exit = !s->pid_file;
933 s->guess_main_pid = false;
934 s->restart = SERVICE_RESTART_NO;
935 s->exec_context.ignore_sigpipe = false;
936 s->kill_context.kill_mode = KILL_PROCESS;
937
938 /* We use the long description only if
939 * no short description is set. */
940
941 if (short_description)
942 description = short_description;
943 else if (chkconfig_description)
944 description = chkconfig_description;
945 else if (long_description)
946 description = long_description;
947 else
948 description = NULL;
949
950 if (description) {
951 char *d;
952
953 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
954 r = -ENOMEM;
955 goto finish;
956 }
957
958 u->description = d;
959 }
960
961 /* The priority that has been set in /etc/rcN.d/ hierarchies
962 * takes precedence over what is stored as default in the LSB
963 * header */
964 if (s->sysv_start_priority_from_rcnd >= 0)
965 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
966
967 u->load_state = UNIT_LOADED;
968 r = 0;
969
970finish:
971
972 if (f)
973 fclose(f);
974
975 free(short_description);
976 free(long_description);
977 free(chkconfig_description);
978
979 return r;
980}
981
982static int service_load_sysv_name(Service *s, const char *name) {
983 char **p;
984
985 assert(s);
986 assert(name);
987
988 /* For SysV services we strip the *.sh suffixes. */
989 if (endswith(name, ".sh.service"))
990 return -ENOENT;
991
992 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
993 char *path;
994 int r;
995
996 path = strjoin(*p, "/", name, NULL);
997 if (!path)
998 return -ENOMEM;
999
1000 assert(endswith(path, ".service"));
1001 path[strlen(path)-8] = 0;
1002
1003 r = service_load_sysv_path(s, path);
1004
1005 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1006 /* Try *.sh source'able init scripts */
1007 strcat(path, ".sh");
1008 r = service_load_sysv_path(s, path);
1009 }
1010 free(path);
1011
1012 if (r < 0)
1013 return r;
1014
1015 if (UNIT(s)->load_state != UNIT_STUB)
1016 break;
1017 }
1018
1019 return 0;
1020}
1021
1022static int service_load_sysv(Service *s) {
1023 const char *t;
1024 Iterator i;
1025 int r;
1026
1027 assert(s);
1028
1029 /* Load service data from SysV init scripts, preferably with
1030 * LSB headers ... */
1031
1032 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1033 return 0;
1034
1035 if ((t = UNIT(s)->id))
1036 if ((r = service_load_sysv_name(s, t)) < 0)
1037 return r;
1038
1039 if (UNIT(s)->load_state == UNIT_STUB)
1040 SET_FOREACH(t, UNIT(s)->names, i) {
1041 if (t == UNIT(s)->id)
1042 continue;
1043
1044 if ((r = service_load_sysv_name(s, t)) < 0)
1045 return r;
1046
1047 if (UNIT(s)->load_state != UNIT_STUB)
1048 break;
1049 }
1050
1051 return 0;
1052}
1053#endif
1054
1055static int fsck_fix_order(Service *s) {
1056 Unit *other;
1057 int r;
1058
1059 assert(s);
1060
1061 if (s->fsck_passno <= 0)
1062 return 0;
1063
1064 /* For each pair of services where both have an fsck priority
1065 * we order things based on it. */
1066
1067 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1068 Service *t;
1069 UnitDependency d;
1070
1071 t = SERVICE(other);
1072
1073 if (s == t)
1074 continue;
1075
1076 if (UNIT(t)->load_state != UNIT_LOADED)
1077 continue;
1078
1079 if (t->fsck_passno <= 0)
1080 continue;
1081
1082 if (t->fsck_passno < s->fsck_passno)
1083 d = UNIT_AFTER;
1084 else if (t->fsck_passno > s->fsck_passno)
1085 d = UNIT_BEFORE;
1086 else
1087 continue;
1088
1089 r = unit_add_dependency(UNIT(s), d, UNIT(t), true);
1090 if (r < 0)
1091 return r;
1092 }
1093
1094 return 0;
1095}
1096
1097static int service_verify(Service *s) {
1098 assert(s);
1099
1100 if (UNIT(s)->load_state != UNIT_LOADED)
1101 return 0;
1102
1103 if (!s->exec_command[SERVICE_EXEC_START]) {
1104 log_error_unit(UNIT(s)->id,
1105 "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1106 return -EINVAL;
1107 }
1108
1109 if (s->type != SERVICE_ONESHOT &&
1110 s->exec_command[SERVICE_EXEC_START]->command_next) {
1111 log_error_unit(UNIT(s)->id,
1112 "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1113 return -EINVAL;
1114 }
1115
1116 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1117 log_error_unit(UNIT(s)->id,
1118 "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1119 return -EINVAL;
1120 }
1121
1122 if (s->type == SERVICE_DBUS && !s->bus_name) {
1123 log_error_unit(UNIT(s)->id,
1124 "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1125 return -EINVAL;
1126 }
1127
1128 if (s->bus_name && s->type != SERVICE_DBUS)
1129 log_warning_unit(UNIT(s)->id,
1130 "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1131
1132 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
1133 log_error_unit(UNIT(s)->id,
1134 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1135 return -EINVAL;
1136 }
1137
1138 return 0;
1139}
1140
1141static int service_add_default_dependencies(Service *s) {
1142 int r;
1143
1144 assert(s);
1145
1146 /* Add a number of automatic dependencies useful for the
1147 * majority of services. */
1148
1149 /* First, pull in base system */
1150 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
1151 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1152 SPECIAL_BASIC_TARGET, NULL, true);
1153 if (r < 0)
1154 return r;
1155
1156 } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
1157 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1158 SPECIAL_SOCKETS_TARGET, NULL, true);
1159 if (r < 0)
1160 return r;
1161
1162 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1163 SPECIAL_TIMERS_TARGET, NULL, true);
1164 if (r < 0)
1165 return r;
1166
1167 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1168 SPECIAL_PATHS_TARGET, NULL, true);
1169 if (r < 0)
1170 return r;
1171 }
1172
1173 /* Second, activate normal shutdown */
1174 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1175 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1176 return r;
1177}
1178
1179static void service_fix_output(Service *s) {
1180 assert(s);
1181
1182 /* If nothing has been explicitly configured, patch default
1183 * output in. If input is socket/tty we avoid this however,
1184 * since in that case we want output to default to the same
1185 * place as we read input from. */
1186
1187 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1188 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1189 s->exec_context.std_input == EXEC_INPUT_NULL)
1190 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1191
1192 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1193 s->exec_context.std_input == EXEC_INPUT_NULL)
1194 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1195}
1196
1197static int service_load(Unit *u) {
1198 int r;
1199 Service *s = SERVICE(u);
1200
1201 assert(s);
1202
1203 /* Load a .service file */
1204 r = unit_load_fragment(u);
1205 if (r < 0)
1206 return r;
1207
1208#ifdef HAVE_SYSV_COMPAT
1209 /* Load a classic init script as a fallback, if we couldn't find anything */
1210 if (u->load_state == UNIT_STUB) {
1211 r = service_load_sysv(s);
1212 if (r < 0)
1213 return r;
1214 }
1215#endif
1216
1217 /* Still nothing found? Then let's give up */
1218 if (u->load_state == UNIT_STUB)
1219 return -ENOENT;
1220
1221 /* This is a new unit? Then let's add in some extras */
1222 if (u->load_state == UNIT_LOADED) {
1223
1224 /* We were able to load something, then let's add in
1225 * the dropin directories. */
1226 r = unit_load_dropin(u);
1227 if (r < 0)
1228 return r;
1229
1230 if (s->type == _SERVICE_TYPE_INVALID)
1231 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1232
1233 /* Oneshot services have disabled start timeout by default */
1234 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1235 s->timeout_start_usec = 0;
1236
1237 service_fix_output(s);
1238
1239 r = unit_add_exec_dependencies(u, &s->exec_context);
1240 if (r < 0)
1241 return r;
1242
1243 r = unit_add_default_slice(u);
1244 if (r < 0)
1245 return r;
1246
1247#ifdef HAVE_SYSV_COMPAT
1248 r = sysv_fix_order(s);
1249 if (r < 0)
1250 return r;
1251#endif
1252
1253 r = fsck_fix_order(s);
1254 if (r < 0)
1255 return r;
1256
1257 if (s->bus_name)
1258 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1259 return r;
1260
1261 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1262 s->notify_access = NOTIFY_MAIN;
1263
1264 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1265 s->notify_access = NOTIFY_MAIN;
1266
1267 if (s->type == SERVICE_DBUS || s->bus_name) {
1268 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES,
1269 SPECIAL_DBUS_SOCKET, NULL, true);
1270 if (r < 0)
1271 return r;
1272 }
1273
1274 if (UNIT(s)->default_dependencies) {
1275 r = service_add_default_dependencies(s);
1276 if (r < 0)
1277 return r;
1278 }
1279
1280 r = unit_exec_context_defaults(u, &s->exec_context);
1281 if (r < 0)
1282 return r;
1283 }
1284
1285 return service_verify(s);
1286}
1287
1288static void service_dump(Unit *u, FILE *f, const char *prefix) {
1289
1290 ServiceExecCommand c;
1291 Service *s = SERVICE(u);
1292 const char *prefix2;
1293 _cleanup_free_ char *p2 = NULL;
1294
1295 assert(s);
1296
1297 p2 = strappend(prefix, "\t");
1298 prefix2 = p2 ? p2 : prefix;
1299
1300 fprintf(f,
1301 "%sService State: %s\n"
1302 "%sResult: %s\n"
1303 "%sReload Result: %s\n"
1304 "%sPermissionsStartOnly: %s\n"
1305 "%sRootDirectoryStartOnly: %s\n"
1306 "%sRemainAfterExit: %s\n"
1307 "%sGuessMainPID: %s\n"
1308 "%sType: %s\n"
1309 "%sRestart: %s\n"
1310 "%sNotifyAccess: %s\n",
1311 prefix, service_state_to_string(s->state),
1312 prefix, service_result_to_string(s->result),
1313 prefix, service_result_to_string(s->reload_result),
1314 prefix, yes_no(s->permissions_start_only),
1315 prefix, yes_no(s->root_directory_start_only),
1316 prefix, yes_no(s->remain_after_exit),
1317 prefix, yes_no(s->guess_main_pid),
1318 prefix, service_type_to_string(s->type),
1319 prefix, service_restart_to_string(s->restart),
1320 prefix, notify_access_to_string(s->notify_access));
1321
1322 if (s->control_pid > 0)
1323 fprintf(f,
1324 "%sControl PID: %lu\n",
1325 prefix, (unsigned long) s->control_pid);
1326
1327 if (s->main_pid > 0)
1328 fprintf(f,
1329 "%sMain PID: %lu\n"
1330 "%sMain PID Known: %s\n"
1331 "%sMain PID Alien: %s\n",
1332 prefix, (unsigned long) s->main_pid,
1333 prefix, yes_no(s->main_pid_known),
1334 prefix, yes_no(s->main_pid_alien));
1335
1336 if (s->pid_file)
1337 fprintf(f,
1338 "%sPIDFile: %s\n",
1339 prefix, s->pid_file);
1340
1341 if (s->bus_name)
1342 fprintf(f,
1343 "%sBusName: %s\n"
1344 "%sBus Name Good: %s\n",
1345 prefix, s->bus_name,
1346 prefix, yes_no(s->bus_name_good));
1347
1348 kill_context_dump(&s->kill_context, f, prefix);
1349 exec_context_dump(&s->exec_context, f, prefix);
1350
1351 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1352
1353 if (!s->exec_command[c])
1354 continue;
1355
1356 fprintf(f, "%s-> %s:\n",
1357 prefix, service_exec_command_to_string(c));
1358
1359 exec_command_dump_list(s->exec_command[c], f, prefix2);
1360 }
1361
1362#ifdef HAVE_SYSV_COMPAT
1363 if (s->is_sysv)
1364 fprintf(f,
1365 "%sSysV Init Script has LSB Header: %s\n"
1366 "%sSysVEnabled: %s\n",
1367 prefix, yes_no(s->sysv_has_lsb),
1368 prefix, yes_no(s->sysv_enabled));
1369
1370 if (s->sysv_start_priority >= 0)
1371 fprintf(f,
1372 "%sSysVStartPriority: %i\n",
1373 prefix, s->sysv_start_priority);
1374
1375 if (s->sysv_runlevels)
1376 fprintf(f, "%sSysVRunLevels: %s\n",
1377 prefix, s->sysv_runlevels);
1378#endif
1379
1380 if (s->fsck_passno > 0)
1381 fprintf(f,
1382 "%sFsckPassNo: %i\n",
1383 prefix, s->fsck_passno);
1384
1385 if (s->status_text)
1386 fprintf(f, "%sStatus Text: %s\n",
1387 prefix, s->status_text);
1388}
1389
1390static int service_load_pid_file(Service *s, bool may_warn) {
1391 _cleanup_free_ char *k = NULL;
1392 int r;
1393 pid_t pid;
1394
1395 assert(s);
1396
1397 if (!s->pid_file)
1398 return -ENOENT;
1399
1400 r = read_one_line_file(s->pid_file, &k);
1401 if (r < 0) {
1402 if (may_warn)
1403 log_info_unit(UNIT(s)->id,
1404 "PID file %s not readable (yet?) after %s.",
1405 s->pid_file, service_state_to_string(s->state));
1406 return r;
1407 }
1408
1409 r = parse_pid(k, &pid);
1410 if (r < 0) {
1411 if (may_warn)
1412 log_info_unit(UNIT(s)->id,
1413 "Failed to read PID from file %s: %s",
1414 s->pid_file, strerror(-r));
1415 return r;
1416 }
1417
1418 if (kill(pid, 0) < 0 && errno != EPERM) {
1419 if (may_warn)
1420 log_info_unit(UNIT(s)->id,
1421 "PID %lu read from file %s does not exist.",
1422 (unsigned long) pid, s->pid_file);
1423 return -ESRCH;
1424 }
1425
1426 if (s->main_pid_known) {
1427 if (pid == s->main_pid)
1428 return 0;
1429
1430 log_debug_unit(UNIT(s)->id,
1431 "Main PID changing: %lu -> %lu",
1432 (unsigned long) s->main_pid, (unsigned long) pid);
1433 service_unwatch_main_pid(s);
1434 s->main_pid_known = false;
1435 } else
1436 log_debug_unit(UNIT(s)->id,
1437 "Main PID loaded: %lu", (unsigned long) pid);
1438
1439 r = service_set_main_pid(s, pid);
1440 if (r < 0)
1441 return r;
1442
1443 r = unit_watch_pid(UNIT(s), pid);
1444 if (r < 0) {
1445 /* FIXME: we need to do something here */
1446 log_warning_unit(UNIT(s)->id,
1447 "Failed to watch PID %lu from service %s",
1448 (unsigned long) pid, UNIT(s)->id);
1449 return r;
1450 }
1451
1452 return 0;
1453}
1454
1455static int service_search_main_pid(Service *s) {
1456 pid_t pid;
1457 int r;
1458
1459 assert(s);
1460
1461 /* If we know it anyway, don't ever fallback to unreliable
1462 * heuristics */
1463 if (s->main_pid_known)
1464 return 0;
1465
1466 if (!s->guess_main_pid)
1467 return 0;
1468
1469 assert(s->main_pid <= 0);
1470
1471 pid = unit_search_main_pid(UNIT(s));
1472 if (pid <= 0)
1473 return -ENOENT;
1474
1475 log_debug_unit(UNIT(s)->id,
1476 "Main PID guessed: %lu", (unsigned long) pid);
1477 r = service_set_main_pid(s, pid);
1478 if (r < 0)
1479 return r;
1480
1481 r = unit_watch_pid(UNIT(s), pid);
1482 if (r < 0)
1483 /* FIXME: we need to do something here */
1484 log_warning_unit(UNIT(s)->id,
1485 "Failed to watch PID %lu from service %s",
1486 (unsigned long) pid, UNIT(s)->id);
1487 return r;
1488
1489 return 0;
1490}
1491
1492static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1493 Iterator i;
1494 Unit *u;
1495
1496 assert(s);
1497
1498 /* Notifies all our sockets when we die */
1499
1500 if (s->socket_fd >= 0)
1501 return;
1502
1503 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1504 if (u->type == UNIT_SOCKET)
1505 socket_notify_service_dead(SOCKET(u), failed_permanent);
1506
1507 return;
1508}
1509
1510static void service_set_state(Service *s, ServiceState state) {
1511 ServiceState old_state;
1512 const UnitActiveState *table;
1513 assert(s);
1514
1515 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1516
1517 old_state = s->state;
1518 s->state = state;
1519
1520 service_unwatch_pid_file(s);
1521
1522 if (state != SERVICE_START_PRE &&
1523 state != SERVICE_START &&
1524 state != SERVICE_START_POST &&
1525 state != SERVICE_RELOAD &&
1526 state != SERVICE_STOP &&
1527 state != SERVICE_STOP_SIGTERM &&
1528 state != SERVICE_STOP_SIGKILL &&
1529 state != SERVICE_STOP_POST &&
1530 state != SERVICE_FINAL_SIGTERM &&
1531 state != SERVICE_FINAL_SIGKILL &&
1532 state != SERVICE_AUTO_RESTART)
1533 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1534
1535 if (state != SERVICE_START &&
1536 state != SERVICE_START_POST &&
1537 state != SERVICE_RUNNING &&
1538 state != SERVICE_RELOAD &&
1539 state != SERVICE_STOP &&
1540 state != SERVICE_STOP_SIGTERM &&
1541 state != SERVICE_STOP_SIGKILL) {
1542 service_unwatch_main_pid(s);
1543 s->main_command = NULL;
1544 }
1545
1546 if (state != SERVICE_START_PRE &&
1547 state != SERVICE_START &&
1548 state != SERVICE_START_POST &&
1549 state != SERVICE_RELOAD &&
1550 state != SERVICE_STOP &&
1551 state != SERVICE_STOP_SIGTERM &&
1552 state != SERVICE_STOP_SIGKILL &&
1553 state != SERVICE_STOP_POST &&
1554 state != SERVICE_FINAL_SIGTERM &&
1555 state != SERVICE_FINAL_SIGKILL) {
1556 service_unwatch_control_pid(s);
1557 s->control_command = NULL;
1558 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1559 }
1560
1561 if (state == SERVICE_FAILED)
1562 service_notify_sockets_dead(s, s->result == SERVICE_FAILURE_START_LIMIT);
1563
1564 if (state == SERVICE_DEAD ||
1565 state == SERVICE_STOP ||
1566 state == SERVICE_STOP_SIGTERM ||
1567 state == SERVICE_STOP_SIGKILL ||
1568 state == SERVICE_STOP_POST ||
1569 state == SERVICE_FINAL_SIGTERM ||
1570 state == SERVICE_FINAL_SIGKILL ||
1571 state == SERVICE_AUTO_RESTART)
1572 service_notify_sockets_dead(s, false);
1573
1574 if (state != SERVICE_START_PRE &&
1575 state != SERVICE_START &&
1576 state != SERVICE_START_POST &&
1577 state != SERVICE_RUNNING &&
1578 state != SERVICE_RELOAD &&
1579 state != SERVICE_STOP &&
1580 state != SERVICE_STOP_SIGTERM &&
1581 state != SERVICE_STOP_SIGKILL &&
1582 state != SERVICE_STOP_POST &&
1583 state != SERVICE_FINAL_SIGTERM &&
1584 state != SERVICE_FINAL_SIGKILL &&
1585 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1586 service_close_socket_fd(s);
1587 service_connection_unref(s);
1588 }
1589
1590 if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
1591 service_stop_watchdog(s);
1592
1593 /* For the inactive states unit_notify() will trim the cgroup,
1594 * but for exit we have to do that ourselves... */
1595 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1596 unit_destroy_cgroup(UNIT(s));
1597
1598 if (old_state != state)
1599 log_debug_unit(UNIT(s)->id,
1600 "%s changed %s -> %s", UNIT(s)->id,
1601 service_state_to_string(old_state),
1602 service_state_to_string(state));
1603
1604 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1605 s->reload_result = SERVICE_SUCCESS;
1606}
1607
1608static int service_coldplug(Unit *u) {
1609 Service *s = SERVICE(u);
1610 int r;
1611
1612 assert(s);
1613 assert(s->state == SERVICE_DEAD);
1614
1615 if (s->deserialized_state != s->state) {
1616
1617 if (s->deserialized_state == SERVICE_START_PRE ||
1618 s->deserialized_state == SERVICE_START ||
1619 s->deserialized_state == SERVICE_START_POST ||
1620 s->deserialized_state == SERVICE_RELOAD ||
1621 s->deserialized_state == SERVICE_STOP ||
1622 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1623 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1624 s->deserialized_state == SERVICE_STOP_POST ||
1625 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1626 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1627 s->deserialized_state == SERVICE_AUTO_RESTART) {
1628
1629 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
1630 usec_t k;
1631
1632 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
1633
1634 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1635 if (r < 0)
1636 return r;
1637 }
1638 }
1639
1640 if ((s->deserialized_state == SERVICE_START &&
1641 (s->type == SERVICE_FORKING ||
1642 s->type == SERVICE_DBUS ||
1643 s->type == SERVICE_ONESHOT ||
1644 s->type == SERVICE_NOTIFY)) ||
1645 s->deserialized_state == SERVICE_START_POST ||
1646 s->deserialized_state == SERVICE_RUNNING ||
1647 s->deserialized_state == SERVICE_RELOAD ||
1648 s->deserialized_state == SERVICE_STOP ||
1649 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1650 s->deserialized_state == SERVICE_STOP_SIGKILL)
1651 if (s->main_pid > 0) {
1652 r = unit_watch_pid(UNIT(s), s->main_pid);
1653 if (r < 0)
1654 return r;
1655 }
1656
1657 if (s->deserialized_state == SERVICE_START_PRE ||
1658 s->deserialized_state == SERVICE_START ||
1659 s->deserialized_state == SERVICE_START_POST ||
1660 s->deserialized_state == SERVICE_RELOAD ||
1661 s->deserialized_state == SERVICE_STOP ||
1662 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1663 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1664 s->deserialized_state == SERVICE_STOP_POST ||
1665 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1666 s->deserialized_state == SERVICE_FINAL_SIGKILL)
1667 if (s->control_pid > 0) {
1668 r = unit_watch_pid(UNIT(s), s->control_pid);
1669 if (r < 0)
1670 return r;
1671 }
1672
1673 if (s->deserialized_state == SERVICE_START_POST ||
1674 s->deserialized_state == SERVICE_RUNNING)
1675 service_handle_watchdog(s);
1676
1677 service_set_state(s, s->deserialized_state);
1678 }
1679 return 0;
1680}
1681
1682static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1683 Iterator i;
1684 int r;
1685 int *rfds = NULL;
1686 unsigned rn_fds = 0;
1687 Unit *u;
1688
1689 assert(s);
1690 assert(fds);
1691 assert(n_fds);
1692
1693 if (s->socket_fd >= 0)
1694 return 0;
1695
1696 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1697 int *cfds;
1698 unsigned cn_fds;
1699 Socket *sock;
1700
1701 if (u->type != UNIT_SOCKET)
1702 continue;
1703
1704 sock = SOCKET(u);
1705
1706 r = socket_collect_fds(sock, &cfds, &cn_fds);
1707 if (r < 0)
1708 goto fail;
1709
1710 if (!cfds)
1711 continue;
1712
1713 if (!rfds) {
1714 rfds = cfds;
1715 rn_fds = cn_fds;
1716 } else {
1717 int *t;
1718
1719 t = new(int, rn_fds+cn_fds);
1720 if (!t) {
1721 free(cfds);
1722 r = -ENOMEM;
1723 goto fail;
1724 }
1725
1726 memcpy(t, rfds, rn_fds * sizeof(int));
1727 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1728 free(rfds);
1729 free(cfds);
1730
1731 rfds = t;
1732 rn_fds = rn_fds+cn_fds;
1733 }
1734 }
1735
1736 *fds = rfds;
1737 *n_fds = rn_fds;
1738
1739 return 0;
1740
1741fail:
1742 free(rfds);
1743
1744 return r;
1745}
1746
1747static int service_spawn(
1748 Service *s,
1749 ExecCommand *c,
1750 bool timeout,
1751 bool pass_fds,
1752 bool apply_permissions,
1753 bool apply_chroot,
1754 bool apply_tty_stdin,
1755 bool set_notify_socket,
1756 bool is_control,
1757 pid_t *_pid) {
1758
1759 pid_t pid;
1760 int r;
1761 int *fds = NULL;
1762 _cleanup_free_ int *fdsbuf = NULL;
1763 unsigned n_fds = 0, n_env = 0;
1764 _cleanup_strv_free_ char
1765 **argv = NULL, **final_env = NULL, **our_env = NULL;
1766 const char *path;
1767
1768 assert(s);
1769 assert(c);
1770 assert(_pid);
1771
1772 unit_realize_cgroup(UNIT(s));
1773
1774 if (pass_fds ||
1775 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1776 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1777 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1778
1779 if (s->socket_fd >= 0) {
1780 fds = &s->socket_fd;
1781 n_fds = 1;
1782 } else {
1783 r = service_collect_fds(s, &fdsbuf, &n_fds);
1784 if (r < 0)
1785 goto fail;
1786
1787 fds = fdsbuf;
1788 }
1789 }
1790
1791 if (timeout && s->timeout_start_usec) {
1792 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1793 s->timeout_start_usec, &s->timer_watch);
1794 if (r < 0)
1795 goto fail;
1796 } else
1797 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1798
1799 argv = unit_full_printf_strv(UNIT(s), c->argv);
1800 if (!argv) {
1801 r = -ENOMEM;
1802 goto fail;
1803 }
1804
1805 our_env = new0(char*, 5);
1806 if (!our_env) {
1807 r = -ENOMEM;
1808 goto fail;
1809 }
1810
1811 if (set_notify_socket)
1812 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1813 r = -ENOMEM;
1814 goto fail;
1815 }
1816
1817 if (s->main_pid > 0)
1818 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1819 r = -ENOMEM;
1820 goto fail;
1821 }
1822
1823 if (s->watchdog_usec > 0)
1824 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1825 r = -ENOMEM;
1826 goto fail;
1827 }
1828
1829 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1830 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1831 r = -ENOMEM;
1832 goto fail;
1833 }
1834
1835 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1836 if (!final_env) {
1837 r = -ENOMEM;
1838 goto fail;
1839 }
1840
1841 if (is_control && UNIT(s)->cgroup_path) {
1842 path = strappenda(UNIT(s)->cgroup_path, "/control");
1843 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1844 } else
1845 path = UNIT(s)->cgroup_path;
1846
1847 r = exec_spawn(c,
1848 argv,
1849 &s->exec_context,
1850 fds, n_fds,
1851 final_env,
1852 apply_permissions,
1853 apply_chroot,
1854 apply_tty_stdin,
1855 UNIT(s)->manager->confirm_spawn,
1856 UNIT(s)->cgroup_mask,
1857 path,
1858 UNIT(s)->id,
1859 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1860 &pid);
1861 if (r < 0)
1862 goto fail;
1863
1864 r = unit_watch_pid(UNIT(s), pid);
1865 if (r < 0)
1866 /* FIXME: we need to do something here */
1867 goto fail;
1868
1869 *_pid = pid;
1870
1871 return 0;
1872
1873fail:
1874 if (timeout)
1875 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1876
1877 return r;
1878}
1879
1880static int main_pid_good(Service *s) {
1881 assert(s);
1882
1883 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1884 * don't know */
1885
1886 /* If we know the pid file, then lets just check if it is
1887 * still valid */
1888 if (s->main_pid_known) {
1889
1890 /* If it's an alien child let's check if it is still
1891 * alive ... */
1892 if (s->main_pid_alien && s->main_pid > 0)
1893 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1894
1895 /* .. otherwise assume we'll get a SIGCHLD for it,
1896 * which we really should wait for to collect exit
1897 * status and code */
1898 return s->main_pid > 0;
1899 }
1900
1901 /* We don't know the pid */
1902 return -EAGAIN;
1903}
1904
1905_pure_ static int control_pid_good(Service *s) {
1906 assert(s);
1907
1908 return s->control_pid > 0;
1909}
1910
1911static int cgroup_good(Service *s) {
1912 int r;
1913
1914 assert(s);
1915
1916 if (!UNIT(s)->cgroup_path)
1917 return 0;
1918
1919 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1920 if (r < 0)
1921 return r;
1922
1923 return !r;
1924}
1925
1926static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1927 int r;
1928 assert(s);
1929
1930 if (f != SERVICE_SUCCESS)
1931 s->result = f;
1932
1933 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1934
1935 if (allow_restart &&
1936 !s->forbid_restart &&
1937 (s->restart == SERVICE_RESTART_ALWAYS ||
1938 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1939 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1940 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1941 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1942 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1943 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1944 (s->result != SERVICE_FAILURE_SIGNAL ||
1945 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1946 ) {
1947
1948 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
1949 if (r < 0)
1950 goto fail;
1951
1952 service_set_state(s, SERVICE_AUTO_RESTART);
1953 }
1954
1955 s->forbid_restart = false;
1956
1957 /* we want fresh tmpdirs in case service is started again immediately */
1958 exec_context_tmp_dirs_done(&s->exec_context);
1959
1960 return;
1961
1962fail:
1963 log_warning_unit(UNIT(s)->id,
1964 "%s failed to run install restart timer: %s",
1965 UNIT(s)->id, strerror(-r));
1966 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1967}
1968
1969static void service_enter_stop_post(Service *s, ServiceResult f) {
1970 int r;
1971 assert(s);
1972
1973 if (f != SERVICE_SUCCESS)
1974 s->result = f;
1975
1976 service_unwatch_control_pid(s);
1977
1978 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1979 if (s->control_command) {
1980 s->control_command_id = SERVICE_EXEC_STOP_POST;
1981
1982 r = service_spawn(s,
1983 s->control_command,
1984 true,
1985 false,
1986 !s->permissions_start_only,
1987 !s->root_directory_start_only,
1988 true,
1989 false,
1990 true,
1991 &s->control_pid);
1992 if (r < 0)
1993 goto fail;
1994
1995
1996 service_set_state(s, SERVICE_STOP_POST);
1997 } else
1998 service_enter_dead(s, SERVICE_SUCCESS, true);
1999
2000 return;
2001
2002fail:
2003 log_warning_unit(UNIT(s)->id,
2004 "%s failed to run 'stop-post' task: %s",
2005 UNIT(s)->id, strerror(-r));
2006 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2007}
2008
2009static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
2010 int r;
2011
2012 assert(s);
2013
2014 if (f != SERVICE_SUCCESS)
2015 s->result = f;
2016
2017 r = unit_kill_context(
2018 UNIT(s),
2019 &s->kill_context,
2020 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
2021 s->main_pid,
2022 s->control_pid,
2023 s->main_pid_alien);
2024 if (r < 0)
2025 goto fail;
2026
2027 if (r > 0) {
2028 if (s->timeout_stop_usec > 0) {
2029 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2030 s->timeout_stop_usec, &s->timer_watch);
2031 if (r < 0)
2032 goto fail;
2033 }
2034
2035 service_set_state(s, state);
2036 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2037 service_enter_stop_post(s, SERVICE_SUCCESS);
2038 else
2039 service_enter_dead(s, SERVICE_SUCCESS, true);
2040
2041 return;
2042
2043fail:
2044 log_warning_unit(UNIT(s)->id,
2045 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2046
2047 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2048 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2049 else
2050 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2051}
2052
2053static void service_enter_stop(Service *s, ServiceResult f) {
2054 int r;
2055
2056 assert(s);
2057
2058 if (f != SERVICE_SUCCESS)
2059 s->result = f;
2060
2061 service_unwatch_control_pid(s);
2062
2063 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2064 if (s->control_command) {
2065 s->control_command_id = SERVICE_EXEC_STOP;
2066
2067 r = service_spawn(s,
2068 s->control_command,
2069 true,
2070 false,
2071 !s->permissions_start_only,
2072 !s->root_directory_start_only,
2073 false,
2074 false,
2075 true,
2076 &s->control_pid);
2077 if (r < 0)
2078 goto fail;
2079
2080 service_set_state(s, SERVICE_STOP);
2081 } else
2082 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2083
2084 return;
2085
2086fail:
2087 log_warning_unit(UNIT(s)->id,
2088 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2089 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2090}
2091
2092static void service_enter_running(Service *s, ServiceResult f) {
2093 int main_pid_ok, cgroup_ok;
2094 assert(s);
2095
2096 if (f != SERVICE_SUCCESS)
2097 s->result = f;
2098
2099 main_pid_ok = main_pid_good(s);
2100 cgroup_ok = cgroup_good(s);
2101
2102 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2103 (s->bus_name_good || s->type != SERVICE_DBUS))
2104 service_set_state(s, SERVICE_RUNNING);
2105 else if (s->remain_after_exit)
2106 service_set_state(s, SERVICE_EXITED);
2107 else
2108 service_enter_stop(s, SERVICE_SUCCESS);
2109}
2110
2111static void service_enter_start_post(Service *s) {
2112 int r;
2113 assert(s);
2114
2115 service_unwatch_control_pid(s);
2116
2117 if (s->watchdog_usec > 0)
2118 service_reset_watchdog(s);
2119
2120 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2121 if (s->control_command) {
2122 s->control_command_id = SERVICE_EXEC_START_POST;
2123
2124 r = service_spawn(s,
2125 s->control_command,
2126 true,
2127 false,
2128 !s->permissions_start_only,
2129 !s->root_directory_start_only,
2130 false,
2131 false,
2132 true,
2133 &s->control_pid);
2134 if (r < 0)
2135 goto fail;
2136
2137 service_set_state(s, SERVICE_START_POST);
2138 } else
2139 service_enter_running(s, SERVICE_SUCCESS);
2140
2141 return;
2142
2143fail:
2144 log_warning_unit(UNIT(s)->id,
2145 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2146 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2147}
2148
2149static void service_kill_control_processes(Service *s) {
2150 char *p;
2151
2152 if (!UNIT(s)->cgroup_path)
2153 return;
2154
2155 p = strappenda(UNIT(s)->cgroup_path, "/control");
2156 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2157}
2158
2159static void service_enter_start(Service *s) {
2160 ExecCommand *c;
2161 pid_t pid;
2162 int r;
2163
2164 assert(s);
2165
2166 assert(s->exec_command[SERVICE_EXEC_START]);
2167 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2168
2169 service_unwatch_control_pid(s);
2170 service_unwatch_main_pid(s);
2171
2172 /* We want to ensure that nobody leaks processes from
2173 * START_PRE here, so let's go on a killing spree, People
2174 * should not spawn long running processes from START_PRE. */
2175 service_kill_control_processes(s);
2176
2177 if (s->type == SERVICE_FORKING) {
2178 s->control_command_id = SERVICE_EXEC_START;
2179 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2180
2181 s->main_command = NULL;
2182 } else {
2183 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2184 s->control_command = NULL;
2185
2186 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2187 }
2188
2189 r = service_spawn(s,
2190 c,
2191 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2192 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2193 true,
2194 true,
2195 true,
2196 true,
2197 s->notify_access != NOTIFY_NONE,
2198 false,
2199 &pid);
2200 if (r < 0)
2201 goto fail;
2202
2203 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2204 /* For simple services we immediately start
2205 * the START_POST binaries. */
2206
2207 service_set_main_pid(s, pid);
2208 service_enter_start_post(s);
2209
2210 } else if (s->type == SERVICE_FORKING) {
2211
2212 /* For forking services we wait until the start
2213 * process exited. */
2214
2215 s->control_pid = pid;
2216 service_set_state(s, SERVICE_START);
2217
2218 } else if (s->type == SERVICE_ONESHOT ||
2219 s->type == SERVICE_DBUS ||
2220 s->type == SERVICE_NOTIFY) {
2221
2222 /* For oneshot services we wait until the start
2223 * process exited, too, but it is our main process. */
2224
2225 /* For D-Bus services we know the main pid right away,
2226 * but wait for the bus name to appear on the
2227 * bus. Notify services are similar. */
2228
2229 service_set_main_pid(s, pid);
2230 service_set_state(s, SERVICE_START);
2231 } else
2232 assert_not_reached("Unknown service type");
2233
2234 return;
2235
2236fail:
2237 log_warning_unit(UNIT(s)->id,
2238 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2239 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2240}
2241
2242static void service_enter_start_pre(Service *s) {
2243 int r;
2244
2245 assert(s);
2246
2247 service_unwatch_control_pid(s);
2248
2249 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2250 if (s->control_command) {
2251 /* Before we start anything, let's clear up what might
2252 * be left from previous runs. */
2253 service_kill_control_processes(s);
2254
2255 s->control_command_id = SERVICE_EXEC_START_PRE;
2256
2257 r = service_spawn(s,
2258 s->control_command,
2259 true,
2260 false,
2261 !s->permissions_start_only,
2262 !s->root_directory_start_only,
2263 true,
2264 false,
2265 true,
2266 &s->control_pid);
2267 if (r < 0)
2268 goto fail;
2269
2270 service_set_state(s, SERVICE_START_PRE);
2271 } else
2272 service_enter_start(s);
2273
2274 return;
2275
2276fail:
2277 log_warning_unit(UNIT(s)->id,
2278 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2279 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2280}
2281
2282static void service_enter_restart(Service *s) {
2283 int r;
2284 DBusError error;
2285
2286 assert(s);
2287 dbus_error_init(&error);
2288
2289 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2290 /* Don't restart things if we are going down anyway */
2291 log_info_unit(UNIT(s)->id,
2292 "Stop job pending for unit, delaying automatic restart.");
2293
2294 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
2295 if (r < 0)
2296 goto fail;
2297
2298 return;
2299 }
2300
2301 /* Any units that are bound to this service must also be
2302 * restarted. We use JOB_RESTART (instead of the more obvious
2303 * JOB_START) here so that those dependency jobs will be added
2304 * as well. */
2305 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2306 if (r < 0)
2307 goto fail;
2308
2309 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2310 * it will be canceled as part of the service_stop() call that
2311 * is executed as part of JOB_RESTART. */
2312
2313 log_debug_unit(UNIT(s)->id,
2314 "%s scheduled restart job.", UNIT(s)->id);
2315 return;
2316
2317fail:
2318 log_warning_unit(UNIT(s)->id,
2319 "%s failed to schedule restart job: %s",
2320 UNIT(s)->id, bus_error(&error, -r));
2321 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2322
2323 dbus_error_free(&error);
2324}
2325
2326static void service_enter_reload(Service *s) {
2327 int r;
2328
2329 assert(s);
2330
2331 service_unwatch_control_pid(s);
2332
2333 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2334 if (s->control_command) {
2335 s->control_command_id = SERVICE_EXEC_RELOAD;
2336
2337 r = service_spawn(s,
2338 s->control_command,
2339 true,
2340 false,
2341 !s->permissions_start_only,
2342 !s->root_directory_start_only,
2343 false,
2344 false,
2345 true,
2346 &s->control_pid);
2347 if (r < 0)
2348 goto fail;
2349
2350 service_set_state(s, SERVICE_RELOAD);
2351 } else
2352 service_enter_running(s, SERVICE_SUCCESS);
2353
2354 return;
2355
2356fail:
2357 log_warning_unit(UNIT(s)->id,
2358 "%s failed to run 'reload' task: %s",
2359 UNIT(s)->id, strerror(-r));
2360 s->reload_result = SERVICE_FAILURE_RESOURCES;
2361 service_enter_running(s, SERVICE_SUCCESS);
2362}
2363
2364static void service_run_next_control(Service *s) {
2365 int r;
2366
2367 assert(s);
2368 assert(s->control_command);
2369 assert(s->control_command->command_next);
2370
2371 assert(s->control_command_id != SERVICE_EXEC_START);
2372
2373 s->control_command = s->control_command->command_next;
2374 service_unwatch_control_pid(s);
2375
2376 r = service_spawn(s,
2377 s->control_command,
2378 true,
2379 false,
2380 !s->permissions_start_only,
2381 !s->root_directory_start_only,
2382 s->control_command_id == SERVICE_EXEC_START_PRE ||
2383 s->control_command_id == SERVICE_EXEC_STOP_POST,
2384 false,
2385 true,
2386 &s->control_pid);
2387 if (r < 0)
2388 goto fail;
2389
2390 return;
2391
2392fail:
2393 log_warning_unit(UNIT(s)->id,
2394 "%s failed to run next control task: %s",
2395 UNIT(s)->id, strerror(-r));
2396
2397 if (s->state == SERVICE_START_PRE)
2398 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2399 else if (s->state == SERVICE_STOP)
2400 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2401 else if (s->state == SERVICE_STOP_POST)
2402 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2403 else if (s->state == SERVICE_RELOAD) {
2404 s->reload_result = SERVICE_FAILURE_RESOURCES;
2405 service_enter_running(s, SERVICE_SUCCESS);
2406 } else
2407 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2408}
2409
2410static void service_run_next_main(Service *s) {
2411 pid_t pid;
2412 int r;
2413
2414 assert(s);
2415 assert(s->main_command);
2416 assert(s->main_command->command_next);
2417 assert(s->type == SERVICE_ONESHOT);
2418
2419 s->main_command = s->main_command->command_next;
2420 service_unwatch_main_pid(s);
2421
2422 r = service_spawn(s,
2423 s->main_command,
2424 true,
2425 true,
2426 true,
2427 true,
2428 true,
2429 s->notify_access != NOTIFY_NONE,
2430 false,
2431 &pid);
2432 if (r < 0)
2433 goto fail;
2434
2435 service_set_main_pid(s, pid);
2436
2437 return;
2438
2439fail:
2440 log_warning_unit(UNIT(s)->id,
2441 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2442 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2443}
2444
2445static int service_start_limit_test(Service *s) {
2446 assert(s);
2447
2448 if (ratelimit_test(&s->start_limit))
2449 return 0;
2450
2451 switch (s->start_limit_action) {
2452
2453 case SERVICE_START_LIMIT_NONE:
2454 log_warning_unit(UNIT(s)->id,
2455 "%s start request repeated too quickly, refusing to start.",
2456 UNIT(s)->id);
2457 break;
2458
2459 case SERVICE_START_LIMIT_REBOOT: {
2460 DBusError error;
2461 int r;
2462
2463 dbus_error_init(&error);
2464
2465 log_warning_unit(UNIT(s)->id,
2466 "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2467
2468 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2469 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2470 true, &error, NULL);
2471 if (r < 0) {
2472 log_error_unit(UNIT(s)->id,
2473 "Failed to reboot: %s.", bus_error(&error, r));
2474 dbus_error_free(&error);
2475 }
2476
2477 break;
2478 }
2479
2480 case SERVICE_START_LIMIT_REBOOT_FORCE:
2481 log_warning_unit(UNIT(s)->id,
2482 "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2483 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2484 break;
2485
2486 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2487 log_warning_unit(UNIT(s)->id,
2488 "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2489 sync();
2490 reboot(RB_AUTOBOOT);
2491 break;
2492
2493 default:
2494 log_error_unit(UNIT(s)->id,
2495 "start limit action=%i", s->start_limit_action);
2496 assert_not_reached("Unknown StartLimitAction.");
2497 }
2498
2499 return -ECANCELED;
2500}
2501
2502static int service_start(Unit *u) {
2503 Service *s = SERVICE(u);
2504 int r;
2505
2506 assert(s);
2507
2508 /* We cannot fulfill this request right now, try again later
2509 * please! */
2510 if (s->state == SERVICE_STOP ||
2511 s->state == SERVICE_STOP_SIGTERM ||
2512 s->state == SERVICE_STOP_SIGKILL ||
2513 s->state == SERVICE_STOP_POST ||
2514 s->state == SERVICE_FINAL_SIGTERM ||
2515 s->state == SERVICE_FINAL_SIGKILL)
2516 return -EAGAIN;
2517
2518 /* Already on it! */
2519 if (s->state == SERVICE_START_PRE ||
2520 s->state == SERVICE_START ||
2521 s->state == SERVICE_START_POST)
2522 return 0;
2523
2524 /* A service that will be restarted must be stopped first to
2525 * trigger BindsTo and/or OnFailure dependencies. If a user
2526 * does not want to wait for the holdoff time to elapse, the
2527 * service should be manually restarted, not started. We
2528 * simply return EAGAIN here, so that any start jobs stay
2529 * queued, and assume that the auto restart timer will
2530 * eventually trigger the restart. */
2531 if (s->state == SERVICE_AUTO_RESTART)
2532 return -EAGAIN;
2533
2534 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2535
2536 /* Make sure we don't enter a busy loop of some kind. */
2537 r = service_start_limit_test(s);
2538 if (r < 0) {
2539 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2540 return r;
2541 }
2542
2543 s->result = SERVICE_SUCCESS;
2544 s->reload_result = SERVICE_SUCCESS;
2545 s->main_pid_known = false;
2546 s->main_pid_alien = false;
2547 s->forbid_restart = false;
2548
2549 service_enter_start_pre(s);
2550 return 0;
2551}
2552
2553static int service_stop(Unit *u) {
2554 Service *s = SERVICE(u);
2555
2556 assert(s);
2557
2558 /* Don't create restart jobs from here. */
2559 s->forbid_restart = true;
2560
2561 /* Already on it */
2562 if (s->state == SERVICE_STOP ||
2563 s->state == SERVICE_STOP_SIGTERM ||
2564 s->state == SERVICE_STOP_SIGKILL ||
2565 s->state == SERVICE_STOP_POST ||
2566 s->state == SERVICE_FINAL_SIGTERM ||
2567 s->state == SERVICE_FINAL_SIGKILL)
2568 return 0;
2569
2570 /* A restart will be scheduled or is in progress. */
2571 if (s->state == SERVICE_AUTO_RESTART) {
2572 service_set_state(s, SERVICE_DEAD);
2573 return 0;
2574 }
2575
2576 /* If there's already something running we go directly into
2577 * kill mode. */
2578 if (s->state == SERVICE_START_PRE ||
2579 s->state == SERVICE_START ||
2580 s->state == SERVICE_START_POST ||
2581 s->state == SERVICE_RELOAD) {
2582 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2583 return 0;
2584 }
2585
2586 assert(s->state == SERVICE_RUNNING ||
2587 s->state == SERVICE_EXITED);
2588
2589 service_enter_stop(s, SERVICE_SUCCESS);
2590 return 0;
2591}
2592
2593static int service_reload(Unit *u) {
2594 Service *s = SERVICE(u);
2595
2596 assert(s);
2597
2598 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2599
2600 service_enter_reload(s);
2601 return 0;
2602}
2603
2604_pure_ static bool service_can_reload(Unit *u) {
2605 Service *s = SERVICE(u);
2606
2607 assert(s);
2608
2609 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2610}
2611
2612static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2613 Service *s = SERVICE(u);
2614
2615 assert(u);
2616 assert(f);
2617 assert(fds);
2618
2619 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2620 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2621 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2622
2623 if (s->control_pid > 0)
2624 unit_serialize_item_format(u, f, "control-pid", "%lu",
2625 (unsigned long) s->control_pid);
2626
2627 if (s->main_pid_known && s->main_pid > 0)
2628 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2629
2630 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2631
2632 if (s->status_text)
2633 unit_serialize_item(u, f, "status-text", s->status_text);
2634
2635 /* FIXME: There's a minor uncleanliness here: if there are
2636 * multiple commands attached here, we will start from the
2637 * first one again */
2638 if (s->control_command_id >= 0)
2639 unit_serialize_item(u, f, "control-command",
2640 service_exec_command_to_string(s->control_command_id));
2641
2642 if (s->socket_fd >= 0) {
2643 int copy;
2644
2645 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2646 return copy;
2647
2648 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2649 }
2650
2651 if (s->main_exec_status.pid > 0) {
2652 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2653 (unsigned long) s->main_exec_status.pid);
2654 dual_timestamp_serialize(f, "main-exec-status-start",
2655 &s->main_exec_status.start_timestamp);
2656 dual_timestamp_serialize(f, "main-exec-status-exit",
2657 &s->main_exec_status.exit_timestamp);
2658
2659 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2660 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2661 s->main_exec_status.code);
2662 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2663 s->main_exec_status.status);
2664 }
2665 }
2666 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2667 dual_timestamp_serialize(f, "watchdog-timestamp",
2668 &s->watchdog_timestamp);
2669
2670 if (s->exec_context.tmp_dir)
2671 unit_serialize_item(u, f, "tmp-dir", s->exec_context.tmp_dir);
2672
2673 if (s->exec_context.var_tmp_dir)
2674 unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2675
2676 return 0;
2677}
2678
2679static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2680 Service *s = SERVICE(u);
2681
2682 assert(u);
2683 assert(key);
2684 assert(value);
2685 assert(fds);
2686
2687 if (streq(key, "state")) {
2688 ServiceState state;
2689
2690 state = service_state_from_string(value);
2691 if (state < 0)
2692 log_debug_unit(u->id, "Failed to parse state value %s", value);
2693 else
2694 s->deserialized_state = state;
2695 } else if (streq(key, "result")) {
2696 ServiceResult f;
2697
2698 f = service_result_from_string(value);
2699 if (f < 0)
2700 log_debug_unit(u->id, "Failed to parse result value %s", value);
2701 else if (f != SERVICE_SUCCESS)
2702 s->result = f;
2703
2704 } else if (streq(key, "reload-result")) {
2705 ServiceResult f;
2706
2707 f = service_result_from_string(value);
2708 if (f < 0)
2709 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2710 else if (f != SERVICE_SUCCESS)
2711 s->reload_result = f;
2712
2713 } else if (streq(key, "control-pid")) {
2714 pid_t pid;
2715
2716 if (parse_pid(value, &pid) < 0)
2717 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2718 else
2719 s->control_pid = pid;
2720 } else if (streq(key, "main-pid")) {
2721 pid_t pid;
2722
2723 if (parse_pid(value, &pid) < 0)
2724 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2725 else
2726 service_set_main_pid(s, (pid_t) pid);
2727 } else if (streq(key, "main-pid-known")) {
2728 int b;
2729
2730 b = parse_boolean(value);
2731 if (b < 0)
2732 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2733 else
2734 s->main_pid_known = b;
2735 } else if (streq(key, "status-text")) {
2736 char *t;
2737
2738 t = strdup(value);
2739 if (!t)
2740 log_oom();
2741 else {
2742 free(s->status_text);
2743 s->status_text = t;
2744 }
2745
2746 } else if (streq(key, "control-command")) {
2747 ServiceExecCommand id;
2748
2749 id = service_exec_command_from_string(value);
2750 if (id < 0)
2751 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2752 else {
2753 s->control_command_id = id;
2754 s->control_command = s->exec_command[id];
2755 }
2756 } else if (streq(key, "socket-fd")) {
2757 int fd;
2758
2759 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2760 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2761 else {
2762
2763 if (s->socket_fd >= 0)
2764 close_nointr_nofail(s->socket_fd);
2765 s->socket_fd = fdset_remove(fds, fd);
2766 }
2767 } else if (streq(key, "main-exec-status-pid")) {
2768 pid_t pid;
2769
2770 if (parse_pid(value, &pid) < 0)
2771 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2772 else
2773 s->main_exec_status.pid = pid;
2774 } else if (streq(key, "main-exec-status-code")) {
2775 int i;
2776
2777 if (safe_atoi(value, &i) < 0)
2778 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2779 else
2780 s->main_exec_status.code = i;
2781 } else if (streq(key, "main-exec-status-status")) {
2782 int i;
2783
2784 if (safe_atoi(value, &i) < 0)
2785 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2786 else
2787 s->main_exec_status.status = i;
2788 } else if (streq(key, "main-exec-status-start"))
2789 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2790 else if (streq(key, "main-exec-status-exit"))
2791 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2792 else if (streq(key, "watchdog-timestamp"))
2793 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2794 else if (streq(key, "tmp-dir")) {
2795 char *t;
2796
2797 t = strdup(value);
2798 if (!t)
2799 return log_oom();
2800
2801 s->exec_context.tmp_dir = t;
2802 } else if (streq(key, "var-tmp-dir")) {
2803 char *t;
2804
2805 t = strdup(value);
2806 if (!t)
2807 return log_oom();
2808
2809 s->exec_context.var_tmp_dir = t;
2810 } else
2811 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2812
2813 return 0;
2814}
2815
2816_pure_ static UnitActiveState service_active_state(Unit *u) {
2817 const UnitActiveState *table;
2818
2819 assert(u);
2820
2821 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2822
2823 return table[SERVICE(u)->state];
2824}
2825
2826static const char *service_sub_state_to_string(Unit *u) {
2827 assert(u);
2828
2829 return service_state_to_string(SERVICE(u)->state);
2830}
2831
2832static bool service_check_gc(Unit *u) {
2833 Service *s = SERVICE(u);
2834
2835 assert(s);
2836
2837 /* Never clean up services that still have a process around,
2838 * even if the service is formally dead. */
2839 if (cgroup_good(s) > 0 ||
2840 main_pid_good(s) > 0 ||
2841 control_pid_good(s) > 0)
2842 return true;
2843
2844#ifdef HAVE_SYSV_COMPAT
2845 if (s->is_sysv)
2846 return true;
2847#endif
2848
2849 return false;
2850}
2851
2852_pure_ static bool service_check_snapshot(Unit *u) {
2853 Service *s = SERVICE(u);
2854
2855 assert(s);
2856
2857 return !s->got_socket_fd;
2858}
2859
2860static int service_retry_pid_file(Service *s) {
2861 int r;
2862
2863 assert(s->pid_file);
2864 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2865
2866 r = service_load_pid_file(s, false);
2867 if (r < 0)
2868 return r;
2869
2870 service_unwatch_pid_file(s);
2871
2872 service_enter_running(s, SERVICE_SUCCESS);
2873 return 0;
2874}
2875
2876static int service_watch_pid_file(Service *s) {
2877 int r;
2878
2879 log_debug_unit(UNIT(s)->id,
2880 "Setting watch for %s's PID file %s",
2881 UNIT(s)->id, s->pid_file_pathspec->path);
2882 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2883 if (r < 0)
2884 goto fail;
2885
2886 /* the pidfile might have appeared just before we set the watch */
2887 log_debug_unit(UNIT(s)->id,
2888 "Trying to read %s's PID file %s in case it changed",
2889 UNIT(s)->id, s->pid_file_pathspec->path);
2890 service_retry_pid_file(s);
2891
2892 return 0;
2893fail:
2894 log_error_unit(UNIT(s)->id,
2895 "Failed to set a watch for %s's PID file %s: %s",
2896 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2897 service_unwatch_pid_file(s);
2898 return r;
2899}
2900
2901static int service_demand_pid_file(Service *s) {
2902 PathSpec *ps;
2903
2904 assert(s->pid_file);
2905 assert(!s->pid_file_pathspec);
2906
2907 ps = new0(PathSpec, 1);
2908 if (!ps)
2909 return -ENOMEM;
2910
2911 ps->path = strdup(s->pid_file);
2912 if (!ps->path) {
2913 free(ps);
2914 return -ENOMEM;
2915 }
2916
2917 path_kill_slashes(ps->path);
2918
2919 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2920 * keep their PID file open all the time. */
2921 ps->type = PATH_MODIFIED;
2922 ps->inotify_fd = -1;
2923
2924 s->pid_file_pathspec = ps;
2925
2926 return service_watch_pid_file(s);
2927}
2928
2929static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2930 Service *s = SERVICE(u);
2931
2932 assert(s);
2933 assert(fd >= 0);
2934 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2935 assert(s->pid_file_pathspec);
2936 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2937
2938 log_debug_unit(u->id, "inotify event for %s", u->id);
2939
2940 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2941 goto fail;
2942
2943 if (service_retry_pid_file(s) == 0)
2944 return;
2945
2946 if (service_watch_pid_file(s) < 0)
2947 goto fail;
2948
2949 return;
2950fail:
2951 service_unwatch_pid_file(s);
2952 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2953}
2954
2955static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2956 Service *s = SERVICE(u);
2957 ServiceResult f;
2958
2959 assert(s);
2960 assert(pid >= 0);
2961
2962 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2963 is_clean_exit_lsb(code, status, &s->success_status))
2964 f = SERVICE_SUCCESS;
2965 else if (code == CLD_EXITED)
2966 f = SERVICE_FAILURE_EXIT_CODE;
2967 else if (code == CLD_KILLED)
2968 f = SERVICE_FAILURE_SIGNAL;
2969 else if (code == CLD_DUMPED)
2970 f = SERVICE_FAILURE_CORE_DUMP;
2971 else
2972 assert_not_reached("Unknown code");
2973
2974 if (s->main_pid == pid) {
2975 /* Forking services may occasionally move to a new PID.
2976 * As long as they update the PID file before exiting the old
2977 * PID, they're fine. */
2978 if (service_load_pid_file(s, false) == 0)
2979 return;
2980
2981 s->main_pid = 0;
2982 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2983
2984 if (s->main_command) {
2985 /* If this is not a forking service than the
2986 * main process got started and hence we copy
2987 * the exit status so that it is recorded both
2988 * as main and as control process exit
2989 * status */
2990
2991 s->main_command->exec_status = s->main_exec_status;
2992
2993 if (s->main_command->ignore)
2994 f = SERVICE_SUCCESS;
2995 } else if (s->exec_command[SERVICE_EXEC_START]) {
2996
2997 /* If this is a forked process, then we should
2998 * ignore the return value if this was
2999 * configured for the starter process */
3000
3001 if (s->exec_command[SERVICE_EXEC_START]->ignore)
3002 f = SERVICE_SUCCESS;
3003 }
3004
3005 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
3006 u->id,
3007 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
3008 u->id, sigchld_code_to_string(code), status,
3009 strna(code == CLD_EXITED
3010 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3011 : signal_to_string(status)),
3012 "EXIT_CODE=%s", sigchld_code_to_string(code),
3013 "EXIT_STATUS=%i", status,
3014 NULL);
3015
3016 if (f != SERVICE_SUCCESS)
3017 s->result = f;
3018
3019 if (s->main_command &&
3020 s->main_command->command_next &&
3021 f == SERVICE_SUCCESS) {
3022
3023 /* There is another command to *
3024 * execute, so let's do that. */
3025
3026 log_debug_unit(u->id,
3027 "%s running next main command for state %s",
3028 u->id, service_state_to_string(s->state));
3029 service_run_next_main(s);
3030
3031 } else {
3032
3033 /* The service exited, so the service is officially
3034 * gone. */
3035 s->main_command = NULL;
3036
3037 switch (s->state) {
3038
3039 case SERVICE_START_POST:
3040 case SERVICE_RELOAD:
3041 case SERVICE_STOP:
3042 /* Need to wait until the operation is
3043 * done */
3044 break;
3045
3046 case SERVICE_START:
3047 if (s->type == SERVICE_ONESHOT) {
3048 /* This was our main goal, so let's go on */
3049 if (f == SERVICE_SUCCESS)
3050 service_enter_start_post(s);
3051 else
3052 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3053 break;
3054 }
3055
3056 /* Fall through */
3057
3058 case SERVICE_RUNNING:
3059 service_enter_running(s, f);
3060 break;
3061
3062 case SERVICE_STOP_SIGTERM:
3063 case SERVICE_STOP_SIGKILL:
3064
3065 if (!control_pid_good(s))
3066 service_enter_stop_post(s, f);
3067
3068 /* If there is still a control process, wait for that first */
3069 break;
3070
3071 default:
3072 assert_not_reached("Uh, main process died at wrong time.");
3073 }
3074 }
3075
3076 } else if (s->control_pid == pid) {
3077 s->control_pid = 0;
3078
3079 if (s->control_command) {
3080 exec_status_exit(&s->control_command->exec_status,
3081 &s->exec_context, pid, code, status);
3082
3083 if (s->control_command->ignore)
3084 f = SERVICE_SUCCESS;
3085 }
3086
3087 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3088 "%s: control process exited, code=%s status=%i",
3089 u->id, sigchld_code_to_string(code), status);
3090
3091 if (f != SERVICE_SUCCESS)
3092 s->result = f;
3093
3094 /* Immediately get rid of the cgroup, so that the
3095 * kernel doesn't delay the cgroup empty messages for
3096 * the service cgroup any longer than necessary */
3097 service_kill_control_processes(s);
3098
3099 if (s->control_command &&
3100 s->control_command->command_next &&
3101 f == SERVICE_SUCCESS) {
3102
3103 /* There is another command to *
3104 * execute, so let's do that. */
3105
3106 log_debug_unit(u->id,
3107 "%s running next control command for state %s",
3108 u->id, service_state_to_string(s->state));
3109 service_run_next_control(s);
3110
3111 } else {
3112 /* No further commands for this step, so let's
3113 * figure out what to do next */
3114
3115 s->control_command = NULL;
3116 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3117
3118 log_debug_unit(u->id,
3119 "%s got final SIGCHLD for state %s",
3120 u->id, service_state_to_string(s->state));
3121
3122 switch (s->state) {
3123
3124 case SERVICE_START_PRE:
3125 if (f == SERVICE_SUCCESS)
3126 service_enter_start(s);
3127 else
3128 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3129 break;
3130
3131 case SERVICE_START:
3132 if (s->type != SERVICE_FORKING)
3133 /* Maybe spurious event due to a reload that changed the type? */
3134 break;
3135
3136 if (f != SERVICE_SUCCESS) {
3137 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3138 break;
3139 }
3140
3141 if (s->pid_file) {
3142 bool has_start_post;
3143 int r;
3144
3145 /* Let's try to load the pid file here if we can.
3146 * The PID file might actually be created by a START_POST
3147 * script. In that case don't worry if the loading fails. */
3148
3149 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3150 r = service_load_pid_file(s, !has_start_post);
3151 if (!has_start_post && r < 0) {
3152 r = service_demand_pid_file(s);
3153 if (r < 0 || !cgroup_good(s))
3154 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3155 break;
3156 }
3157 } else
3158 service_search_main_pid(s);
3159
3160 service_enter_start_post(s);
3161 break;
3162
3163 case SERVICE_START_POST:
3164 if (f != SERVICE_SUCCESS) {
3165 service_enter_stop(s, f);
3166 break;
3167 }
3168
3169 if (s->pid_file) {
3170 int r;
3171
3172 r = service_load_pid_file(s, true);
3173 if (r < 0) {
3174 r = service_demand_pid_file(s);
3175 if (r < 0 || !cgroup_good(s))
3176 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3177 break;
3178 }
3179 } else
3180 service_search_main_pid(s);
3181
3182 service_enter_running(s, SERVICE_SUCCESS);
3183 break;
3184
3185 case SERVICE_RELOAD:
3186 if (f == SERVICE_SUCCESS) {
3187 service_load_pid_file(s, true);
3188 service_search_main_pid(s);
3189 }
3190
3191 s->reload_result = f;
3192 service_enter_running(s, SERVICE_SUCCESS);
3193 break;
3194
3195 case SERVICE_STOP:
3196 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3197 break;
3198
3199 case SERVICE_STOP_SIGTERM:
3200 case SERVICE_STOP_SIGKILL:
3201 if (main_pid_good(s) <= 0)
3202 service_enter_stop_post(s, f);
3203
3204 /* If there is still a service
3205 * process around, wait until
3206 * that one quit, too */
3207 break;
3208
3209 case SERVICE_STOP_POST:
3210 case SERVICE_FINAL_SIGTERM:
3211 case SERVICE_FINAL_SIGKILL:
3212 service_enter_dead(s, f, true);
3213 break;
3214
3215 default:
3216 assert_not_reached("Uh, control process died at wrong time.");
3217 }
3218 }
3219 }
3220
3221 /* Notify clients about changed exit status */
3222 unit_add_to_dbus_queue(u);
3223}
3224
3225static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3226 Service *s = SERVICE(u);
3227
3228 assert(s);
3229 assert(elapsed == 1);
3230
3231 if (w == &s->watchdog_watch) {
3232 service_handle_watchdog(s);
3233 return;
3234 }
3235
3236 assert(w == &s->timer_watch);
3237
3238 switch (s->state) {
3239
3240 case SERVICE_START_PRE:
3241 case SERVICE_START:
3242 log_warning_unit(u->id,
3243 "%s operation timed out. Terminating.", u->id);
3244 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3245 break;
3246
3247 case SERVICE_START_POST:
3248 log_warning_unit(u->id,
3249 "%s operation timed out. Stopping.", u->id);
3250 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3251 break;
3252
3253 case SERVICE_RELOAD:
3254 log_warning_unit(u->id,
3255 "%s operation timed out. Stopping.", u->id);
3256 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3257 service_enter_running(s, SERVICE_SUCCESS);
3258 break;
3259
3260 case SERVICE_STOP:
3261 log_warning_unit(u->id,
3262 "%s stopping timed out. Terminating.", u->id);
3263 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3264 break;
3265
3266 case SERVICE_STOP_SIGTERM:
3267 if (s->kill_context.send_sigkill) {
3268 log_warning_unit(u->id,
3269 "%s stopping timed out. Killing.", u->id);
3270 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3271 } else {
3272 log_warning_unit(u->id,
3273 "%s stopping timed out. Skipping SIGKILL.", u->id);
3274 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3275 }
3276
3277 break;
3278
3279 case SERVICE_STOP_SIGKILL:
3280 /* Uh, we sent a SIGKILL and it is still not gone?
3281 * Must be something we cannot kill, so let's just be
3282 * weirded out and continue */
3283
3284 log_warning_unit(u->id,
3285 "%s still around after SIGKILL. Ignoring.", u->id);
3286 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3287 break;
3288
3289 case SERVICE_STOP_POST:
3290 log_warning_unit(u->id,
3291 "%s stopping timed out (2). Terminating.", u->id);
3292 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3293 break;
3294
3295 case SERVICE_FINAL_SIGTERM:
3296 if (s->kill_context.send_sigkill) {
3297 log_warning_unit(u->id,
3298 "%s stopping timed out (2). Killing.", u->id);
3299 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3300 } else {
3301 log_warning_unit(u->id,
3302 "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3303 u->id);
3304 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3305 }
3306
3307 break;
3308
3309 case SERVICE_FINAL_SIGKILL:
3310 log_warning_unit(u->id,
3311 "%s still around after SIGKILL (2). Entering failed mode.", u->id);
3312 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3313 break;
3314
3315 case SERVICE_AUTO_RESTART:
3316 log_info_unit(u->id,
3317 "%s holdoff time over, scheduling restart.", u->id);
3318 service_enter_restart(s);
3319 break;
3320
3321 default:
3322 assert_not_reached("Timeout at wrong time.");
3323 }
3324}
3325
3326static void service_notify_cgroup_empty_event(Unit *u) {
3327 Service *s = SERVICE(u);
3328
3329 assert(u);
3330
3331 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
3332
3333 switch (s->state) {
3334
3335 /* Waiting for SIGCHLD is usually more interesting,
3336 * because it includes return codes/signals. Which is
3337 * why we ignore the cgroup events for most cases,
3338 * except when we don't know pid which to expect the
3339 * SIGCHLD for. */
3340
3341 case SERVICE_START:
3342 case SERVICE_START_POST:
3343 /* If we were hoping for the daemon to write its PID file,
3344 * we can give up now. */
3345 if (s->pid_file_pathspec) {
3346 log_warning_unit(u->id,
3347 "%s never wrote its PID file. Failing.", UNIT(s)->id);
3348 service_unwatch_pid_file(s);
3349 if (s->state == SERVICE_START)
3350 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3351 else
3352 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3353 }
3354 break;
3355
3356 case SERVICE_RUNNING:
3357 /* service_enter_running() will figure out what to do */
3358 service_enter_running(s, SERVICE_SUCCESS);
3359 break;
3360
3361 case SERVICE_STOP_SIGTERM:
3362 case SERVICE_STOP_SIGKILL:
3363
3364 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3365 service_enter_stop_post(s, SERVICE_SUCCESS);
3366
3367 break;
3368
3369 case SERVICE_FINAL_SIGTERM:
3370 case SERVICE_FINAL_SIGKILL:
3371 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3372 service_enter_dead(s, SERVICE_SUCCESS, true);
3373
3374 break;
3375
3376 default:
3377 ;
3378 }
3379}
3380
3381static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3382 Service *s = SERVICE(u);
3383 const char *e;
3384
3385 assert(u);
3386
3387 if (s->notify_access == NOTIFY_NONE) {
3388 log_warning_unit(u->id,
3389 "%s: Got notification message from PID %lu, but reception is disabled.",
3390 u->id, (unsigned long) pid);
3391 return;
3392 }
3393
3394 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3395 log_warning_unit(u->id,
3396 "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3397 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3398 return;
3399 }
3400
3401 log_debug_unit(u->id,
3402 "%s: Got message", u->id);
3403
3404 /* Interpret MAINPID= */
3405 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3406 (s->state == SERVICE_START ||
3407 s->state == SERVICE_START_POST ||
3408 s->state == SERVICE_RUNNING ||
3409 s->state == SERVICE_RELOAD)) {
3410
3411 if (parse_pid(e + 8, &pid) < 0)
3412 log_warning_unit(u->id,
3413 "Failed to parse notification message %s", e);
3414 else {
3415 log_debug_unit(u->id,
3416 "%s: got %s", u->id, e);
3417 service_set_main_pid(s, pid);
3418 }
3419 }
3420
3421 /* Interpret READY= */
3422 if (s->type == SERVICE_NOTIFY &&
3423 s->state == SERVICE_START &&
3424 strv_find(tags, "READY=1")) {
3425 log_debug_unit(u->id,
3426 "%s: got READY=1", u->id);
3427
3428 service_enter_start_post(s);
3429 }
3430
3431 /* Interpret STATUS= */
3432 e = strv_find_prefix(tags, "STATUS=");
3433 if (e) {
3434 char *t;
3435
3436 if (e[7]) {
3437
3438 if (!utf8_is_valid(e+7)) {
3439 log_warning_unit(u->id,
3440 "Status message in notification is not UTF-8 clean.");
3441 return;
3442 }
3443
3444 t = strdup(e+7);
3445 if (!t) {
3446 log_error_unit(u->id,
3447 "Failed to allocate string.");
3448 return;
3449 }
3450
3451 log_debug_unit(u->id,
3452 "%s: got %s", u->id, e);
3453
3454 free(s->status_text);
3455 s->status_text = t;
3456 } else {
3457 free(s->status_text);
3458 s->status_text = NULL;
3459 }
3460
3461 }
3462 if (strv_find(tags, "WATCHDOG=1")) {
3463 log_debug_unit(u->id,
3464 "%s: got WATCHDOG=1", u->id);
3465 if (dual_timestamp_is_set(&s->watchdog_timestamp))
3466 service_reset_watchdog(s);
3467 }
3468
3469 /* Notify clients about changed status or main pid */
3470 unit_add_to_dbus_queue(u);
3471}
3472
3473#ifdef HAVE_SYSV_COMPAT
3474
3475static int service_enumerate(Manager *m) {
3476 char **p;
3477 unsigned i;
3478 _cleanup_closedir_ DIR *d = NULL;
3479 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3480 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3481 _cleanup_set_free_ Set *shutdown_services = NULL;
3482 Unit *service;
3483 Iterator j;
3484 int r;
3485
3486 assert(m);
3487
3488 if (m->running_as != SYSTEMD_SYSTEM)
3489 return 0;
3490
3491 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3492 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3493 struct dirent *de;
3494
3495 free(path);
3496 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3497 if (!path) {
3498 r = -ENOMEM;
3499 goto finish;
3500 }
3501
3502 if (d)
3503 closedir(d);
3504
3505 d = opendir(path);
3506 if (!d) {
3507 if (errno != ENOENT)
3508 log_warning("opendir(%s) failed: %s", path, strerror(errno));
3509
3510 continue;
3511 }
3512
3513 while ((de = readdir(d))) {
3514 int a, b;
3515
3516 if (ignore_file(de->d_name))
3517 continue;
3518
3519 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3520 continue;
3521
3522 if (strlen(de->d_name) < 4)
3523 continue;
3524
3525 a = undecchar(de->d_name[1]);
3526 b = undecchar(de->d_name[2]);
3527
3528 if (a < 0 || b < 0)
3529 continue;
3530
3531 free(fpath);
3532 fpath = strjoin(path, "/", de->d_name, NULL);
3533 if (!fpath) {
3534 r = -ENOMEM;
3535 goto finish;
3536 }
3537
3538 if (access(fpath, X_OK) < 0) {
3539
3540 if (errno != ENOENT)
3541 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3542
3543 continue;
3544 }
3545
3546 free(name);
3547 name = sysv_translate_name(de->d_name + 3);
3548 if (!name) {
3549 r = log_oom();
3550 goto finish;
3551 }
3552
3553 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3554 if (r < 0) {
3555 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3556 continue;
3557 }
3558
3559 if (de->d_name[0] == 'S') {
3560
3561 if (rcnd_table[i].type == RUNLEVEL_UP) {
3562 SERVICE(service)->sysv_start_priority_from_rcnd =
3563 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3564
3565 SERVICE(service)->sysv_enabled = true;
3566 }
3567
3568 r = set_ensure_allocated(&runlevel_services[i],
3569 trivial_hash_func, trivial_compare_func);
3570 if (r < 0)
3571 goto finish;
3572
3573 r = set_put(runlevel_services[i], service);
3574 if (r < 0)
3575 goto finish;
3576
3577 } else if (de->d_name[0] == 'K' &&
3578 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3579
3580 r = set_ensure_allocated(&shutdown_services,
3581 trivial_hash_func, trivial_compare_func);
3582 if (r < 0)
3583 goto finish;
3584
3585 r = set_put(shutdown_services, service);
3586 if (r < 0)
3587 goto finish;
3588 }
3589 }
3590 }
3591
3592 /* Now we loaded all stubs and are aware of the lowest
3593 start-up priority for all services, not let's actually load
3594 the services, this will also tell us which services are
3595 actually native now */
3596 manager_dispatch_load_queue(m);
3597
3598 /* If this is a native service, rely on native ways to pull in
3599 * a service, don't pull it in via sysv rcN.d links. */
3600 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3601 SET_FOREACH(service, runlevel_services[i], j) {
3602 service = unit_follow_merge(service);
3603
3604 if (service->fragment_path)
3605 continue;
3606
3607 r = unit_add_two_dependencies_by_name_inverse(
3608 service, UNIT_AFTER, UNIT_WANTS,
3609 rcnd_table[i].target, NULL, true);
3610 if (r < 0)
3611 goto finish;
3612 }
3613
3614 /* We honour K links only for halt/reboot. For the normal
3615 * runlevels we assume the stop jobs will be implicitly added
3616 * by the core logic. Also, we don't really distinguish here
3617 * between the runlevels 0 and 6 and just add them to the
3618 * special shutdown target. */
3619 SET_FOREACH(service, shutdown_services, j) {
3620 service = unit_follow_merge(service);
3621
3622 if (service->fragment_path)
3623 continue;
3624
3625 r = unit_add_two_dependencies_by_name(
3626 service, UNIT_BEFORE, UNIT_CONFLICTS,
3627 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3628 if (r < 0)
3629 goto finish;
3630 }
3631
3632 r = 0;
3633
3634finish:
3635
3636 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3637 set_free(runlevel_services[i]);
3638
3639 return r;
3640}
3641#endif
3642
3643static void service_bus_name_owner_change(
3644 Unit *u,
3645 const char *name,
3646 const char *old_owner,
3647 const char *new_owner) {
3648
3649 Service *s = SERVICE(u);
3650
3651 assert(s);
3652 assert(name);
3653
3654 assert(streq(s->bus_name, name));
3655 assert(old_owner || new_owner);
3656
3657 if (old_owner && new_owner)
3658 log_debug_unit(u->id,
3659 "%s's D-Bus name %s changed owner from %s to %s",
3660 u->id, name, old_owner, new_owner);
3661 else if (old_owner)
3662 log_debug_unit(u->id,
3663 "%s's D-Bus name %s no longer registered by %s",
3664 u->id, name, old_owner);
3665 else
3666 log_debug_unit(u->id,
3667 "%s's D-Bus name %s now registered by %s",
3668 u->id, name, new_owner);
3669
3670 s->bus_name_good = !!new_owner;
3671
3672 if (s->type == SERVICE_DBUS) {
3673
3674 /* service_enter_running() will figure out what to
3675 * do */
3676 if (s->state == SERVICE_RUNNING)
3677 service_enter_running(s, SERVICE_SUCCESS);
3678 else if (s->state == SERVICE_START && new_owner)
3679 service_enter_start_post(s);
3680
3681 } else if (new_owner &&
3682 s->main_pid <= 0 &&
3683 (s->state == SERVICE_START ||
3684 s->state == SERVICE_START_POST ||
3685 s->state == SERVICE_RUNNING ||
3686 s->state == SERVICE_RELOAD)) {
3687
3688 /* Try to acquire PID from bus service */
3689 log_debug_unit(u->id,
3690 "Trying to acquire PID from D-Bus name...");
3691
3692 bus_query_pid(u->manager, name);
3693 }
3694}
3695
3696static void service_bus_query_pid_done(
3697 Unit *u,
3698 const char *name,
3699 pid_t pid) {
3700
3701 Service *s = SERVICE(u);
3702
3703 assert(s);
3704 assert(name);
3705
3706 log_debug_unit(u->id,
3707 "%s's D-Bus name %s is now owned by process %u",
3708 u->id, name, (unsigned) pid);
3709
3710 if (s->main_pid <= 0 &&
3711 (s->state == SERVICE_START ||
3712 s->state == SERVICE_START_POST ||
3713 s->state == SERVICE_RUNNING ||
3714 s->state == SERVICE_RELOAD))
3715 service_set_main_pid(s, pid);
3716}
3717
3718int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3719
3720 assert(s);
3721 assert(fd >= 0);
3722
3723 /* This is called by the socket code when instantiating a new
3724 * service for a stream socket and the socket needs to be
3725 * configured. */
3726
3727 if (UNIT(s)->load_state != UNIT_LOADED)
3728 return -EINVAL;
3729
3730 if (s->socket_fd >= 0)
3731 return -EBUSY;
3732
3733 if (s->state != SERVICE_DEAD)
3734 return -EAGAIN;
3735
3736 s->socket_fd = fd;
3737 s->got_socket_fd = true;
3738
3739 unit_ref_set(&s->accept_socket, UNIT(sock));
3740
3741 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3742}
3743
3744static void service_reset_failed(Unit *u) {
3745 Service *s = SERVICE(u);
3746
3747 assert(s);
3748
3749 if (s->state == SERVICE_FAILED)
3750 service_set_state(s, SERVICE_DEAD);
3751
3752 s->result = SERVICE_SUCCESS;
3753 s->reload_result = SERVICE_SUCCESS;
3754
3755 RATELIMIT_RESET(s->start_limit);
3756}
3757
3758static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
3759 Service *s = SERVICE(u);
3760
3761 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3762}
3763
3764static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3765 [SERVICE_DEAD] = "dead",
3766 [SERVICE_START_PRE] = "start-pre",
3767 [SERVICE_START] = "start",
3768 [SERVICE_START_POST] = "start-post",
3769 [SERVICE_RUNNING] = "running",
3770 [SERVICE_EXITED] = "exited",
3771 [SERVICE_RELOAD] = "reload",
3772 [SERVICE_STOP] = "stop",
3773 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3774 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3775 [SERVICE_STOP_POST] = "stop-post",
3776 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3777 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3778 [SERVICE_FAILED] = "failed",
3779 [SERVICE_AUTO_RESTART] = "auto-restart",
3780};
3781
3782DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3783
3784static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3785 [SERVICE_RESTART_NO] = "no",
3786 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3787 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3788 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3789 [SERVICE_RESTART_ALWAYS] = "always"
3790};
3791
3792DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3793
3794static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3795 [SERVICE_SIMPLE] = "simple",
3796 [SERVICE_FORKING] = "forking",
3797 [SERVICE_ONESHOT] = "oneshot",
3798 [SERVICE_DBUS] = "dbus",
3799 [SERVICE_NOTIFY] = "notify",
3800 [SERVICE_IDLE] = "idle"
3801};
3802
3803DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3804
3805static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3806 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3807 [SERVICE_EXEC_START] = "ExecStart",
3808 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3809 [SERVICE_EXEC_RELOAD] = "ExecReload",
3810 [SERVICE_EXEC_STOP] = "ExecStop",
3811 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3812};
3813
3814DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3815
3816static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3817 [NOTIFY_NONE] = "none",
3818 [NOTIFY_MAIN] = "main",
3819 [NOTIFY_ALL] = "all"
3820};
3821
3822DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3823
3824static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3825 [SERVICE_SUCCESS] = "success",
3826 [SERVICE_FAILURE_RESOURCES] = "resources",
3827 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3828 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3829 [SERVICE_FAILURE_SIGNAL] = "signal",
3830 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3831 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3832 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3833};
3834
3835DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3836
3837static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3838 [SERVICE_START_LIMIT_NONE] = "none",
3839 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3840 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3841 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3842};
3843DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3844
3845const UnitVTable service_vtable = {
3846 .object_size = sizeof(Service),
3847
3848 .sections =
3849 "Unit\0"
3850 "Service\0"
3851 "Install\0",
3852
3853 .private_section = "Service",
3854 .exec_context_offset = offsetof(Service, exec_context),
3855 .cgroup_context_offset = offsetof(Service, cgroup_context),
3856
3857 .init = service_init,
3858 .done = service_done,
3859 .load = service_load,
3860
3861 .coldplug = service_coldplug,
3862
3863 .dump = service_dump,
3864
3865 .start = service_start,
3866 .stop = service_stop,
3867 .reload = service_reload,
3868
3869 .can_reload = service_can_reload,
3870
3871 .kill = service_kill,
3872
3873 .serialize = service_serialize,
3874 .deserialize_item = service_deserialize_item,
3875
3876 .active_state = service_active_state,
3877 .sub_state_to_string = service_sub_state_to_string,
3878
3879 .check_gc = service_check_gc,
3880 .check_snapshot = service_check_snapshot,
3881
3882 .sigchld_event = service_sigchld_event,
3883 .timer_event = service_timer_event,
3884 .fd_event = service_fd_event,
3885
3886 .reset_failed = service_reset_failed,
3887
3888 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3889 .notify_message = service_notify_message,
3890
3891 .bus_name_owner_change = service_bus_name_owner_change,
3892 .bus_query_pid_done = service_bus_query_pid_done,
3893
3894 .bus_interface = "org.freedesktop.systemd1.Service",
3895 .bus_message_handler = bus_service_message_handler,
3896 .bus_invalidating_properties = bus_service_invalidating_properties,
3897 .bus_set_property = bus_service_set_property,
3898 .bus_commit_properties = bus_service_commit_properties,
3899
3900 .can_transient = true,
3901
3902#ifdef HAVE_SYSV_COMPAT
3903 .enumerate = service_enumerate,
3904#endif
3905 .status_message_formats = {
3906 .starting_stopping = {
3907 [0] = "Starting %s...",
3908 [1] = "Stopping %s...",
3909 },
3910 .finished_start_job = {
3911 [JOB_DONE] = "Started %s.",
3912 [JOB_FAILED] = "Failed to start %s.",
3913 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3914 [JOB_TIMEOUT] = "Timed out starting %s.",
3915 },
3916 .finished_stop_job = {
3917 [JOB_DONE] = "Stopped %s.",
3918 [JOB_FAILED] = "Stopped (with error) %s.",
3919 [JOB_TIMEOUT] = "Timed out stopping %s.",
3920 },
3921 },
3922};
Unnamed repository; edit this file 'description' to name the repository.