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