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