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