]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/service.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
manager: drop MountAuto= and SwapAuto= options
[thirdparty/systemd.git] / src / core / service.c
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
48 typedef enum RunlevelType {
49 RUNLEVEL_UP,
50 RUNLEVEL_DOWN,
51 RUNLEVEL_SYSINIT
52 } RunlevelType;
53
54 static 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
92 static 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
110 static 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
136 static 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
146 static 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
156 static 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
167 static 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
194 static 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
204 static 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
214 static 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
222 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
223
224 static 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
245 static void service_reset_watchdog(Service *s) {
246 assert(s);
247
248 dual_timestamp_get(&s->watchdog_timestamp);
249 service_handle_watchdog(s);
250 }
251
252 static 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
299 static 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
327 static 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
414 finish:
415 *_r = r;
416
417 return 1;
418 }
419
420 static 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
477 static 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
497 static 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
518 static 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
939 finish:
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
951 static 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
1036 static 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
1069 static 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
1110 static 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->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
1139 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1140 return -EINVAL;
1141 }
1142
1143 return 0;
1144 }
1145
1146 static int service_add_default_dependencies(Service *s) {
1147 int r;
1148
1149 assert(s);
1150
1151 /* Add a number of automatic dependencies useful for the
1152 * majority of services. */
1153
1154 /* First, pull in base system */
1155 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
1156
1157 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1158 return r;
1159
1160 } else if (UNIT(s)->manager->running_as == MANAGER_USER) {
1161
1162 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1163 return r;
1164 }
1165
1166 /* Second, activate normal shutdown */
1167 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1168 }
1169
1170 static void service_fix_output(Service *s) {
1171 assert(s);
1172
1173 /* If nothing has been explicitly configured, patch default
1174 * output in. If input is socket/tty we avoid this however,
1175 * since in that case we want output to default to the same
1176 * place as we read input from. */
1177
1178 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1179 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1180 s->exec_context.std_input == EXEC_INPUT_NULL)
1181 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1182
1183 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1184 s->exec_context.std_input == EXEC_INPUT_NULL)
1185 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1186 }
1187
1188 static int service_load(Unit *u) {
1189 int r;
1190 Service *s = SERVICE(u);
1191
1192 assert(s);
1193
1194 /* Load a .service file */
1195 if ((r = unit_load_fragment(u)) < 0)
1196 return r;
1197
1198 #ifdef HAVE_SYSV_COMPAT
1199 /* Load a classic init script as a fallback, if we couldn't find anything */
1200 if (u->load_state == UNIT_STUB)
1201 if ((r = service_load_sysv(s)) < 0)
1202 return r;
1203 #endif
1204
1205 /* Still nothing found? Then let's give up */
1206 if (u->load_state == UNIT_STUB)
1207 return -ENOENT;
1208
1209 /* We were able to load something, then let's add in the
1210 * dropin directories. */
1211 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1212 return r;
1213
1214 /* This is a new unit? Then let's add in some extras */
1215 if (u->load_state == UNIT_LOADED) {
1216 service_fix_output(s);
1217
1218 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1219 return r;
1220
1221 if ((r = unit_add_default_cgroups(u)) < 0)
1222 return r;
1223
1224 #ifdef HAVE_SYSV_COMPAT
1225 if ((r = sysv_fix_order(s)) < 0)
1226 return r;
1227 #endif
1228
1229 if ((r = fsck_fix_order(s)) < 0)
1230 return r;
1231
1232 if (s->bus_name)
1233 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1234 return r;
1235
1236 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1237 s->notify_access = NOTIFY_MAIN;
1238
1239 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1240 s->notify_access = NOTIFY_MAIN;
1241
1242 if (s->type == SERVICE_DBUS || s->bus_name)
1243 if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1244 return r;
1245
1246 if (UNIT(s)->default_dependencies)
1247 if ((r = service_add_default_dependencies(s)) < 0)
1248 return r;
1249 }
1250
1251 return service_verify(s);
1252 }
1253
1254 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1255
1256 ServiceExecCommand c;
1257 Service *s = SERVICE(u);
1258 const char *prefix2;
1259 char *p2;
1260
1261 assert(s);
1262
1263 p2 = strappend(prefix, "\t");
1264 prefix2 = p2 ? p2 : prefix;
1265
1266 fprintf(f,
1267 "%sService State: %s\n"
1268 "%sResult: %s\n"
1269 "%sReload Result: %s\n"
1270 "%sPermissionsStartOnly: %s\n"
1271 "%sRootDirectoryStartOnly: %s\n"
1272 "%sRemainAfterExit: %s\n"
1273 "%sGuessMainPID: %s\n"
1274 "%sType: %s\n"
1275 "%sRestart: %s\n"
1276 "%sNotifyAccess: %s\n",
1277 prefix, service_state_to_string(s->state),
1278 prefix, service_result_to_string(s->result),
1279 prefix, service_result_to_string(s->reload_result),
1280 prefix, yes_no(s->permissions_start_only),
1281 prefix, yes_no(s->root_directory_start_only),
1282 prefix, yes_no(s->remain_after_exit),
1283 prefix, yes_no(s->guess_main_pid),
1284 prefix, service_type_to_string(s->type),
1285 prefix, service_restart_to_string(s->restart),
1286 prefix, notify_access_to_string(s->notify_access));
1287
1288 if (s->control_pid > 0)
1289 fprintf(f,
1290 "%sControl PID: %lu\n",
1291 prefix, (unsigned long) s->control_pid);
1292
1293 if (s->main_pid > 0)
1294 fprintf(f,
1295 "%sMain PID: %lu\n"
1296 "%sMain PID Known: %s\n"
1297 "%sMain PID Alien: %s\n",
1298 prefix, (unsigned long) s->main_pid,
1299 prefix, yes_no(s->main_pid_known),
1300 prefix, yes_no(s->main_pid_alien));
1301
1302 if (s->pid_file)
1303 fprintf(f,
1304 "%sPIDFile: %s\n",
1305 prefix, s->pid_file);
1306
1307 if (s->bus_name)
1308 fprintf(f,
1309 "%sBusName: %s\n"
1310 "%sBus Name Good: %s\n",
1311 prefix, s->bus_name,
1312 prefix, yes_no(s->bus_name_good));
1313
1314 exec_context_dump(&s->exec_context, f, prefix);
1315
1316 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1317
1318 if (!s->exec_command[c])
1319 continue;
1320
1321 fprintf(f, "%s-> %s:\n",
1322 prefix, service_exec_command_to_string(c));
1323
1324 exec_command_dump_list(s->exec_command[c], f, prefix2);
1325 }
1326
1327 #ifdef HAVE_SYSV_COMPAT
1328 if (s->sysv_path)
1329 fprintf(f,
1330 "%sSysV Init Script Path: %s\n"
1331 "%sSysV Init Script has LSB Header: %s\n"
1332 "%sSysVEnabled: %s\n",
1333 prefix, s->sysv_path,
1334 prefix, yes_no(s->sysv_has_lsb),
1335 prefix, yes_no(s->sysv_enabled));
1336
1337 if (s->sysv_start_priority >= 0)
1338 fprintf(f,
1339 "%sSysVStartPriority: %i\n",
1340 prefix, s->sysv_start_priority);
1341
1342 if (s->sysv_runlevels)
1343 fprintf(f, "%sSysVRunLevels: %s\n",
1344 prefix, s->sysv_runlevels);
1345 #endif
1346
1347 if (s->fsck_passno > 0)
1348 fprintf(f,
1349 "%sFsckPassNo: %i\n",
1350 prefix, s->fsck_passno);
1351
1352 if (s->status_text)
1353 fprintf(f, "%sStatus Text: %s\n",
1354 prefix, s->status_text);
1355
1356 free(p2);
1357 }
1358
1359 static int service_load_pid_file(Service *s, bool may_warn) {
1360 char *k;
1361 int r;
1362 pid_t pid;
1363
1364 assert(s);
1365
1366 if (!s->pid_file)
1367 return -ENOENT;
1368
1369 if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1370 if (may_warn)
1371 log_info("PID file %s not readable (yet?) after %s.",
1372 s->pid_file, service_state_to_string(s->state));
1373 return r;
1374 }
1375
1376 r = parse_pid(k, &pid);
1377 free(k);
1378
1379 if (r < 0)
1380 return r;
1381
1382 if (kill(pid, 0) < 0 && errno != EPERM) {
1383 if (may_warn)
1384 log_info("PID %lu read from file %s does not exist.",
1385 (unsigned long) pid, s->pid_file);
1386 return -ESRCH;
1387 }
1388
1389 if (s->main_pid_known) {
1390 if (pid == s->main_pid)
1391 return 0;
1392
1393 log_debug("Main PID changing: %lu -> %lu",
1394 (unsigned long) s->main_pid, (unsigned long) pid);
1395 service_unwatch_main_pid(s);
1396 s->main_pid_known = false;
1397 } else
1398 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1399
1400 if ((r = service_set_main_pid(s, pid)) < 0)
1401 return r;
1402
1403 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1404 /* FIXME: we need to do something here */
1405 return r;
1406
1407 return 0;
1408 }
1409
1410 static int service_search_main_pid(Service *s) {
1411 pid_t pid;
1412 int r;
1413
1414 assert(s);
1415
1416 /* If we know it anyway, don't ever fallback to unreliable
1417 * heuristics */
1418 if (s->main_pid_known)
1419 return 0;
1420
1421 if (!s->guess_main_pid)
1422 return 0;
1423
1424 assert(s->main_pid <= 0);
1425
1426 if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1427 return -ENOENT;
1428
1429 log_debug("Main PID guessed: %lu", (unsigned long) pid);
1430 if ((r = service_set_main_pid(s, pid)) < 0)
1431 return r;
1432
1433 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1434 /* FIXME: we need to do something here */
1435 return r;
1436
1437 return 0;
1438 }
1439
1440 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1441 Iterator i;
1442 Unit *u;
1443
1444 assert(s);
1445
1446 /* Notifies all our sockets when we die */
1447
1448 if (s->socket_fd >= 0)
1449 return;
1450
1451 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1452 if (u->type == UNIT_SOCKET)
1453 socket_notify_service_dead(SOCKET(u), failed_permanent);
1454
1455 return;
1456 }
1457
1458 static void service_set_state(Service *s, ServiceState state) {
1459 ServiceState old_state;
1460 assert(s);
1461
1462 old_state = s->state;
1463 s->state = state;
1464
1465 service_unwatch_pid_file(s);
1466
1467 if (state != SERVICE_START_PRE &&
1468 state != SERVICE_START &&
1469 state != SERVICE_START_POST &&
1470 state != SERVICE_RELOAD &&
1471 state != SERVICE_STOP &&
1472 state != SERVICE_STOP_SIGTERM &&
1473 state != SERVICE_STOP_SIGKILL &&
1474 state != SERVICE_STOP_POST &&
1475 state != SERVICE_FINAL_SIGTERM &&
1476 state != SERVICE_FINAL_SIGKILL &&
1477 state != SERVICE_AUTO_RESTART)
1478 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1479
1480 if (state != SERVICE_START &&
1481 state != SERVICE_START_POST &&
1482 state != SERVICE_RUNNING &&
1483 state != SERVICE_RELOAD &&
1484 state != SERVICE_STOP &&
1485 state != SERVICE_STOP_SIGTERM &&
1486 state != SERVICE_STOP_SIGKILL) {
1487 service_unwatch_main_pid(s);
1488 s->main_command = NULL;
1489 }
1490
1491 if (state != SERVICE_START_PRE &&
1492 state != SERVICE_START &&
1493 state != SERVICE_START_POST &&
1494 state != SERVICE_RELOAD &&
1495 state != SERVICE_STOP &&
1496 state != SERVICE_STOP_SIGTERM &&
1497 state != SERVICE_STOP_SIGKILL &&
1498 state != SERVICE_STOP_POST &&
1499 state != SERVICE_FINAL_SIGTERM &&
1500 state != SERVICE_FINAL_SIGKILL) {
1501 service_unwatch_control_pid(s);
1502 s->control_command = NULL;
1503 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1504 }
1505
1506 if (state == SERVICE_DEAD ||
1507 state == SERVICE_STOP ||
1508 state == SERVICE_STOP_SIGTERM ||
1509 state == SERVICE_STOP_SIGKILL ||
1510 state == SERVICE_STOP_POST ||
1511 state == SERVICE_FINAL_SIGTERM ||
1512 state == SERVICE_FINAL_SIGKILL ||
1513 state == SERVICE_FAILED ||
1514 state == SERVICE_AUTO_RESTART)
1515 service_notify_sockets_dead(s, false);
1516
1517 if (state != SERVICE_START_PRE &&
1518 state != SERVICE_START &&
1519 state != SERVICE_START_POST &&
1520 state != SERVICE_RUNNING &&
1521 state != SERVICE_RELOAD &&
1522 state != SERVICE_STOP &&
1523 state != SERVICE_STOP_SIGTERM &&
1524 state != SERVICE_STOP_SIGKILL &&
1525 state != SERVICE_STOP_POST &&
1526 state != SERVICE_FINAL_SIGTERM &&
1527 state != SERVICE_FINAL_SIGKILL &&
1528 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1529 service_close_socket_fd(s);
1530 service_connection_unref(s);
1531 }
1532
1533 if (state == SERVICE_STOP)
1534 service_stop_watchdog(s);
1535
1536 /* For the inactive states unit_notify() will trim the cgroup,
1537 * but for exit we have to do that ourselves... */
1538 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1539 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1540
1541 if (old_state != state)
1542 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1543
1544 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], s->reload_result == SERVICE_SUCCESS);
1545 s->reload_result = SERVICE_SUCCESS;
1546 }
1547
1548 static int service_coldplug(Unit *u) {
1549 Service *s = SERVICE(u);
1550 int r;
1551
1552 assert(s);
1553 assert(s->state == SERVICE_DEAD);
1554
1555 if (s->deserialized_state != s->state) {
1556
1557 if (s->deserialized_state == SERVICE_START_PRE ||
1558 s->deserialized_state == SERVICE_START ||
1559 s->deserialized_state == SERVICE_START_POST ||
1560 s->deserialized_state == SERVICE_RELOAD ||
1561 s->deserialized_state == SERVICE_STOP ||
1562 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1563 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1564 s->deserialized_state == SERVICE_STOP_POST ||
1565 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1566 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1567 s->deserialized_state == SERVICE_AUTO_RESTART) {
1568
1569 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) {
1570 usec_t k;
1571
1572 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec;
1573
1574 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1575 return r;
1576 }
1577 }
1578
1579 if ((s->deserialized_state == SERVICE_START &&
1580 (s->type == SERVICE_FORKING ||
1581 s->type == SERVICE_DBUS ||
1582 s->type == SERVICE_ONESHOT ||
1583 s->type == SERVICE_NOTIFY)) ||
1584 s->deserialized_state == SERVICE_START_POST ||
1585 s->deserialized_state == SERVICE_RUNNING ||
1586 s->deserialized_state == SERVICE_RELOAD ||
1587 s->deserialized_state == SERVICE_STOP ||
1588 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1589 s->deserialized_state == SERVICE_STOP_SIGKILL)
1590 if (s->main_pid > 0)
1591 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1592 return r;
1593
1594 if (s->deserialized_state == SERVICE_START_PRE ||
1595 s->deserialized_state == SERVICE_START ||
1596 s->deserialized_state == SERVICE_START_POST ||
1597 s->deserialized_state == SERVICE_RELOAD ||
1598 s->deserialized_state == SERVICE_STOP ||
1599 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1600 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1601 s->deserialized_state == SERVICE_STOP_POST ||
1602 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1603 s->deserialized_state == SERVICE_FINAL_SIGKILL)
1604 if (s->control_pid > 0)
1605 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1606 return r;
1607
1608 if (s->deserialized_state == SERVICE_START_POST ||
1609 s->deserialized_state == SERVICE_RUNNING)
1610 service_handle_watchdog(s);
1611
1612 service_set_state(s, s->deserialized_state);
1613 }
1614 return 0;
1615 }
1616
1617 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1618 Iterator i;
1619 int r;
1620 int *rfds = NULL;
1621 unsigned rn_fds = 0;
1622 Unit *u;
1623
1624 assert(s);
1625 assert(fds);
1626 assert(n_fds);
1627
1628 if (s->socket_fd >= 0)
1629 return 0;
1630
1631 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1632 int *cfds;
1633 unsigned cn_fds;
1634 Socket *sock;
1635
1636 if (u->type != UNIT_SOCKET)
1637 continue;
1638
1639 sock = SOCKET(u);
1640
1641 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1642 goto fail;
1643
1644 if (!cfds)
1645 continue;
1646
1647 if (!rfds) {
1648 rfds = cfds;
1649 rn_fds = cn_fds;
1650 } else {
1651 int *t;
1652
1653 if (!(t = new(int, rn_fds+cn_fds))) {
1654 free(cfds);
1655 r = -ENOMEM;
1656 goto fail;
1657 }
1658
1659 memcpy(t, rfds, rn_fds * sizeof(int));
1660 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1661 free(rfds);
1662 free(cfds);
1663
1664 rfds = t;
1665 rn_fds = rn_fds+cn_fds;
1666 }
1667 }
1668
1669 *fds = rfds;
1670 *n_fds = rn_fds;
1671
1672 return 0;
1673
1674 fail:
1675 free(rfds);
1676
1677 return r;
1678 }
1679
1680 static int service_spawn(
1681 Service *s,
1682 ExecCommand *c,
1683 bool timeout,
1684 bool pass_fds,
1685 bool apply_permissions,
1686 bool apply_chroot,
1687 bool apply_tty_stdin,
1688 bool set_notify_socket,
1689 bool is_control,
1690 pid_t *_pid) {
1691
1692 pid_t pid;
1693 int r;
1694 int *fds = NULL, *fdsbuf = NULL;
1695 unsigned n_fds = 0, n_env = 0;
1696 char **argv = NULL, **final_env = NULL, **our_env = NULL;
1697
1698 assert(s);
1699 assert(c);
1700 assert(_pid);
1701
1702 if (pass_fds ||
1703 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1704 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1705 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1706
1707 if (s->socket_fd >= 0) {
1708 fds = &s->socket_fd;
1709 n_fds = 1;
1710 } else {
1711 if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1712 goto fail;
1713
1714 fds = fdsbuf;
1715 }
1716 }
1717
1718 if (timeout && s->timeout_usec) {
1719 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1720 goto fail;
1721 } else
1722 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1723
1724 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1725 r = -ENOMEM;
1726 goto fail;
1727 }
1728
1729 if (!(our_env = new0(char*, 4))) {
1730 r = -ENOMEM;
1731 goto fail;
1732 }
1733
1734 if (set_notify_socket)
1735 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1736 r = -ENOMEM;
1737 goto fail;
1738 }
1739
1740 if (s->main_pid > 0)
1741 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1742 r = -ENOMEM;
1743 goto fail;
1744 }
1745
1746 if (s->watchdog_usec > 0)
1747 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1748 r = -ENOMEM;
1749 goto fail;
1750 }
1751
1752 if (!(final_env = strv_env_merge(2,
1753 UNIT(s)->manager->environment,
1754 our_env,
1755 NULL))) {
1756 r = -ENOMEM;
1757 goto fail;
1758 }
1759
1760 r = exec_spawn(c,
1761 argv,
1762 &s->exec_context,
1763 fds, n_fds,
1764 final_env,
1765 apply_permissions,
1766 apply_chroot,
1767 apply_tty_stdin,
1768 UNIT(s)->manager->confirm_spawn,
1769 UNIT(s)->cgroup_bondings,
1770 UNIT(s)->cgroup_attributes,
1771 is_control ? "control" : NULL,
1772 &pid);
1773
1774 if (r < 0)
1775 goto fail;
1776
1777
1778 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1779 /* FIXME: we need to do something here */
1780 goto fail;
1781
1782 free(fdsbuf);
1783 strv_free(argv);
1784 strv_free(our_env);
1785 strv_free(final_env);
1786
1787 *_pid = pid;
1788
1789 return 0;
1790
1791 fail:
1792 free(fdsbuf);
1793 strv_free(argv);
1794 strv_free(our_env);
1795 strv_free(final_env);
1796
1797 if (timeout)
1798 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1799
1800 return r;
1801 }
1802
1803 static int main_pid_good(Service *s) {
1804 assert(s);
1805
1806 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1807 * don't know */
1808
1809 /* If we know the pid file, then lets just check if it is
1810 * still valid */
1811 if (s->main_pid_known) {
1812
1813 /* If it's an alien child let's check if it is still
1814 * alive ... */
1815 if (s->main_pid_alien)
1816 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1817
1818 /* .. otherwise assume we'll get a SIGCHLD for it,
1819 * which we really should wait for to collect exit
1820 * status and code */
1821 return s->main_pid > 0;
1822 }
1823
1824 /* We don't know the pid */
1825 return -EAGAIN;
1826 }
1827
1828 static int control_pid_good(Service *s) {
1829 assert(s);
1830
1831 return s->control_pid > 0;
1832 }
1833
1834 static int cgroup_good(Service *s) {
1835 int r;
1836
1837 assert(s);
1838
1839 if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1840 return r;
1841
1842 return !r;
1843 }
1844
1845 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1846 int r;
1847 assert(s);
1848
1849 if (f != SERVICE_SUCCESS)
1850 s->result = f;
1851
1852 if (allow_restart &&
1853 !s->forbid_restart &&
1854 (s->restart == SERVICE_RESTART_ALWAYS ||
1855 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1856 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1857 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1858 s->result == SERVICE_FAILURE_CORE_DUMP)))) {
1859
1860 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1861 if (r < 0)
1862 goto fail;
1863
1864 service_set_state(s, SERVICE_AUTO_RESTART);
1865 } else
1866 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1867
1868 s->forbid_restart = false;
1869
1870 return;
1871
1872 fail:
1873 log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1874 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1875 }
1876
1877 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1878
1879 static void service_enter_stop_post(Service *s, ServiceResult f) {
1880 int r;
1881 assert(s);
1882
1883 if (f != SERVICE_SUCCESS)
1884 s->result = f;
1885
1886 service_unwatch_control_pid(s);
1887
1888 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1889 s->control_command_id = SERVICE_EXEC_STOP_POST;
1890
1891 r = service_spawn(s,
1892 s->control_command,
1893 true,
1894 false,
1895 !s->permissions_start_only,
1896 !s->root_directory_start_only,
1897 true,
1898 false,
1899 true,
1900 &s->control_pid);
1901 if (r < 0)
1902 goto fail;
1903
1904
1905 service_set_state(s, SERVICE_STOP_POST);
1906 } else
1907 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1908
1909 return;
1910
1911 fail:
1912 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1913 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1914 }
1915
1916 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1917 int r;
1918 Set *pid_set = NULL;
1919 bool wait_for_exit = false;
1920
1921 assert(s);
1922
1923 if (f != SERVICE_SUCCESS)
1924 s->result = f;
1925
1926 if (s->exec_context.kill_mode != KILL_NONE) {
1927 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1928
1929 if (s->main_pid > 0) {
1930 if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1931 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1932 else
1933 wait_for_exit = !s->main_pid_alien;
1934 }
1935
1936 if (s->control_pid > 0) {
1937 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1938 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1939 else
1940 wait_for_exit = true;
1941 }
1942
1943 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1944
1945 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1946 r = -ENOMEM;
1947 goto fail;
1948 }
1949
1950 /* Exclude the main/control pids from being killed via the cgroup */
1951 if (s->main_pid > 0)
1952 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
1953 goto fail;
1954
1955 if (s->control_pid > 0)
1956 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1957 goto fail;
1958
1959 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, pid_set, NULL);
1960 if (r < 0) {
1961 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1962 log_warning("Failed to kill control group: %s", strerror(-r));
1963 } else if (r > 0)
1964 wait_for_exit = true;
1965
1966 set_free(pid_set);
1967 pid_set = NULL;
1968 }
1969 }
1970
1971 if (wait_for_exit) {
1972 if (s->timeout_usec > 0)
1973 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1974 goto fail;
1975
1976 service_set_state(s, state);
1977 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1978 service_enter_stop_post(s, SERVICE_SUCCESS);
1979 else
1980 service_enter_dead(s, SERVICE_SUCCESS, true);
1981
1982 return;
1983
1984 fail:
1985 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1986
1987 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1988 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1989 else
1990 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1991
1992 if (pid_set)
1993 set_free(pid_set);
1994 }
1995
1996 static void service_enter_stop(Service *s, ServiceResult f) {
1997 int r;
1998
1999 assert(s);
2000
2001 if (f != SERVICE_SUCCESS)
2002 s->result = f;
2003
2004 service_unwatch_control_pid(s);
2005
2006 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2007 s->control_command_id = SERVICE_EXEC_STOP;
2008
2009 r = service_spawn(s,
2010 s->control_command,
2011 true,
2012 false,
2013 !s->permissions_start_only,
2014 !s->root_directory_start_only,
2015 false,
2016 false,
2017 true,
2018 &s->control_pid);
2019 if (r < 0)
2020 goto fail;
2021
2022 service_set_state(s, SERVICE_STOP);
2023 } else
2024 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2025
2026 return;
2027
2028 fail:
2029 log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2030 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2031 }
2032
2033 static void service_enter_running(Service *s, ServiceResult f) {
2034 int main_pid_ok, cgroup_ok;
2035 assert(s);
2036
2037 if (f != SERVICE_SUCCESS)
2038 s->result = f;
2039
2040 main_pid_ok = main_pid_good(s);
2041 cgroup_ok = cgroup_good(s);
2042
2043 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2044 (s->bus_name_good || s->type != SERVICE_DBUS))
2045 service_set_state(s, SERVICE_RUNNING);
2046 else if (s->remain_after_exit)
2047 service_set_state(s, SERVICE_EXITED);
2048 else
2049 service_enter_stop(s, SERVICE_SUCCESS);
2050 }
2051
2052 static void service_enter_start_post(Service *s) {
2053 int r;
2054 assert(s);
2055
2056 service_unwatch_control_pid(s);
2057
2058 if (s->watchdog_usec > 0)
2059 service_reset_watchdog(s);
2060
2061 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2062 s->control_command_id = SERVICE_EXEC_START_POST;
2063
2064 r = service_spawn(s,
2065 s->control_command,
2066 true,
2067 false,
2068 !s->permissions_start_only,
2069 !s->root_directory_start_only,
2070 false,
2071 false,
2072 true,
2073 &s->control_pid);
2074 if (r < 0)
2075 goto fail;
2076
2077 service_set_state(s, SERVICE_START_POST);
2078 } else
2079 service_enter_running(s, SERVICE_SUCCESS);
2080
2081 return;
2082
2083 fail:
2084 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2085 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2086 }
2087
2088 static void service_enter_start(Service *s) {
2089 pid_t pid;
2090 int r;
2091 ExecCommand *c;
2092
2093 assert(s);
2094
2095 assert(s->exec_command[SERVICE_EXEC_START]);
2096 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2097
2098 if (s->type == SERVICE_FORKING)
2099 service_unwatch_control_pid(s);
2100 else
2101 service_unwatch_main_pid(s);
2102
2103 /* We want to ensure that nobody leaks processes from
2104 * START_PRE here, so let's go on a killing spree, People
2105 * should not spawn long running processes from START_PRE. */
2106 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL, "control");
2107
2108 if (s->type == SERVICE_FORKING) {
2109 s->control_command_id = SERVICE_EXEC_START;
2110 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2111
2112 s->main_command = NULL;
2113 } else {
2114 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2115 s->control_command = NULL;
2116
2117 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2118 }
2119
2120 r = service_spawn(s,
2121 c,
2122 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
2123 true,
2124 true,
2125 true,
2126 true,
2127 s->notify_access != NOTIFY_NONE,
2128 false,
2129 &pid);
2130 if (r < 0)
2131 goto fail;
2132
2133 if (s->type == SERVICE_SIMPLE) {
2134 /* For simple services we immediately start
2135 * the START_POST binaries. */
2136
2137 service_set_main_pid(s, pid);
2138 service_enter_start_post(s);
2139
2140 } else if (s->type == SERVICE_FORKING) {
2141
2142 /* For forking services we wait until the start
2143 * process exited. */
2144
2145 s->control_pid = pid;
2146 service_set_state(s, SERVICE_START);
2147
2148 } else if (s->type == SERVICE_ONESHOT ||
2149 s->type == SERVICE_DBUS ||
2150 s->type == SERVICE_NOTIFY) {
2151
2152 /* For oneshot services we wait until the start
2153 * process exited, too, but it is our main process. */
2154
2155 /* For D-Bus services we know the main pid right away,
2156 * but wait for the bus name to appear on the
2157 * bus. Notify services are similar. */
2158
2159 service_set_main_pid(s, pid);
2160 service_set_state(s, SERVICE_START);
2161 } else
2162 assert_not_reached("Unknown service type");
2163
2164 return;
2165
2166 fail:
2167 log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2168 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2169 }
2170
2171 static void service_enter_start_pre(Service *s) {
2172 int r;
2173
2174 assert(s);
2175
2176 service_unwatch_control_pid(s);
2177
2178 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2179
2180 /* Before we start anything, let's clear up what might
2181 * be left from previous runs. */
2182 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL, "control");
2183
2184 s->control_command_id = SERVICE_EXEC_START_PRE;
2185
2186 r = service_spawn(s,
2187 s->control_command,
2188 true,
2189 false,
2190 !s->permissions_start_only,
2191 !s->root_directory_start_only,
2192 true,
2193 false,
2194 true,
2195 &s->control_pid);
2196 if (r < 0)
2197 goto fail;
2198
2199 service_set_state(s, SERVICE_START_PRE);
2200 } else
2201 service_enter_start(s);
2202
2203 return;
2204
2205 fail:
2206 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2207 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2208 }
2209
2210 static void service_enter_restart(Service *s) {
2211 int r;
2212 DBusError error;
2213
2214 assert(s);
2215 dbus_error_init(&error);
2216
2217 if (UNIT(s)->job) {
2218 log_info("Job pending for unit, delaying automatic restart.");
2219
2220 if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
2221 goto fail;
2222 }
2223
2224 /* Any units that are bound to this service must also be
2225 * restarted. We use JOB_RESTART (instead of the more obvious
2226 * JOB_START) here so that those dependency jobs will be added
2227 * as well. */
2228 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2229 if (r < 0)
2230 goto fail;
2231
2232 log_debug("%s scheduled restart job.", UNIT(s)->id);
2233 return;
2234
2235 fail:
2236 log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2237 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2238
2239 dbus_error_free(&error);
2240 }
2241
2242 static void service_enter_reload(Service *s) {
2243 int r;
2244
2245 assert(s);
2246
2247 service_unwatch_control_pid(s);
2248
2249 if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2250 s->control_command_id = SERVICE_EXEC_RELOAD;
2251
2252 r = service_spawn(s,
2253 s->control_command,
2254 true,
2255 false,
2256 !s->permissions_start_only,
2257 !s->root_directory_start_only,
2258 false,
2259 false,
2260 true,
2261 &s->control_pid);
2262 if (r < 0)
2263 goto fail;
2264
2265 service_set_state(s, SERVICE_RELOAD);
2266 } else
2267 service_enter_running(s, SERVICE_SUCCESS);
2268
2269 return;
2270
2271 fail:
2272 log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2273 s->reload_result = SERVICE_FAILURE_RESOURCES;
2274 service_enter_running(s, SERVICE_SUCCESS);
2275 }
2276
2277 static void service_run_next_control(Service *s) {
2278 int r;
2279
2280 assert(s);
2281 assert(s->control_command);
2282 assert(s->control_command->command_next);
2283
2284 assert(s->control_command_id != SERVICE_EXEC_START);
2285
2286 s->control_command = s->control_command->command_next;
2287 service_unwatch_control_pid(s);
2288
2289 r = service_spawn(s,
2290 s->control_command,
2291 true,
2292 false,
2293 !s->permissions_start_only,
2294 !s->root_directory_start_only,
2295 s->control_command_id == SERVICE_EXEC_START_PRE ||
2296 s->control_command_id == SERVICE_EXEC_STOP_POST,
2297 false,
2298 true,
2299 &s->control_pid);
2300 if (r < 0)
2301 goto fail;
2302
2303 return;
2304
2305 fail:
2306 log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2307
2308 if (s->state == SERVICE_START_PRE)
2309 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2310 else if (s->state == SERVICE_STOP)
2311 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2312 else if (s->state == SERVICE_STOP_POST)
2313 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2314 else if (s->state == SERVICE_RELOAD) {
2315 s->reload_result = SERVICE_FAILURE_RESOURCES;
2316 service_enter_running(s, SERVICE_SUCCESS);
2317 } else
2318 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2319 }
2320
2321 static void service_run_next_main(Service *s) {
2322 pid_t pid;
2323 int r;
2324
2325 assert(s);
2326 assert(s->main_command);
2327 assert(s->main_command->command_next);
2328 assert(s->type == SERVICE_ONESHOT);
2329
2330 s->main_command = s->main_command->command_next;
2331 service_unwatch_main_pid(s);
2332
2333 r = service_spawn(s,
2334 s->main_command,
2335 false,
2336 true,
2337 true,
2338 true,
2339 true,
2340 s->notify_access != NOTIFY_NONE,
2341 false,
2342 &pid);
2343 if (r < 0)
2344 goto fail;
2345
2346 service_set_main_pid(s, pid);
2347
2348 return;
2349
2350 fail:
2351 log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2352 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2353 }
2354
2355 static int service_start_limit_test(Service *s) {
2356 assert(s);
2357
2358 if (ratelimit_test(&s->start_limit))
2359 return 0;
2360
2361 switch (s->start_limit_action) {
2362
2363 case SERVICE_START_LIMIT_NONE:
2364 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2365 break;
2366
2367 case SERVICE_START_LIMIT_REBOOT: {
2368 DBusError error;
2369 int r;
2370
2371 dbus_error_init(&error);
2372
2373 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2374
2375 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2376 if (r < 0) {
2377 log_error("Failed to reboot: %s.", bus_error(&error, r));
2378 dbus_error_free(&error);
2379 }
2380
2381 break;
2382 }
2383
2384 case SERVICE_START_LIMIT_REBOOT_FORCE:
2385 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2386 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2387 break;
2388
2389 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2390 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2391 reboot(RB_AUTOBOOT);
2392 break;
2393
2394 default:
2395 log_error("start limit action=%i", s->start_limit_action);
2396 assert_not_reached("Unknown StartLimitAction.");
2397 }
2398
2399 return -ECANCELED;
2400 }
2401
2402 static int service_start(Unit *u) {
2403 Service *s = SERVICE(u);
2404 int r;
2405
2406 assert(s);
2407
2408 /* We cannot fulfill this request right now, try again later
2409 * please! */
2410 if (s->state == SERVICE_STOP ||
2411 s->state == SERVICE_STOP_SIGTERM ||
2412 s->state == SERVICE_STOP_SIGKILL ||
2413 s->state == SERVICE_STOP_POST ||
2414 s->state == SERVICE_FINAL_SIGTERM ||
2415 s->state == SERVICE_FINAL_SIGKILL)
2416 return -EAGAIN;
2417
2418 /* Already on it! */
2419 if (s->state == SERVICE_START_PRE ||
2420 s->state == SERVICE_START ||
2421 s->state == SERVICE_START_POST)
2422 return 0;
2423
2424 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
2425
2426 /* Make sure we don't enter a busy loop of some kind. */
2427 r = service_start_limit_test(s);
2428 if (r < 0) {
2429 service_notify_sockets_dead(s, true);
2430 return r;
2431 }
2432
2433 s->result = SERVICE_SUCCESS;
2434 s->reload_result = SERVICE_SUCCESS;
2435 s->main_pid_known = false;
2436 s->main_pid_alien = false;
2437 s->forbid_restart = false;
2438
2439 service_enter_start_pre(s);
2440 return 0;
2441 }
2442
2443 static int service_stop(Unit *u) {
2444 Service *s = SERVICE(u);
2445
2446 assert(s);
2447
2448 /* This is a user request, so don't do restarts on this
2449 * shutdown. */
2450 s->forbid_restart = true;
2451
2452 /* Already on it */
2453 if (s->state == SERVICE_STOP ||
2454 s->state == SERVICE_STOP_SIGTERM ||
2455 s->state == SERVICE_STOP_SIGKILL ||
2456 s->state == SERVICE_STOP_POST ||
2457 s->state == SERVICE_FINAL_SIGTERM ||
2458 s->state == SERVICE_FINAL_SIGKILL)
2459 return 0;
2460
2461 /* Don't allow a restart */
2462 if (s->state == SERVICE_AUTO_RESTART) {
2463 service_set_state(s, SERVICE_DEAD);
2464 return 0;
2465 }
2466
2467 /* If there's already something running we go directly into
2468 * kill mode. */
2469 if (s->state == SERVICE_START_PRE ||
2470 s->state == SERVICE_START ||
2471 s->state == SERVICE_START_POST ||
2472 s->state == SERVICE_RELOAD) {
2473 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2474 return 0;
2475 }
2476
2477 assert(s->state == SERVICE_RUNNING ||
2478 s->state == SERVICE_EXITED);
2479
2480 service_enter_stop(s, SERVICE_SUCCESS);
2481 return 0;
2482 }
2483
2484 static int service_reload(Unit *u) {
2485 Service *s = SERVICE(u);
2486
2487 assert(s);
2488
2489 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2490
2491 service_enter_reload(s);
2492 return 0;
2493 }
2494
2495 static bool service_can_reload(Unit *u) {
2496 Service *s = SERVICE(u);
2497
2498 assert(s);
2499
2500 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2501 }
2502
2503 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2504 Service *s = SERVICE(u);
2505
2506 assert(u);
2507 assert(f);
2508 assert(fds);
2509
2510 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2511 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2512 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2513
2514 if (s->control_pid > 0)
2515 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2516
2517 if (s->main_pid_known && s->main_pid > 0)
2518 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2519
2520 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2521
2522 if (s->status_text)
2523 unit_serialize_item(u, f, "status-text", s->status_text);
2524
2525 /* FIXME: There's a minor uncleanliness here: if there are
2526 * multiple commands attached here, we will start from the
2527 * first one again */
2528 if (s->control_command_id >= 0)
2529 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2530
2531 if (s->socket_fd >= 0) {
2532 int copy;
2533
2534 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2535 return copy;
2536
2537 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2538 }
2539
2540 if (s->main_exec_status.pid > 0) {
2541 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2542 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2543 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2544
2545 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2546 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2547 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2548 }
2549 }
2550 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2551 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2552
2553 return 0;
2554 }
2555
2556 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2557 Service *s = SERVICE(u);
2558
2559 assert(u);
2560 assert(key);
2561 assert(value);
2562 assert(fds);
2563
2564 if (streq(key, "state")) {
2565 ServiceState state;
2566
2567 if ((state = service_state_from_string(value)) < 0)
2568 log_debug("Failed to parse state value %s", value);
2569 else
2570 s->deserialized_state = state;
2571 } else if (streq(key, "result")) {
2572 ServiceResult f;
2573
2574 f = service_result_from_string(value);
2575 if (f < 0)
2576 log_debug("Failed to parse result value %s", value);
2577 else if (f != SERVICE_SUCCESS)
2578 s->result = f;
2579
2580 } else if (streq(key, "reload-result")) {
2581 ServiceResult f;
2582
2583 f = service_result_from_string(value);
2584 if (f < 0)
2585 log_debug("Failed to parse reload result value %s", value);
2586 else if (f != SERVICE_SUCCESS)
2587 s->reload_result = f;
2588
2589 } else if (streq(key, "control-pid")) {
2590 pid_t pid;
2591
2592 if (parse_pid(value, &pid) < 0)
2593 log_debug("Failed to parse control-pid value %s", value);
2594 else
2595 s->control_pid = pid;
2596 } else if (streq(key, "main-pid")) {
2597 pid_t pid;
2598
2599 if (parse_pid(value, &pid) < 0)
2600 log_debug("Failed to parse main-pid value %s", value);
2601 else
2602 service_set_main_pid(s, (pid_t) pid);
2603 } else if (streq(key, "main-pid-known")) {
2604 int b;
2605
2606 if ((b = parse_boolean(value)) < 0)
2607 log_debug("Failed to parse main-pid-known value %s", value);
2608 else
2609 s->main_pid_known = b;
2610 } else if (streq(key, "status-text")) {
2611 char *t;
2612
2613 if ((t = strdup(value))) {
2614 free(s->status_text);
2615 s->status_text = t;
2616 }
2617
2618 } else if (streq(key, "control-command")) {
2619 ServiceExecCommand id;
2620
2621 if ((id = service_exec_command_from_string(value)) < 0)
2622 log_debug("Failed to parse exec-command value %s", value);
2623 else {
2624 s->control_command_id = id;
2625 s->control_command = s->exec_command[id];
2626 }
2627 } else if (streq(key, "socket-fd")) {
2628 int fd;
2629
2630 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2631 log_debug("Failed to parse socket-fd value %s", value);
2632 else {
2633
2634 if (s->socket_fd >= 0)
2635 close_nointr_nofail(s->socket_fd);
2636 s->socket_fd = fdset_remove(fds, fd);
2637 }
2638 } else if (streq(key, "main-exec-status-pid")) {
2639 pid_t pid;
2640
2641 if (parse_pid(value, &pid) < 0)
2642 log_debug("Failed to parse main-exec-status-pid value %s", value);
2643 else
2644 s->main_exec_status.pid = pid;
2645 } else if (streq(key, "main-exec-status-code")) {
2646 int i;
2647
2648 if (safe_atoi(value, &i) < 0)
2649 log_debug("Failed to parse main-exec-status-code value %s", value);
2650 else
2651 s->main_exec_status.code = i;
2652 } else if (streq(key, "main-exec-status-status")) {
2653 int i;
2654
2655 if (safe_atoi(value, &i) < 0)
2656 log_debug("Failed to parse main-exec-status-status value %s", value);
2657 else
2658 s->main_exec_status.status = i;
2659 } else if (streq(key, "main-exec-status-start"))
2660 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2661 else if (streq(key, "main-exec-status-exit"))
2662 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2663 else if (streq(key, "watchdog-timestamp"))
2664 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2665 else
2666 log_debug("Unknown serialization key '%s'", key);
2667
2668 return 0;
2669 }
2670
2671 static UnitActiveState service_active_state(Unit *u) {
2672 assert(u);
2673
2674 return state_translation_table[SERVICE(u)->state];
2675 }
2676
2677 static const char *service_sub_state_to_string(Unit *u) {
2678 assert(u);
2679
2680 return service_state_to_string(SERVICE(u)->state);
2681 }
2682
2683 static bool service_check_gc(Unit *u) {
2684 Service *s = SERVICE(u);
2685
2686 assert(s);
2687
2688 /* Never clean up services that still have a process around,
2689 * even if the service is formally dead. */
2690 if (cgroup_good(s) > 0 ||
2691 main_pid_good(s) > 0 ||
2692 control_pid_good(s) > 0)
2693 return true;
2694
2695 #ifdef HAVE_SYSV_COMPAT
2696 if (s->sysv_path)
2697 return true;
2698 #endif
2699
2700 return false;
2701 }
2702
2703 static bool service_check_snapshot(Unit *u) {
2704 Service *s = SERVICE(u);
2705
2706 assert(s);
2707
2708 return !s->got_socket_fd;
2709 }
2710
2711 static int service_retry_pid_file(Service *s) {
2712 int r;
2713
2714 assert(s->pid_file);
2715 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2716
2717 r = service_load_pid_file(s, false);
2718 if (r < 0)
2719 return r;
2720
2721 service_unwatch_pid_file(s);
2722
2723 service_enter_running(s, SERVICE_SUCCESS);
2724 return 0;
2725 }
2726
2727 static int service_watch_pid_file(Service *s) {
2728 int r;
2729
2730 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2731 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2732 if (r < 0)
2733 goto fail;
2734
2735 /* the pidfile might have appeared just before we set the watch */
2736 service_retry_pid_file(s);
2737
2738 return 0;
2739 fail:
2740 log_error("Failed to set a watch for %s's PID file %s: %s",
2741 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2742 service_unwatch_pid_file(s);
2743 return r;
2744 }
2745
2746 static int service_demand_pid_file(Service *s) {
2747 PathSpec *ps;
2748
2749 assert(s->pid_file);
2750 assert(!s->pid_file_pathspec);
2751
2752 ps = new0(PathSpec, 1);
2753 if (!ps)
2754 return -ENOMEM;
2755
2756 ps->path = strdup(s->pid_file);
2757 if (!ps->path) {
2758 free(ps);
2759 return -ENOMEM;
2760 }
2761
2762 path_kill_slashes(ps->path);
2763
2764 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2765 * keep their PID file open all the time. */
2766 ps->type = PATH_MODIFIED;
2767 ps->inotify_fd = -1;
2768
2769 s->pid_file_pathspec = ps;
2770
2771 return service_watch_pid_file(s);
2772 }
2773
2774 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2775 Service *s = SERVICE(u);
2776
2777 assert(s);
2778 assert(fd >= 0);
2779 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2780 assert(s->pid_file_pathspec);
2781 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2782
2783 log_debug("inotify event for %s", u->id);
2784
2785 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2786 goto fail;
2787
2788 if (service_retry_pid_file(s) == 0)
2789 return;
2790
2791 if (service_watch_pid_file(s) < 0)
2792 goto fail;
2793
2794 return;
2795 fail:
2796 service_unwatch_pid_file(s);
2797 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2798 }
2799
2800 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2801 Service *s = SERVICE(u);
2802 ServiceResult f;
2803
2804 assert(s);
2805 assert(pid >= 0);
2806
2807 if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2808 f = SERVICE_SUCCESS;
2809 else if (code == CLD_EXITED)
2810 f = SERVICE_FAILURE_EXIT_CODE;
2811 else if (code == CLD_KILLED)
2812 f = SERVICE_FAILURE_SIGNAL;
2813 else if (code == CLD_DUMPED)
2814 f = SERVICE_FAILURE_CORE_DUMP;
2815 else
2816 assert_not_reached("Unknown code");
2817
2818 if (s->main_pid == pid) {
2819 /* Forking services may occasionally move to a new PID.
2820 * As long as they update the PID file before exiting the old
2821 * PID, they're fine. */
2822 if (service_load_pid_file(s, false) == 0)
2823 return;
2824
2825 s->main_pid = 0;
2826 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2827
2828 /* If this is not a forking service than the main
2829 * process got started and hence we copy the exit
2830 * status so that it is recorded both as main and as
2831 * control process exit status */
2832 if (s->main_command) {
2833 s->main_command->exec_status = s->main_exec_status;
2834
2835 if (s->main_command->ignore)
2836 f = SERVICE_SUCCESS;
2837 }
2838
2839 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2840 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2841
2842 if (f != SERVICE_SUCCESS)
2843 s->result = f;
2844
2845 if (s->main_command &&
2846 s->main_command->command_next &&
2847 f == SERVICE_SUCCESS) {
2848
2849 /* There is another command to *
2850 * execute, so let's do that. */
2851
2852 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2853 service_run_next_main(s);
2854
2855 } else {
2856
2857 /* The service exited, so the service is officially
2858 * gone. */
2859 s->main_command = NULL;
2860
2861 switch (s->state) {
2862
2863 case SERVICE_START_POST:
2864 case SERVICE_RELOAD:
2865 case SERVICE_STOP:
2866 /* Need to wait until the operation is
2867 * done */
2868 break;
2869
2870 case SERVICE_START:
2871 if (s->type == SERVICE_ONESHOT) {
2872 /* This was our main goal, so let's go on */
2873 if (f == SERVICE_SUCCESS)
2874 service_enter_start_post(s);
2875 else
2876 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2877 break;
2878 } else {
2879 assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2880
2881 /* Fall through */
2882 }
2883
2884 case SERVICE_RUNNING:
2885 service_enter_running(s, f);
2886 break;
2887
2888 case SERVICE_STOP_SIGTERM:
2889 case SERVICE_STOP_SIGKILL:
2890
2891 if (!control_pid_good(s))
2892 service_enter_stop_post(s, f);
2893
2894 /* If there is still a control process, wait for that first */
2895 break;
2896
2897 default:
2898 assert_not_reached("Uh, main process died at wrong time.");
2899 }
2900 }
2901
2902 } else if (s->control_pid == pid) {
2903
2904 s->control_pid = 0;
2905
2906 if (s->control_command) {
2907 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2908
2909 if (s->control_command->ignore)
2910 f = SERVICE_SUCCESS;
2911 }
2912
2913 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2914 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2915
2916 if (f != SERVICE_SUCCESS)
2917 s->result = f;
2918
2919 if (s->control_command &&
2920 s->control_command->command_next &&
2921 f == SERVICE_SUCCESS) {
2922
2923 /* There is another command to *
2924 * execute, so let's do that. */
2925
2926 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2927 service_run_next_control(s);
2928
2929 } else {
2930 /* No further commands for this step, so let's
2931 * figure out what to do next */
2932
2933 s->control_command = NULL;
2934 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2935
2936 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2937
2938 switch (s->state) {
2939
2940 case SERVICE_START_PRE:
2941 if (f == SERVICE_SUCCESS)
2942 service_enter_start(s);
2943 else
2944 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2945 break;
2946
2947 case SERVICE_START:
2948 assert(s->type == SERVICE_FORKING);
2949
2950 if (f != SERVICE_SUCCESS) {
2951 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2952 break;
2953 }
2954
2955 if (s->pid_file) {
2956 bool has_start_post;
2957 int r;
2958
2959 /* Let's try to load the pid file here if we can.
2960 * The PID file might actually be created by a START_POST
2961 * script. In that case don't worry if the loading fails. */
2962
2963 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2964 r = service_load_pid_file(s, !has_start_post);
2965 if (!has_start_post && r < 0) {
2966 r = service_demand_pid_file(s);
2967 if (r < 0 || !cgroup_good(s))
2968 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2969 break;
2970 }
2971 } else
2972 service_search_main_pid(s);
2973
2974 service_enter_start_post(s);
2975 break;
2976
2977 case SERVICE_START_POST:
2978 if (f != SERVICE_SUCCESS) {
2979 service_enter_stop(s, f);
2980 break;
2981 }
2982
2983 if (s->pid_file) {
2984 int r;
2985
2986 r = service_load_pid_file(s, true);
2987 if (r < 0) {
2988 r = service_demand_pid_file(s);
2989 if (r < 0 || !cgroup_good(s))
2990 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2991 break;
2992 }
2993 } else
2994 service_search_main_pid(s);
2995
2996 service_enter_running(s, SERVICE_SUCCESS);
2997 break;
2998
2999 case SERVICE_RELOAD:
3000 if (f == SERVICE_SUCCESS) {
3001 service_load_pid_file(s, true);
3002 service_search_main_pid(s);
3003 }
3004
3005 s->reload_result = f;
3006 service_enter_running(s, SERVICE_SUCCESS);
3007 break;
3008
3009 case SERVICE_STOP:
3010 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3011 break;
3012
3013 case SERVICE_STOP_SIGTERM:
3014 case SERVICE_STOP_SIGKILL:
3015 if (main_pid_good(s) <= 0)
3016 service_enter_stop_post(s, f);
3017
3018 /* If there is still a service
3019 * process around, wait until
3020 * that one quit, too */
3021 break;
3022
3023 case SERVICE_STOP_POST:
3024 case SERVICE_FINAL_SIGTERM:
3025 case SERVICE_FINAL_SIGKILL:
3026 service_enter_dead(s, f, true);
3027 break;
3028
3029 default:
3030 assert_not_reached("Uh, control process died at wrong time.");
3031 }
3032 }
3033 }
3034
3035 /* Notify clients about changed exit status */
3036 unit_add_to_dbus_queue(u);
3037 }
3038
3039 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3040 Service *s = SERVICE(u);
3041
3042 assert(s);
3043 assert(elapsed == 1);
3044
3045 if (w == &s->watchdog_watch) {
3046 service_handle_watchdog(s);
3047 return;
3048 }
3049
3050 assert(w == &s->timer_watch);
3051
3052 switch (s->state) {
3053
3054 case SERVICE_START_PRE:
3055 case SERVICE_START:
3056 log_warning("%s operation timed out. Terminating.", u->id);
3057 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3058 break;
3059
3060 case SERVICE_START_POST:
3061 log_warning("%s operation timed out. Stopping.", u->id);
3062 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3063 break;
3064
3065 case SERVICE_RELOAD:
3066 log_warning("%s operation timed out. Stopping.", u->id);
3067 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3068 service_enter_running(s, SERVICE_SUCCESS);
3069 break;
3070
3071 case SERVICE_STOP:
3072 log_warning("%s stopping timed out. Terminating.", u->id);
3073 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3074 break;
3075
3076 case SERVICE_STOP_SIGTERM:
3077 if (s->exec_context.send_sigkill) {
3078 log_warning("%s stopping timed out. Killing.", u->id);
3079 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3080 } else {
3081 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3082 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3083 }
3084
3085 break;
3086
3087 case SERVICE_STOP_SIGKILL:
3088 /* Uh, we sent a SIGKILL and it is still not gone?
3089 * Must be something we cannot kill, so let's just be
3090 * weirded out and continue */
3091
3092 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3093 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3094 break;
3095
3096 case SERVICE_STOP_POST:
3097 log_warning("%s stopping timed out (2). Terminating.", u->id);
3098 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3099 break;
3100
3101 case SERVICE_FINAL_SIGTERM:
3102 if (s->exec_context.send_sigkill) {
3103 log_warning("%s stopping timed out (2). Killing.", u->id);
3104 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3105 } else {
3106 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3107 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3108 }
3109
3110 break;
3111
3112 case SERVICE_FINAL_SIGKILL:
3113 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3114 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3115 break;
3116
3117 case SERVICE_AUTO_RESTART:
3118 log_info("%s holdoff time over, scheduling restart.", u->id);
3119 service_enter_restart(s);
3120 break;
3121
3122 default:
3123 assert_not_reached("Timeout at wrong time.");
3124 }
3125 }
3126
3127 static void service_cgroup_notify_event(Unit *u) {
3128 Service *s = SERVICE(u);
3129
3130 assert(u);
3131
3132 log_debug("%s: cgroup is empty", u->id);
3133
3134 switch (s->state) {
3135
3136 /* Waiting for SIGCHLD is usually more interesting,
3137 * because it includes return codes/signals. Which is
3138 * why we ignore the cgroup events for most cases,
3139 * except when we don't know pid which to expect the
3140 * SIGCHLD for. */
3141
3142 case SERVICE_START:
3143 case SERVICE_START_POST:
3144 /* If we were hoping for the daemon to write its PID file,
3145 * we can give up now. */
3146 if (s->pid_file_pathspec) {
3147 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3148 service_unwatch_pid_file(s);
3149 if (s->state == SERVICE_START)
3150 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3151 else
3152 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3153 }
3154 break;
3155
3156 case SERVICE_RUNNING:
3157 /* service_enter_running() will figure out what to do */
3158 service_enter_running(s, SERVICE_SUCCESS);
3159 break;
3160
3161 case SERVICE_STOP_SIGTERM:
3162 case SERVICE_STOP_SIGKILL:
3163
3164 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3165 service_enter_stop_post(s, SERVICE_SUCCESS);
3166
3167 break;
3168
3169 case SERVICE_FINAL_SIGTERM:
3170 case SERVICE_FINAL_SIGKILL:
3171 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3172 service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3173
3174 break;
3175
3176 default:
3177 ;
3178 }
3179 }
3180
3181 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3182 Service *s = SERVICE(u);
3183 const char *e;
3184
3185 assert(u);
3186
3187 if (s->notify_access == NOTIFY_NONE) {
3188 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3189 u->id, (unsigned long) pid);
3190 return;
3191 }
3192
3193 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3194 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3195 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3196 return;
3197 }
3198
3199 log_debug("%s: Got message", u->id);
3200
3201 /* Interpret MAINPID= */
3202 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3203 (s->state == SERVICE_START ||
3204 s->state == SERVICE_START_POST ||
3205 s->state == SERVICE_RUNNING ||
3206 s->state == SERVICE_RELOAD)) {
3207
3208 if (parse_pid(e + 8, &pid) < 0)
3209 log_warning("Failed to parse notification message %s", e);
3210 else {
3211 log_debug("%s: got %s", u->id, e);
3212 service_set_main_pid(s, pid);
3213 }
3214 }
3215
3216 /* Interpret READY= */
3217 if (s->type == SERVICE_NOTIFY &&
3218 s->state == SERVICE_START &&
3219 strv_find(tags, "READY=1")) {
3220 log_debug("%s: got READY=1", u->id);
3221
3222 service_enter_start_post(s);
3223 }
3224
3225 /* Interpret STATUS= */
3226 e = strv_find_prefix(tags, "STATUS=");
3227 if (e) {
3228 char *t;
3229
3230 if (e[7]) {
3231
3232 if (!utf8_is_valid(e+7)) {
3233 log_warning("Status message in notification is not UTF-8 clean.");
3234 return;
3235 }
3236
3237 t = strdup(e+7);
3238 if (!t) {
3239 log_error("Failed to allocate string.");
3240 return;
3241 }
3242
3243 log_debug("%s: got %s", u->id, e);
3244
3245 free(s->status_text);
3246 s->status_text = t;
3247 } else {
3248 free(s->status_text);
3249 s->status_text = NULL;
3250 }
3251
3252 }
3253 if (strv_find(tags, "WATCHDOG=1")) {
3254 log_debug("%s: got WATCHDOG=1", u->id);
3255 service_reset_watchdog(s);
3256 }
3257
3258 /* Notify clients about changed status or main pid */
3259 unit_add_to_dbus_queue(u);
3260 }
3261
3262 #ifdef HAVE_SYSV_COMPAT
3263
3264 #ifdef TARGET_SUSE
3265 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3266 FILE *f=NULL;
3267 int r;
3268
3269 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3270 r = errno == ENOENT ? 0 : -errno;
3271 goto finish;
3272 }
3273
3274 while (!feof(f)) {
3275 char l[LINE_MAX], *t;
3276 char **parsed = NULL;
3277
3278 if (!fgets(l, sizeof(l), f)) {
3279 if (feof(f))
3280 break;
3281
3282 r = -errno;
3283 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3284 goto finish;
3285 }
3286
3287 t = strstrip(l);
3288 if (*t != '$' && *t != '<')
3289 continue;
3290
3291 parsed = strv_split(t,WHITESPACE);
3292 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3293 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3294 char *facility;
3295 Unit *u;
3296 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3297 continue;
3298 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3299 UnitDependency e;
3300 char *dep = NULL, *name, **j;
3301
3302 STRV_FOREACH (j, parsed+1) {
3303 if (*j[0]=='+') {
3304 e = UNIT_WANTS;
3305 name = *j+1;
3306 }
3307 else {
3308 e = UNIT_REQUIRES;
3309 name = *j;
3310 }
3311 if (sysv_translate_facility(name, NULL, &dep) < 0)
3312 continue;
3313
3314 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3315 free(dep);
3316 }
3317 }
3318 free(facility);
3319 }
3320 strv_free(parsed);
3321 }
3322 finish:
3323 if (f)
3324 fclose(f);
3325
3326 }
3327 #endif
3328
3329 static int service_enumerate(Manager *m) {
3330 char **p;
3331 unsigned i;
3332 DIR *d = NULL;
3333 char *path = NULL, *fpath = NULL, *name = NULL;
3334 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3335 Unit *service;
3336 Iterator j;
3337 int r;
3338
3339 assert(m);
3340
3341 if (m->running_as != MANAGER_SYSTEM)
3342 return 0;
3343
3344 zero(runlevel_services);
3345
3346 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3347 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3348 struct dirent *de;
3349
3350 free(path);
3351 path = join(*p, "/", rcnd_table[i].path, NULL);
3352 if (!path) {
3353 r = -ENOMEM;
3354 goto finish;
3355 }
3356
3357 if (d)
3358 closedir(d);
3359
3360 if (!(d = opendir(path))) {
3361 if (errno != ENOENT)
3362 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3363
3364 continue;
3365 }
3366
3367 while ((de = readdir(d))) {
3368 int a, b;
3369
3370 if (ignore_file(de->d_name))
3371 continue;
3372
3373 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3374 continue;
3375
3376 if (strlen(de->d_name) < 4)
3377 continue;
3378
3379 a = undecchar(de->d_name[1]);
3380 b = undecchar(de->d_name[2]);
3381
3382 if (a < 0 || b < 0)
3383 continue;
3384
3385 free(fpath);
3386 fpath = join(path, "/", de->d_name, NULL);
3387 if (!fpath) {
3388 r = -ENOMEM;
3389 goto finish;
3390 }
3391
3392 if (access(fpath, X_OK) < 0) {
3393
3394 if (errno != ENOENT)
3395 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3396
3397 continue;
3398 }
3399
3400 free(name);
3401 if (!(name = sysv_translate_name(de->d_name + 3))) {
3402 r = -ENOMEM;
3403 goto finish;
3404 }
3405
3406 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3407 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3408 continue;
3409 }
3410
3411 if (de->d_name[0] == 'S') {
3412
3413 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3414 SERVICE(service)->sysv_start_priority_from_rcnd =
3415 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3416
3417 SERVICE(service)->sysv_enabled = true;
3418 }
3419
3420 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3421 goto finish;
3422
3423 if ((r = set_put(runlevel_services[i], service)) < 0)
3424 goto finish;
3425
3426 } else if (de->d_name[0] == 'K' &&
3427 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3428 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3429
3430 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3431 goto finish;
3432
3433 if ((r = set_put(shutdown_services, service)) < 0)
3434 goto finish;
3435 }
3436 }
3437 }
3438
3439 /* Now we loaded all stubs and are aware of the lowest
3440 start-up priority for all services, not let's actually load
3441 the services, this will also tell us which services are
3442 actually native now */
3443 manager_dispatch_load_queue(m);
3444
3445 /* If this is a native service, rely on native ways to pull in
3446 * a service, don't pull it in via sysv rcN.d links. */
3447 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3448 SET_FOREACH(service, runlevel_services[i], j) {
3449 service = unit_follow_merge(service);
3450
3451 if (service->fragment_path)
3452 continue;
3453
3454 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3455 goto finish;
3456 }
3457
3458 /* We honour K links only for halt/reboot. For the normal
3459 * runlevels we assume the stop jobs will be implicitly added
3460 * by the core logic. Also, we don't really distinguish here
3461 * between the runlevels 0 and 6 and just add them to the
3462 * special shutdown target. On SUSE the boot.d/ runlevel is
3463 * also used for shutdown, so we add links for that too to the
3464 * shutdown target.*/
3465 SET_FOREACH(service, shutdown_services, j) {
3466 service = unit_follow_merge(service);
3467
3468 if (service->fragment_path)
3469 continue;
3470
3471 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3472 goto finish;
3473 }
3474
3475 r = 0;
3476
3477 #ifdef TARGET_SUSE
3478 sysv_facility_in_insserv_conf (m);
3479 #endif
3480
3481 finish:
3482 free(path);
3483 free(fpath);
3484 free(name);
3485
3486 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3487 set_free(runlevel_services[i]);
3488 set_free(shutdown_services);
3489
3490 if (d)
3491 closedir(d);
3492
3493 return r;
3494 }
3495 #endif
3496
3497 static void service_bus_name_owner_change(
3498 Unit *u,
3499 const char *name,
3500 const char *old_owner,
3501 const char *new_owner) {
3502
3503 Service *s = SERVICE(u);
3504
3505 assert(s);
3506 assert(name);
3507
3508 assert(streq(s->bus_name, name));
3509 assert(old_owner || new_owner);
3510
3511 if (old_owner && new_owner)
3512 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3513 else if (old_owner)
3514 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3515 else
3516 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3517
3518 s->bus_name_good = !!new_owner;
3519
3520 if (s->type == SERVICE_DBUS) {
3521
3522 /* service_enter_running() will figure out what to
3523 * do */
3524 if (s->state == SERVICE_RUNNING)
3525 service_enter_running(s, SERVICE_SUCCESS);
3526 else if (s->state == SERVICE_START && new_owner)
3527 service_enter_start_post(s);
3528
3529 } else if (new_owner &&
3530 s->main_pid <= 0 &&
3531 (s->state == SERVICE_START ||
3532 s->state == SERVICE_START_POST ||
3533 s->state == SERVICE_RUNNING ||
3534 s->state == SERVICE_RELOAD)) {
3535
3536 /* Try to acquire PID from bus service */
3537 log_debug("Trying to acquire PID from D-Bus name...");
3538
3539 bus_query_pid(u->manager, name);
3540 }
3541 }
3542
3543 static void service_bus_query_pid_done(
3544 Unit *u,
3545 const char *name,
3546 pid_t pid) {
3547
3548 Service *s = SERVICE(u);
3549
3550 assert(s);
3551 assert(name);
3552
3553 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3554
3555 if (s->main_pid <= 0 &&
3556 (s->state == SERVICE_START ||
3557 s->state == SERVICE_START_POST ||
3558 s->state == SERVICE_RUNNING ||
3559 s->state == SERVICE_RELOAD))
3560 service_set_main_pid(s, pid);
3561 }
3562
3563 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3564
3565 assert(s);
3566 assert(fd >= 0);
3567
3568 /* This is called by the socket code when instantiating a new
3569 * service for a stream socket and the socket needs to be
3570 * configured. */
3571
3572 if (UNIT(s)->load_state != UNIT_LOADED)
3573 return -EINVAL;
3574
3575 if (s->socket_fd >= 0)
3576 return -EBUSY;
3577
3578 if (s->state != SERVICE_DEAD)
3579 return -EAGAIN;
3580
3581 s->socket_fd = fd;
3582 s->got_socket_fd = true;
3583
3584 unit_ref_set(&s->accept_socket, UNIT(sock));
3585
3586 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3587 }
3588
3589 static void service_reset_failed(Unit *u) {
3590 Service *s = SERVICE(u);
3591
3592 assert(s);
3593
3594 if (s->state == SERVICE_FAILED)
3595 service_set_state(s, SERVICE_DEAD);
3596
3597 s->result = SERVICE_SUCCESS;
3598 s->reload_result = SERVICE_SUCCESS;
3599 }
3600
3601 static bool service_need_daemon_reload(Unit *u) {
3602 Service *s = SERVICE(u);
3603
3604 assert(s);
3605
3606 #ifdef HAVE_SYSV_COMPAT
3607 if (s->sysv_path) {
3608 struct stat st;
3609
3610 zero(st);
3611 if (stat(s->sysv_path, &st) < 0)
3612 /* What, cannot access this anymore? */
3613 return true;
3614
3615 if (s->sysv_mtime > 0 &&
3616 timespec_load(&st.st_mtim) != s->sysv_mtime)
3617 return true;
3618 }
3619 #endif
3620
3621 return false;
3622 }
3623
3624 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3625 Service *s = SERVICE(u);
3626 int r = 0;
3627 Set *pid_set = NULL;
3628
3629 assert(s);
3630
3631 if (s->main_pid <= 0 && who == KILL_MAIN) {
3632 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3633 return -ESRCH;
3634 }
3635
3636 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3637 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3638 return -ESRCH;
3639 }
3640
3641 if (who == KILL_CONTROL || who == KILL_ALL)
3642 if (s->control_pid > 0)
3643 if (kill(s->control_pid, signo) < 0)
3644 r = -errno;
3645
3646 if (who == KILL_MAIN || who == KILL_ALL)
3647 if (s->main_pid > 0)
3648 if (kill(s->main_pid, signo) < 0)
3649 r = -errno;
3650
3651 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3652 int q;
3653
3654 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3655 return -ENOMEM;
3656
3657 /* Exclude the control/main pid from being killed via the cgroup */
3658 if (s->control_pid > 0)
3659 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3660 r = q;
3661 goto finish;
3662 }
3663
3664 if (s->main_pid > 0)
3665 if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3666 r = q;
3667 goto finish;
3668 }
3669 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, pid_set, NULL);
3670 if (q < 0)
3671 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3672 r = q;
3673 }
3674
3675 finish:
3676 if (pid_set)
3677 set_free(pid_set);
3678
3679 return r;
3680 }
3681
3682 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3683 [SERVICE_DEAD] = "dead",
3684 [SERVICE_START_PRE] = "start-pre",
3685 [SERVICE_START] = "start",
3686 [SERVICE_START_POST] = "start-post",
3687 [SERVICE_RUNNING] = "running",
3688 [SERVICE_EXITED] = "exited",
3689 [SERVICE_RELOAD] = "reload",
3690 [SERVICE_STOP] = "stop",
3691 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3692 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3693 [SERVICE_STOP_POST] = "stop-post",
3694 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3695 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3696 [SERVICE_FAILED] = "failed",
3697 [SERVICE_AUTO_RESTART] = "auto-restart",
3698 };
3699
3700 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3701
3702 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3703 [SERVICE_RESTART_NO] = "no",
3704 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3705 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3706 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3707 [SERVICE_RESTART_ALWAYS] = "always"
3708 };
3709
3710 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3711
3712 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3713 [SERVICE_SIMPLE] = "simple",
3714 [SERVICE_FORKING] = "forking",
3715 [SERVICE_ONESHOT] = "oneshot",
3716 [SERVICE_DBUS] = "dbus",
3717 [SERVICE_NOTIFY] = "notify"
3718 };
3719
3720 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3721
3722 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3723 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3724 [SERVICE_EXEC_START] = "ExecStart",
3725 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3726 [SERVICE_EXEC_RELOAD] = "ExecReload",
3727 [SERVICE_EXEC_STOP] = "ExecStop",
3728 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3729 };
3730
3731 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3732
3733 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3734 [NOTIFY_NONE] = "none",
3735 [NOTIFY_MAIN] = "main",
3736 [NOTIFY_ALL] = "all"
3737 };
3738
3739 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3740
3741 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3742 [SERVICE_SUCCESS] = "success",
3743 [SERVICE_FAILURE_RESOURCES] = "resources",
3744 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3745 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3746 [SERVICE_FAILURE_SIGNAL] = "signal",
3747 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3748 [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3749 };
3750
3751 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3752
3753 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3754 [SERVICE_START_LIMIT_NONE] = "none",
3755 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3756 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3757 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3758 };
3759 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3760
3761 const UnitVTable service_vtable = {
3762 .suffix = ".service",
3763 .object_size = sizeof(Service),
3764 .sections =
3765 "Unit\0"
3766 "Service\0"
3767 "Install\0",
3768 .show_status = true,
3769
3770 .init = service_init,
3771 .done = service_done,
3772 .load = service_load,
3773
3774 .coldplug = service_coldplug,
3775
3776 .dump = service_dump,
3777
3778 .start = service_start,
3779 .stop = service_stop,
3780 .reload = service_reload,
3781
3782 .can_reload = service_can_reload,
3783
3784 .kill = service_kill,
3785
3786 .serialize = service_serialize,
3787 .deserialize_item = service_deserialize_item,
3788
3789 .active_state = service_active_state,
3790 .sub_state_to_string = service_sub_state_to_string,
3791
3792 .check_gc = service_check_gc,
3793 .check_snapshot = service_check_snapshot,
3794
3795 .sigchld_event = service_sigchld_event,
3796 .timer_event = service_timer_event,
3797 .fd_event = service_fd_event,
3798
3799 .reset_failed = service_reset_failed,
3800
3801 .need_daemon_reload = service_need_daemon_reload,
3802
3803 .cgroup_notify_empty = service_cgroup_notify_event,
3804 .notify_message = service_notify_message,
3805
3806 .bus_name_owner_change = service_bus_name_owner_change,
3807 .bus_query_pid_done = service_bus_query_pid_done,
3808
3809 .bus_interface = "org.freedesktop.systemd1.Service",
3810 .bus_message_handler = bus_service_message_handler,
3811 .bus_invalidating_properties = bus_service_invalidating_properties,
3812
3813 #ifdef HAVE_SYSV_COMPAT
3814 .enumerate = service_enumerate
3815 #endif
3816 };
Unnamed repository; edit this file 'description' to name the repository.