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