chiark / gitweb /
cgroup: if we do a cgroup operation then do something on all supported controllers
[elogind.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 "dbus-common.h"
40 #include "exit-status.h"
41 #include "def.h"
42 #include "path-util.h"
43 #include "util.h"
44 #include "utf8.h"
45 #include "env-util.h"
46 #include "fileio.h"
47
48 #ifdef HAVE_SYSV_COMPAT
49
50 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
51
52 typedef enum RunlevelType {
53         RUNLEVEL_UP,
54         RUNLEVEL_DOWN
55 } RunlevelType;
56
57 static const struct {
58         const char *path;
59         const char *target;
60         const RunlevelType type;
61 } rcnd_table[] = {
62         /* Standard SysV runlevels for start-up */
63         { "rc1.d",  SPECIAL_RESCUE_TARGET,    RUNLEVEL_UP },
64         { "rc2.d",  SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
65         { "rc3.d",  SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
66         { "rc4.d",  SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
67         { "rc5.d",  SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
68
69         /* Standard SysV runlevels for shutdown */
70         { "rc0.d",  SPECIAL_POWEROFF_TARGET,  RUNLEVEL_DOWN },
71         { "rc6.d",  SPECIAL_REBOOT_TARGET,    RUNLEVEL_DOWN }
72
73         /* Note that the order here matters, as we read the
74            directories in this order, and we want to make sure that
75            sysv_start_priority is known when we first load the
76            unit. And that value we only know from S links. Hence
77            UP must be read before DOWN */
78 };
79
80 #define RUNLEVELS_UP "12345"
81 #endif
82
83 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
84         [SERVICE_DEAD] = UNIT_INACTIVE,
85         [SERVICE_START_PRE] = UNIT_ACTIVATING,
86         [SERVICE_START] = UNIT_ACTIVATING,
87         [SERVICE_START_POST] = UNIT_ACTIVATING,
88         [SERVICE_RUNNING] = UNIT_ACTIVE,
89         [SERVICE_EXITED] = UNIT_ACTIVE,
90         [SERVICE_RELOAD] = UNIT_RELOADING,
91         [SERVICE_STOP] = UNIT_DEACTIVATING,
92         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
93         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
94         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
95         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
96         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
97         [SERVICE_FAILED] = UNIT_FAILED,
98         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
99 };
100
101 /* For Type=idle we never want to delay any other jobs, hence we
102  * consider idle jobs active as soon as we start working on them */
103 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
104         [SERVICE_DEAD] = UNIT_INACTIVE,
105         [SERVICE_START_PRE] = UNIT_ACTIVE,
106         [SERVICE_START] = UNIT_ACTIVE,
107         [SERVICE_START_POST] = UNIT_ACTIVE,
108         [SERVICE_RUNNING] = UNIT_ACTIVE,
109         [SERVICE_EXITED] = UNIT_ACTIVE,
110         [SERVICE_RELOAD] = UNIT_RELOADING,
111         [SERVICE_STOP] = UNIT_DEACTIVATING,
112         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
113         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
114         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
115         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
116         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
117         [SERVICE_FAILED] = UNIT_FAILED,
118         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
119 };
120
121 static void service_init(Unit *u) {
122         Service *s = SERVICE(u);
123
124         assert(u);
125         assert(u->load_state == UNIT_STUB);
126
127         s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
128         s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
129         s->restart_usec = DEFAULT_RESTART_USEC;
130         s->type = _SERVICE_TYPE_INVALID;
131
132         watch_init(&s->watchdog_watch);
133         watch_init(&s->timer_watch);
134
135 #ifdef HAVE_SYSV_COMPAT
136         s->sysv_start_priority = -1;
137         s->sysv_start_priority_from_rcnd = -1;
138 #endif
139         s->socket_fd = -1;
140         s->guess_main_pid = true;
141
142         exec_context_init(&s->exec_context);
143         kill_context_init(&s->kill_context);
144         cgroup_context_init(&s->cgroup_context);
145
146         RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
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, UNIT(s));
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         service_unwatch_main_pid(s);
195
196         s->main_pid = pid;
197         s->main_pid_known = true;
198
199         if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
200                 log_warning_unit(UNIT(s)->id,
201                                  "%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
202                                  UNIT(s)->id, (unsigned long) pid);
203
204                 s->main_pid_alien = true;
205         } else
206                 s->main_pid_alien = false;
207
208         exec_status_start(&s->main_exec_status, pid);
209
210         return 0;
211 }
212
213 static void service_close_socket_fd(Service *s) {
214         assert(s);
215
216         if (s->socket_fd < 0)
217                 return;
218
219         close_nointr_nofail(s->socket_fd);
220         s->socket_fd = -1;
221 }
222
223 static void service_connection_unref(Service *s) {
224         assert(s);
225
226         if (!UNIT_ISSET(s->accept_socket))
227                 return;
228
229         socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
230         unit_ref_unset(&s->accept_socket);
231 }
232
233 static void service_stop_watchdog(Service *s) {
234         assert(s);
235
236         unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
237         s->watchdog_timestamp.realtime = 0;
238         s->watchdog_timestamp.monotonic = 0;
239 }
240
241 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
242
243 static void service_handle_watchdog(Service *s) {
244         usec_t offset;
245         int r;
246
247         assert(s);
248
249         if (s->watchdog_usec == 0)
250                 return;
251
252         offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
253         if (offset >= s->watchdog_usec) {
254                 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
255                 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_WATCHDOG);
256                 return;
257         }
258
259         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->watchdog_usec - offset, &s->watchdog_watch);
260         if (r < 0)
261                 log_warning_unit(UNIT(s)->id,
262                                  "%s failed to install watchdog timer: %s",
263                                  UNIT(s)->id, strerror(-r));
264 }
265
266 static void service_reset_watchdog(Service *s) {
267         assert(s);
268
269         dual_timestamp_get(&s->watchdog_timestamp);
270         service_handle_watchdog(s);
271 }
272
273 static void service_done(Unit *u) {
274         Service *s = SERVICE(u);
275
276         assert(s);
277
278         free(s->pid_file);
279         s->pid_file = NULL;
280
281 #ifdef HAVE_SYSV_COMPAT
282         free(s->sysv_runlevels);
283         s->sysv_runlevels = NULL;
284 #endif
285
286         free(s->status_text);
287         s->status_text = NULL;
288
289         cgroup_context_done(&s->cgroup_context);
290         exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
291         exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
292         s->control_command = NULL;
293         s->main_command = NULL;
294
295         set_free(s->restart_ignore_status.code);
296         s->restart_ignore_status.code = NULL;
297         set_free(s->restart_ignore_status.signal);
298         s->restart_ignore_status.signal = NULL;
299
300         set_free(s->success_status.code);
301         s->success_status.code = NULL;
302         set_free(s->success_status.signal);
303         s->success_status.signal = NULL;
304
305         /* This will leak a process, but at least no memory or any of
306          * our resources */
307         service_unwatch_main_pid(s);
308         service_unwatch_control_pid(s);
309         service_unwatch_pid_file(s);
310
311         if (s->bus_name)  {
312                 unit_unwatch_bus_name(u, s->bus_name);
313                 free(s->bus_name);
314                 s->bus_name = NULL;
315         }
316
317         service_close_socket_fd(s);
318         service_connection_unref(s);
319
320         unit_ref_unset(&s->accept_socket);
321
322         service_stop_watchdog(s);
323
324         unit_unwatch_timer(u, &s->timer_watch);
325 }
326
327 #ifdef HAVE_SYSV_COMPAT
328 static char *sysv_translate_name(const char *name) {
329         char *r;
330
331         r = new(char, strlen(name) + sizeof(".service"));
332         if (!r)
333                 return NULL;
334
335         if (endswith(name, ".sh"))
336                 /* Drop .sh suffix */
337                 strcpy(stpcpy(r, name) - 3, ".service");
338         else
339                 /* Normal init script name */
340                 strcpy(stpcpy(r, name), ".service");
341
342         return r;
343 }
344
345 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
346
347         /* We silently ignore the $ prefix here. According to the LSB
348          * spec it simply indicates whether something is a
349          * standardized name or a distribution-specific one. Since we
350          * just follow what already exists and do not introduce new
351          * uses or names we don't care who introduced a new name. */
352
353         static const char * const table[] = {
354                 /* LSB defined facilities */
355                 "local_fs",             NULL,
356                 "network",              SPECIAL_NETWORK_TARGET,
357                 "named",                SPECIAL_NSS_LOOKUP_TARGET,
358                 "portmap",              SPECIAL_RPCBIND_TARGET,
359                 "remote_fs",            SPECIAL_REMOTE_FS_TARGET,
360                 "syslog",               NULL,
361                 "time",                 SPECIAL_TIME_SYNC_TARGET,
362         };
363
364         unsigned i;
365         char *r;
366         const char *n;
367
368         assert(name);
369         assert(_r);
370
371         n = *name == '$' ? name + 1 : name;
372
373         for (i = 0; i < ELEMENTSOF(table); i += 2) {
374
375                 if (!streq(table[i], n))
376                         continue;
377
378                 if (!table[i+1])
379                         return 0;
380
381                 r = strdup(table[i+1]);
382                 if (!r)
383                         return log_oom();
384
385                 goto finish;
386         }
387
388         /* If we don't know this name, fallback heuristics to figure
389          * out whether something is a target or a service alias. */
390
391         if (*name == '$') {
392                 if (!unit_prefix_is_valid(n))
393                         return -EINVAL;
394
395                 /* Facilities starting with $ are most likely targets */
396                 r = unit_name_build(n, NULL, ".target");
397         } else if (filename && streq(name, filename))
398                 /* Names equaling the file name of the services are redundant */
399                 return 0;
400         else
401                 /* Everything else we assume to be normal service names */
402                 r = sysv_translate_name(n);
403
404         if (!r)
405                 return -ENOMEM;
406
407 finish:
408         *_r = r;
409
410         return 1;
411 }
412
413 static int sysv_fix_order(Service *s) {
414         Unit *other;
415         int r;
416
417         assert(s);
418
419         if (s->sysv_start_priority < 0)
420                 return 0;
421
422         /* For each pair of services where at least one lacks a LSB
423          * header, we use the start priority value to order things. */
424
425         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
426                 Service *t;
427                 UnitDependency d;
428                 bool special_s, special_t;
429
430                 t = SERVICE(other);
431
432                 if (s == t)
433                         continue;
434
435                 if (UNIT(t)->load_state != UNIT_LOADED)
436                         continue;
437
438                 if (t->sysv_start_priority < 0)
439                         continue;
440
441                 /* If both units have modern headers we don't care
442                  * about the priorities */
443                 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
444                     (UNIT(t)->fragment_path || t->sysv_has_lsb))
445                         continue;
446
447                 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
448                 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
449
450                 if (special_t && !special_s)
451                         d = UNIT_AFTER;
452                 else if (special_s && !special_t)
453                         d = UNIT_BEFORE;
454                 else if (t->sysv_start_priority < s->sysv_start_priority)
455                         d = UNIT_AFTER;
456                 else if (t->sysv_start_priority > s->sysv_start_priority)
457                         d = UNIT_BEFORE;
458                 else
459                         continue;
460
461                 /* FIXME: Maybe we should compare the name here lexicographically? */
462
463                 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
464                         return r;
465         }
466
467         return 0;
468 }
469
470 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
471         ExecCommand *c;
472
473         if (!(c = new0(ExecCommand, 1)))
474                 return NULL;
475
476         if (!(c->path = strdup(path))) {
477                 free(c);
478                 return NULL;
479         }
480
481         if (!(c->argv = strv_new(path, arg1, NULL))) {
482                 free(c->path);
483                 free(c);
484                 return NULL;
485         }
486
487         return c;
488 }
489
490 static int sysv_exec_commands(Service *s, const bool supports_reload) {
491         ExecCommand *c;
492
493         assert(s);
494         assert(s->is_sysv);
495         assert(UNIT(s)->source_path);
496
497         c = exec_command_new(UNIT(s)->source_path, "start");
498         if (!c)
499                 return -ENOMEM;
500         exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
501
502         c = exec_command_new(UNIT(s)->source_path, "stop");
503         if (!c)
504                 return -ENOMEM;
505         exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
506
507         if (supports_reload) {
508                 c = exec_command_new(UNIT(s)->source_path, "reload");
509                 if (!c)
510                         return -ENOMEM;
511                 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
512         }
513
514         return 0;
515 }
516
517 static bool usage_contains_reload(const char *line) {
518         return (strcasestr(line, "{reload|") ||
519                 strcasestr(line, "{reload}") ||
520                 strcasestr(line, "{reload\"") ||
521                 strcasestr(line, "|reload|") ||
522                 strcasestr(line, "|reload}") ||
523                 strcasestr(line, "|reload\""));
524 }
525
526 static int service_load_sysv_path(Service *s, const char *path) {
527         FILE *f;
528         Unit *u;
529         unsigned line = 0;
530         int r;
531         enum {
532                 NORMAL,
533                 DESCRIPTION,
534                 LSB,
535                 LSB_DESCRIPTION,
536                 USAGE_CONTINUATION
537         } state = NORMAL;
538         char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
539         struct stat st;
540         bool supports_reload = false;
541
542         assert(s);
543         assert(path);
544
545         u = UNIT(s);
546
547         f = fopen(path, "re");
548         if (!f) {
549                 r = errno == ENOENT ? 0 : -errno;
550                 goto finish;
551         }
552
553         if (fstat(fileno(f), &st) < 0) {
554                 r = -errno;
555                 goto finish;
556         }
557
558         free(u->source_path);
559         u->source_path = strdup(path);
560         if (!u->source_path) {
561                 r = -ENOMEM;
562                 goto finish;
563         }
564         u->source_mtime = timespec_load(&st.st_mtim);
565
566         if (null_or_empty(&st)) {
567                 u->load_state = UNIT_MASKED;
568                 r = 0;
569                 goto finish;
570         }
571
572         s->is_sysv = true;
573
574         while (!feof(f)) {
575                 char l[LINE_MAX], *t;
576
577                 if (!fgets(l, sizeof(l), f)) {
578                         if (feof(f))
579                                 break;
580
581                         r = -errno;
582                         log_error_unit(u->id,
583                                        "Failed to read configuration file '%s': %s",
584                                        path, strerror(-r));
585                         goto finish;
586                 }
587
588                 line++;
589
590                 t = strstrip(l);
591                 if (*t != '#') {
592                         /* Try to figure out whether this init script supports
593                          * the reload operation. This heuristic looks for
594                          * "Usage" lines which include the reload option. */
595                         if ( state == USAGE_CONTINUATION ||
596                             (state == NORMAL && strcasestr(t, "usage"))) {
597                                 if (usage_contains_reload(t)) {
598                                         supports_reload = true;
599                                         state = NORMAL;
600                                 } else if (t[strlen(t)-1] == '\\')
601                                         state = USAGE_CONTINUATION;
602                                 else
603                                         state = NORMAL;
604                         }
605
606                         continue;
607                 }
608
609                 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
610                         state = LSB;
611                         s->sysv_has_lsb = true;
612                         continue;
613                 }
614
615                 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
616                         state = NORMAL;
617                         continue;
618                 }
619
620                 t++;
621                 t += strspn(t, WHITESPACE);
622
623                 if (state == NORMAL) {
624
625                         /* Try to parse Red Hat style chkconfig headers */
626
627                         if (startswith_no_case(t, "chkconfig:")) {
628                                 int start_priority;
629                                 char runlevels[16], *k;
630
631                                 state = NORMAL;
632
633                                 if (sscanf(t+10, "%15s %i %*i",
634                                            runlevels,
635                                            &start_priority) != 2) {
636
637                                         log_warning_unit(u->id,
638                                                          "[%s:%u] Failed to parse chkconfig line. Ignoring.",
639                                                          path, line);
640                                         continue;
641                                 }
642
643                                 /* A start priority gathered from the
644                                  * symlink farms is preferred over the
645                                  * data from the LSB header. */
646                                 if (start_priority < 0 || start_priority > 99)
647                                         log_warning_unit(u->id,
648                                                          "[%s:%u] Start priority out of range. Ignoring.",
649                                                          path, line);
650                                 else
651                                         s->sysv_start_priority = start_priority;
652
653                                 char_array_0(runlevels);
654                                 k = delete_chars(runlevels, WHITESPACE "-");
655
656                                 if (k[0]) {
657                                         char *d;
658
659                                         if (!(d = strdup(k))) {
660                                                 r = -ENOMEM;
661                                                 goto finish;
662                                         }
663
664                                         free(s->sysv_runlevels);
665                                         s->sysv_runlevels = d;
666                                 }
667
668                         } else if (startswith_no_case(t, "description:")) {
669
670                                 size_t k = strlen(t);
671                                 char *d;
672                                 const char *j;
673
674                                 if (t[k-1] == '\\') {
675                                         state = DESCRIPTION;
676                                         t[k-1] = 0;
677                                 }
678
679                                 if ((j = strstrip(t+12)) && *j) {
680                                         if (!(d = strdup(j))) {
681                                                 r = -ENOMEM;
682                                                 goto finish;
683                                         }
684                                 } else
685                                         d = NULL;
686
687                                 free(chkconfig_description);
688                                 chkconfig_description = d;
689
690                         } else if (startswith_no_case(t, "pidfile:")) {
691
692                                 char *fn;
693
694                                 state = NORMAL;
695
696                                 fn = strstrip(t+8);
697                                 if (!path_is_absolute(fn)) {
698                                         log_warning_unit(u->id,
699                                                          "[%s:%u] PID file not absolute. Ignoring.",
700                                                          path, line);
701                                         continue;
702                                 }
703
704                                 if (!(fn = strdup(fn))) {
705                                         r = -ENOMEM;
706                                         goto finish;
707                                 }
708
709                                 free(s->pid_file);
710                                 s->pid_file = fn;
711                         }
712
713                 } else if (state == DESCRIPTION) {
714
715                         /* Try to parse Red Hat style description
716                          * continuation */
717
718                         size_t k = strlen(t);
719                         char *j;
720
721                         if (t[k-1] == '\\')
722                                 t[k-1] = 0;
723                         else
724                                 state = NORMAL;
725
726                         if ((j = strstrip(t)) && *j) {
727                                 char *d = NULL;
728
729                                 if (chkconfig_description)
730                                         d = strjoin(chkconfig_description, " ", j, NULL);
731                                 else
732                                         d = strdup(j);
733
734                                 if (!d) {
735                                         r = -ENOMEM;
736                                         goto finish;
737                                 }
738
739                                 free(chkconfig_description);
740                                 chkconfig_description = d;
741                         }
742
743                 } else if (state == LSB || state == LSB_DESCRIPTION) {
744
745                         if (startswith_no_case(t, "Provides:")) {
746                                 char *i, *w;
747                                 size_t z;
748
749                                 state = LSB;
750
751                                 FOREACH_WORD_QUOTED(w, z, t+9, i) {
752                                         char *n, *m;
753
754                                         if (!(n = strndup(w, z))) {
755                                                 r = -ENOMEM;
756                                                 goto finish;
757                                         }
758
759                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
760                                         free(n);
761
762                                         if (r < 0)
763                                                 goto finish;
764
765                                         if (r == 0)
766                                                 continue;
767
768                                         if (unit_name_to_type(m) == UNIT_SERVICE)
769                                                 r = unit_merge_by_name(u, m);
770                                         else
771                                                 /* NB: SysV targets
772                                                  * which are provided
773                                                  * by a service are
774                                                  * pulled in by the
775                                                  * services, as an
776                                                  * indication that the
777                                                  * generic service is
778                                                  * now available. This
779                                                  * is strictly
780                                                  * one-way. The
781                                                  * targets do NOT pull
782                                                  * in the SysV
783                                                  * services! */
784                                                 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
785
786                                         if (r < 0)
787                                                 log_error_unit(u->id,
788                                                                "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
789                                                                path, line, m, strerror(-r));
790
791                                         free(m);
792                                 }
793
794                         } else if (startswith_no_case(t, "Required-Start:") ||
795                                    startswith_no_case(t, "Should-Start:") ||
796                                    startswith_no_case(t, "X-Start-Before:") ||
797                                    startswith_no_case(t, "X-Start-After:")) {
798                                 char *i, *w;
799                                 size_t z;
800
801                                 state = LSB;
802
803                                 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
804                                         char *n, *m;
805
806                                         if (!(n = strndup(w, z))) {
807                                                 r = -ENOMEM;
808                                                 goto finish;
809                                         }
810
811                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
812                                         if (r < 0) {
813                                                 log_error_unit(u->id,
814                                                                "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
815                                                                path, line, n, strerror(-r));
816                                                 free(n);
817                                                 continue;
818                                         }
819
820                                         free(n);
821
822                                         if (r == 0)
823                                                 continue;
824
825                                         r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
826
827                                         if (r < 0)
828                                                 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
829                                                                path, line, m, strerror(-r));
830
831                                         free(m);
832                                 }
833                         } else if (startswith_no_case(t, "Default-Start:")) {
834                                 char *k, *d;
835
836                                 state = LSB;
837
838                                 k = delete_chars(t+14, WHITESPACE "-");
839
840                                 if (k[0] != 0) {
841                                         if (!(d = strdup(k))) {
842                                                 r = -ENOMEM;
843                                                 goto finish;
844                                         }
845
846                                         free(s->sysv_runlevels);
847                                         s->sysv_runlevels = d;
848                                 }
849
850                         } else if (startswith_no_case(t, "Description:")) {
851                                 char *d, *j;
852
853                                 state = LSB_DESCRIPTION;
854
855                                 if ((j = strstrip(t+12)) && *j) {
856                                         if (!(d = strdup(j))) {
857                                                 r = -ENOMEM;
858                                                 goto finish;
859                                         }
860                                 } else
861                                         d = NULL;
862
863                                 free(long_description);
864                                 long_description = d;
865
866                         } else if (startswith_no_case(t, "Short-Description:")) {
867                                 char *d, *j;
868
869                                 state = LSB;
870
871                                 if ((j = strstrip(t+18)) && *j) {
872                                         if (!(d = strdup(j))) {
873                                                 r = -ENOMEM;
874                                                 goto finish;
875                                         }
876                                 } else
877                                         d = NULL;
878
879                                 free(short_description);
880                                 short_description = d;
881
882                         } else if (state == LSB_DESCRIPTION) {
883
884                                 if (startswith(l, "#\t") || startswith(l, "#  ")) {
885                                         char *j;
886
887                                         if ((j = strstrip(t)) && *j) {
888                                                 char *d = NULL;
889
890                                                 if (long_description)
891                                                         d = strjoin(long_description, " ", t, NULL);
892                                                 else
893                                                         d = strdup(j);
894
895                                                 if (!d) {
896                                                         r = -ENOMEM;
897                                                         goto finish;
898                                                 }
899
900                                                 free(long_description);
901                                                 long_description = d;
902                                         }
903
904                                 } else
905                                         state = LSB;
906                         }
907                 }
908         }
909
910         if ((r = sysv_exec_commands(s, supports_reload)) < 0)
911                 goto finish;
912
913         if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
914                 /* If there a runlevels configured for this service
915                  * but none of the standard ones, then we assume this
916                  * is some special kind of service (which might be
917                  * needed for early boot) and don't create any links
918                  * to it. */
919
920                 UNIT(s)->default_dependencies = false;
921
922                 /* Don't timeout special services during boot (like fsck) */
923                 s->timeout_start_usec = 0;
924                 s->timeout_stop_usec = 0;
925         } else {
926                 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
927                 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
928         }
929
930         /* Special setting for all SysV services */
931         s->type = SERVICE_FORKING;
932         s->remain_after_exit = !s->pid_file;
933         s->guess_main_pid = false;
934         s->restart = SERVICE_RESTART_NO;
935         s->exec_context.ignore_sigpipe = false;
936         s->kill_context.kill_mode = KILL_PROCESS;
937
938         /* We use the long description only if
939          * no short description is set. */
940
941         if (short_description)
942                 description = short_description;
943         else if (chkconfig_description)
944                 description = chkconfig_description;
945         else if (long_description)
946                 description = long_description;
947         else
948                 description = NULL;
949
950         if (description) {
951                 char *d;
952
953                 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
954                         r = -ENOMEM;
955                         goto finish;
956                 }
957
958                 u->description = d;
959         }
960
961         /* The priority that has been set in /etc/rcN.d/ hierarchies
962          * takes precedence over what is stored as default in the LSB
963          * header */
964         if (s->sysv_start_priority_from_rcnd >= 0)
965                 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
966
967         u->load_state = UNIT_LOADED;
968         r = 0;
969
970 finish:
971
972         if (f)
973                 fclose(f);
974
975         free(short_description);
976         free(long_description);
977         free(chkconfig_description);
978
979         return r;
980 }
981
982 static int service_load_sysv_name(Service *s, const char *name) {
983         char **p;
984
985         assert(s);
986         assert(name);
987
988         /* For SysV services we strip the *.sh suffixes. */
989         if (endswith(name, ".sh.service"))
990                 return -ENOENT;
991
992         STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
993                 char *path;
994                 int r;
995
996                 path = strjoin(*p, "/", name, NULL);
997                 if (!path)
998                         return -ENOMEM;
999
1000                 assert(endswith(path, ".service"));
1001                 path[strlen(path)-8] = 0;
1002
1003                 r = service_load_sysv_path(s, path);
1004
1005                 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1006                         /* Try *.sh source'able init scripts */
1007                         strcat(path, ".sh");
1008                         r = service_load_sysv_path(s, path);
1009                 }
1010                 free(path);
1011
1012                 if (r < 0)
1013                         return r;
1014
1015                 if (UNIT(s)->load_state != UNIT_STUB)
1016                         break;
1017         }
1018
1019         return 0;
1020 }
1021
1022 static int service_load_sysv(Service *s) {
1023         const char *t;
1024         Iterator i;
1025         int r;
1026
1027         assert(s);
1028
1029         /* Load service data from SysV init scripts, preferably with
1030          * LSB headers ... */
1031
1032         if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1033                 return 0;
1034
1035         if ((t = UNIT(s)->id))
1036                 if ((r = service_load_sysv_name(s, t)) < 0)
1037                         return r;
1038
1039         if (UNIT(s)->load_state == UNIT_STUB)
1040                 SET_FOREACH(t, UNIT(s)->names, i) {
1041                         if (t == UNIT(s)->id)
1042                                 continue;
1043
1044                         if ((r = service_load_sysv_name(s, t)) < 0)
1045                                 return r;
1046
1047                         if (UNIT(s)->load_state != UNIT_STUB)
1048                                 break;
1049                 }
1050
1051         return 0;
1052 }
1053 #endif
1054
1055 static int fsck_fix_order(Service *s) {
1056         Unit *other;
1057         int r;
1058
1059         assert(s);
1060
1061         if (s->fsck_passno <= 0)
1062                 return 0;
1063
1064         /* For each pair of services where both have an fsck priority
1065          * we order things based on it. */
1066
1067         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1068                 Service *t;
1069                 UnitDependency d;
1070
1071                 t = SERVICE(other);
1072
1073                 if (s == t)
1074                         continue;
1075
1076                 if (UNIT(t)->load_state != UNIT_LOADED)
1077                         continue;
1078
1079                 if (t->fsck_passno <= 0)
1080                         continue;
1081
1082                 if (t->fsck_passno < s->fsck_passno)
1083                         d = UNIT_AFTER;
1084                 else if (t->fsck_passno > s->fsck_passno)
1085                         d = UNIT_BEFORE;
1086                 else
1087                         continue;
1088
1089                 r = unit_add_dependency(UNIT(s), d, UNIT(t), true);
1090                 if (r < 0)
1091                         return r;
1092         }
1093
1094         return 0;
1095 }
1096
1097 static int service_verify(Service *s) {
1098         assert(s);
1099
1100         if (UNIT(s)->load_state != UNIT_LOADED)
1101                 return 0;
1102
1103         if (!s->exec_command[SERVICE_EXEC_START]) {
1104                 log_error_unit(UNIT(s)->id,
1105                                "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1106                 return -EINVAL;
1107         }
1108
1109         if (s->type != SERVICE_ONESHOT &&
1110             s->exec_command[SERVICE_EXEC_START]->command_next) {
1111                 log_error_unit(UNIT(s)->id,
1112                                "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1113                 return -EINVAL;
1114         }
1115
1116         if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1117                 log_error_unit(UNIT(s)->id,
1118                                 "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1119                 return -EINVAL;
1120         }
1121
1122         if (s->type == SERVICE_DBUS && !s->bus_name) {
1123                 log_error_unit(UNIT(s)->id,
1124                                "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1125                 return -EINVAL;
1126         }
1127
1128         if (s->bus_name && s->type != SERVICE_DBUS)
1129                 log_warning_unit(UNIT(s)->id,
1130                                  "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1131
1132         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
1133                 log_error_unit(UNIT(s)->id,
1134                                "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1135                 return -EINVAL;
1136         }
1137
1138         return 0;
1139 }
1140
1141 static int service_add_default_dependencies(Service *s) {
1142         int r;
1143
1144         assert(s);
1145
1146         /* Add a number of automatic dependencies useful for the
1147          * majority of services. */
1148
1149         /* First, pull in base system */
1150         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
1151                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1152                                                       SPECIAL_BASIC_TARGET, NULL, true);
1153                 if (r < 0)
1154                         return r;
1155
1156         } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
1157                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1158                                                       SPECIAL_SOCKETS_TARGET, NULL, true);
1159                 if (r < 0)
1160                         return r;
1161
1162                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1163                                                       SPECIAL_TIMERS_TARGET, NULL, true);
1164                 if (r < 0)
1165                         return r;
1166
1167                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1168                                                       SPECIAL_PATHS_TARGET, NULL, true);
1169                 if (r < 0)
1170                         return r;
1171         }
1172
1173         /* Second, activate normal shutdown */
1174         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1175                                               SPECIAL_SHUTDOWN_TARGET, NULL, true);
1176         return r;
1177 }
1178
1179 static void service_fix_output(Service *s) {
1180         assert(s);
1181
1182         /* If nothing has been explicitly configured, patch default
1183          * output in. If input is socket/tty we avoid this however,
1184          * since in that case we want output to default to the same
1185          * place as we read input from. */
1186
1187         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1188             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1189             s->exec_context.std_input == EXEC_INPUT_NULL)
1190                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1191
1192         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1193             s->exec_context.std_input == EXEC_INPUT_NULL)
1194                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1195 }
1196
1197 static int service_load(Unit *u) {
1198         int r;
1199         Service *s = SERVICE(u);
1200
1201         assert(s);
1202
1203         /* Load a .service file */
1204         r = unit_load_fragment(u);
1205         if (r < 0)
1206                 return r;
1207
1208 #ifdef HAVE_SYSV_COMPAT
1209         /* Load a classic init script as a fallback, if we couldn't find anything */
1210         if (u->load_state == UNIT_STUB) {
1211                 r = service_load_sysv(s);
1212                 if (r < 0)
1213                         return r;
1214         }
1215 #endif
1216
1217         /* Still nothing found? Then let's give up */
1218         if (u->load_state == UNIT_STUB)
1219                 return -ENOENT;
1220
1221         /* This is a new unit? Then let's add in some extras */
1222         if (u->load_state == UNIT_LOADED) {
1223
1224                 /* We were able to load something, then let's add in
1225                  * the dropin directories. */
1226                 r = unit_load_dropin(u);
1227                 if (r < 0)
1228                         return r;
1229
1230                 if (s->type == _SERVICE_TYPE_INVALID)
1231                         s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1232
1233                 /* Oneshot services have disabled start timeout by default */
1234                 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1235                         s->timeout_start_usec = 0;
1236
1237                 service_fix_output(s);
1238
1239                 r = unit_add_exec_dependencies(u, &s->exec_context);
1240                 if (r < 0)
1241                         return r;
1242
1243                 r = unit_add_default_slice(u);
1244                 if (r < 0)
1245                         return r;
1246
1247 #ifdef HAVE_SYSV_COMPAT
1248                 r = sysv_fix_order(s);
1249                 if (r < 0)
1250                         return r;
1251 #endif
1252
1253                 r = fsck_fix_order(s);
1254                 if (r < 0)
1255                         return r;
1256
1257                 if (s->bus_name)
1258                         if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1259                                 return r;
1260
1261                 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1262                         s->notify_access = NOTIFY_MAIN;
1263
1264                 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1265                         s->notify_access = NOTIFY_MAIN;
1266
1267                 if (s->type == SERVICE_DBUS || s->bus_name) {
1268                         r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES,
1269                                                               SPECIAL_DBUS_SOCKET, NULL, true);
1270                         if (r < 0)
1271                                 return r;
1272                 }
1273
1274                 if (UNIT(s)->default_dependencies) {
1275                         r = service_add_default_dependencies(s);
1276                         if (r < 0)
1277                                 return r;
1278                 }
1279
1280                 r = unit_exec_context_defaults(u, &s->exec_context);
1281                 if (r < 0)
1282                         return r;
1283         }
1284
1285         return service_verify(s);
1286 }
1287
1288 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1289
1290         ServiceExecCommand c;
1291         Service *s = SERVICE(u);
1292         const char *prefix2;
1293         _cleanup_free_ char *p2 = NULL;
1294
1295         assert(s);
1296
1297         p2 = strappend(prefix, "\t");
1298         prefix2 = p2 ? p2 : prefix;
1299
1300         fprintf(f,
1301                 "%sService State: %s\n"
1302                 "%sResult: %s\n"
1303                 "%sReload Result: %s\n"
1304                 "%sPermissionsStartOnly: %s\n"
1305                 "%sRootDirectoryStartOnly: %s\n"
1306                 "%sRemainAfterExit: %s\n"
1307                 "%sGuessMainPID: %s\n"
1308                 "%sType: %s\n"
1309                 "%sRestart: %s\n"
1310                 "%sNotifyAccess: %s\n",
1311                 prefix, service_state_to_string(s->state),
1312                 prefix, service_result_to_string(s->result),
1313                 prefix, service_result_to_string(s->reload_result),
1314                 prefix, yes_no(s->permissions_start_only),
1315                 prefix, yes_no(s->root_directory_start_only),
1316                 prefix, yes_no(s->remain_after_exit),
1317                 prefix, yes_no(s->guess_main_pid),
1318                 prefix, service_type_to_string(s->type),
1319                 prefix, service_restart_to_string(s->restart),
1320                 prefix, notify_access_to_string(s->notify_access));
1321
1322         if (s->control_pid > 0)
1323                 fprintf(f,
1324                         "%sControl PID: %lu\n",
1325                         prefix, (unsigned long) s->control_pid);
1326
1327         if (s->main_pid > 0)
1328                 fprintf(f,
1329                         "%sMain PID: %lu\n"
1330                         "%sMain PID Known: %s\n"
1331                         "%sMain PID Alien: %s\n",
1332                         prefix, (unsigned long) s->main_pid,
1333                         prefix, yes_no(s->main_pid_known),
1334                         prefix, yes_no(s->main_pid_alien));
1335
1336         if (s->pid_file)
1337                 fprintf(f,
1338                         "%sPIDFile: %s\n",
1339                         prefix, s->pid_file);
1340
1341         if (s->bus_name)
1342                 fprintf(f,
1343                         "%sBusName: %s\n"
1344                         "%sBus Name Good: %s\n",
1345                         prefix, s->bus_name,
1346                         prefix, yes_no(s->bus_name_good));
1347
1348         kill_context_dump(&s->kill_context, f, prefix);
1349         exec_context_dump(&s->exec_context, f, prefix);
1350
1351         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1352
1353                 if (!s->exec_command[c])
1354                         continue;
1355
1356                 fprintf(f, "%s-> %s:\n",
1357                         prefix, service_exec_command_to_string(c));
1358
1359                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1360         }
1361
1362 #ifdef HAVE_SYSV_COMPAT
1363         if (s->is_sysv)
1364                 fprintf(f,
1365                         "%sSysV Init Script has LSB Header: %s\n"
1366                         "%sSysVEnabled: %s\n",
1367                         prefix, yes_no(s->sysv_has_lsb),
1368                         prefix, yes_no(s->sysv_enabled));
1369
1370         if (s->sysv_start_priority >= 0)
1371                 fprintf(f,
1372                         "%sSysVStartPriority: %i\n",
1373                         prefix, s->sysv_start_priority);
1374
1375         if (s->sysv_runlevels)
1376                 fprintf(f, "%sSysVRunLevels: %s\n",
1377                         prefix, s->sysv_runlevels);
1378 #endif
1379
1380         if (s->fsck_passno > 0)
1381                 fprintf(f,
1382                         "%sFsckPassNo: %i\n",
1383                         prefix, s->fsck_passno);
1384
1385         if (s->status_text)
1386                 fprintf(f, "%sStatus Text: %s\n",
1387                         prefix, s->status_text);
1388 }
1389
1390 static int service_load_pid_file(Service *s, bool may_warn) {
1391         _cleanup_free_ char *k = NULL;
1392         int r;
1393         pid_t pid;
1394
1395         assert(s);
1396
1397         if (!s->pid_file)
1398                 return -ENOENT;
1399
1400         r = read_one_line_file(s->pid_file, &k);
1401         if (r < 0) {
1402                 if (may_warn)
1403                         log_info_unit(UNIT(s)->id,
1404                                       "PID file %s not readable (yet?) after %s.",
1405                                       s->pid_file, service_state_to_string(s->state));
1406                 return r;
1407         }
1408
1409         r = parse_pid(k, &pid);
1410         if (r < 0) {
1411                 if (may_warn)
1412                         log_info_unit(UNIT(s)->id,
1413                                       "Failed to read PID from file %s: %s",
1414                                       s->pid_file, strerror(-r));
1415                 return r;
1416         }
1417
1418         if (kill(pid, 0) < 0 && errno != EPERM) {
1419                 if (may_warn)
1420                         log_info_unit(UNIT(s)->id,
1421                                       "PID %lu read from file %s does not exist.",
1422                                       (unsigned long) pid, s->pid_file);
1423                 return -ESRCH;
1424         }
1425
1426         if (s->main_pid_known) {
1427                 if (pid == s->main_pid)
1428                         return 0;
1429
1430                 log_debug_unit(UNIT(s)->id,
1431                                "Main PID changing: %lu -> %lu",
1432                                (unsigned long) s->main_pid, (unsigned long) pid);
1433                 service_unwatch_main_pid(s);
1434                 s->main_pid_known = false;
1435         } else
1436                 log_debug_unit(UNIT(s)->id,
1437                                "Main PID loaded: %lu", (unsigned long) pid);
1438
1439         r = service_set_main_pid(s, pid);
1440         if (r < 0)
1441                 return r;
1442
1443         r = unit_watch_pid(UNIT(s), pid);
1444         if (r < 0) {
1445                 /* FIXME: we need to do something here */
1446                 log_warning_unit(UNIT(s)->id,
1447                                  "Failed to watch PID %lu from service %s",
1448                                  (unsigned long) pid, UNIT(s)->id);
1449                 return r;
1450         }
1451
1452         return 0;
1453 }
1454
1455 static int service_search_main_pid(Service *s) {
1456         pid_t pid;
1457         int r;
1458
1459         assert(s);
1460
1461         /* If we know it anyway, don't ever fallback to unreliable
1462          * heuristics */
1463         if (s->main_pid_known)
1464                 return 0;
1465
1466         if (!s->guess_main_pid)
1467                 return 0;
1468
1469         assert(s->main_pid <= 0);
1470
1471         pid = unit_search_main_pid(UNIT(s));
1472         if (pid <= 0)
1473                 return -ENOENT;
1474
1475         log_debug_unit(UNIT(s)->id,
1476                        "Main PID guessed: %lu", (unsigned long) pid);
1477         r = service_set_main_pid(s, pid);
1478         if (r < 0)
1479                 return r;
1480
1481         r = unit_watch_pid(UNIT(s), pid);
1482         if (r < 0)
1483                 /* FIXME: we need to do something here */
1484                 log_warning_unit(UNIT(s)->id,
1485                                  "Failed to watch PID %lu from service %s",
1486                                  (unsigned long) pid, UNIT(s)->id);
1487                 return r;
1488
1489         return 0;
1490 }
1491
1492 static void service_set_state(Service *s, ServiceState state) {
1493         ServiceState old_state;
1494         const UnitActiveState *table;
1495         assert(s);
1496
1497         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1498
1499         old_state = s->state;
1500         s->state = state;
1501
1502         service_unwatch_pid_file(s);
1503
1504         if (state != SERVICE_START_PRE &&
1505             state != SERVICE_START &&
1506             state != SERVICE_START_POST &&
1507             state != SERVICE_RELOAD &&
1508             state != SERVICE_STOP &&
1509             state != SERVICE_STOP_SIGTERM &&
1510             state != SERVICE_STOP_SIGKILL &&
1511             state != SERVICE_STOP_POST &&
1512             state != SERVICE_FINAL_SIGTERM &&
1513             state != SERVICE_FINAL_SIGKILL &&
1514             state != SERVICE_AUTO_RESTART)
1515                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1516
1517         if (state != SERVICE_START &&
1518             state != SERVICE_START_POST &&
1519             state != SERVICE_RUNNING &&
1520             state != SERVICE_RELOAD &&
1521             state != SERVICE_STOP &&
1522             state != SERVICE_STOP_SIGTERM &&
1523             state != SERVICE_STOP_SIGKILL) {
1524                 service_unwatch_main_pid(s);
1525                 s->main_command = NULL;
1526         }
1527
1528         if (state != SERVICE_START_PRE &&
1529             state != SERVICE_START &&
1530             state != SERVICE_START_POST &&
1531             state != SERVICE_RELOAD &&
1532             state != SERVICE_STOP &&
1533             state != SERVICE_STOP_SIGTERM &&
1534             state != SERVICE_STOP_SIGKILL &&
1535             state != SERVICE_STOP_POST &&
1536             state != SERVICE_FINAL_SIGTERM &&
1537             state != SERVICE_FINAL_SIGKILL) {
1538                 service_unwatch_control_pid(s);
1539                 s->control_command = NULL;
1540                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1541         }
1542
1543         if (state != SERVICE_START_PRE &&
1544             state != SERVICE_START &&
1545             state != SERVICE_START_POST &&
1546             state != SERVICE_RUNNING &&
1547             state != SERVICE_RELOAD &&
1548             state != SERVICE_STOP &&
1549             state != SERVICE_STOP_SIGTERM &&
1550             state != SERVICE_STOP_SIGKILL &&
1551             state != SERVICE_STOP_POST &&
1552             state != SERVICE_FINAL_SIGTERM &&
1553             state != SERVICE_FINAL_SIGKILL &&
1554             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1555                 service_close_socket_fd(s);
1556                 service_connection_unref(s);
1557         }
1558
1559         if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
1560                 service_stop_watchdog(s);
1561
1562         /* For the inactive states unit_notify() will trim the cgroup,
1563          * but for exit we have to do that ourselves... */
1564         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1565                 unit_destroy_cgroup(UNIT(s));
1566
1567         if (old_state != state)
1568                 log_debug_unit(UNIT(s)->id,
1569                                "%s changed %s -> %s", UNIT(s)->id,
1570                                service_state_to_string(old_state),
1571                                service_state_to_string(state));
1572
1573         unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1574         s->reload_result = SERVICE_SUCCESS;
1575 }
1576
1577 static int service_coldplug(Unit *u) {
1578         Service *s = SERVICE(u);
1579         int r;
1580
1581         assert(s);
1582         assert(s->state == SERVICE_DEAD);
1583
1584         if (s->deserialized_state != s->state) {
1585
1586                 if (s->deserialized_state == SERVICE_START_PRE ||
1587                     s->deserialized_state == SERVICE_START ||
1588                     s->deserialized_state == SERVICE_START_POST ||
1589                     s->deserialized_state == SERVICE_RELOAD ||
1590                     s->deserialized_state == SERVICE_STOP ||
1591                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1592                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1593                     s->deserialized_state == SERVICE_STOP_POST ||
1594                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1595                     s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1596                     s->deserialized_state == SERVICE_AUTO_RESTART) {
1597
1598                         if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
1599                                 usec_t k;
1600
1601                                 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
1602
1603                                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1604                                 if (r < 0)
1605                                         return r;
1606                         }
1607                 }
1608
1609                 if ((s->deserialized_state == SERVICE_START &&
1610                      (s->type == SERVICE_FORKING ||
1611                       s->type == SERVICE_DBUS ||
1612                       s->type == SERVICE_ONESHOT ||
1613                       s->type == SERVICE_NOTIFY)) ||
1614                     s->deserialized_state == SERVICE_START_POST ||
1615                     s->deserialized_state == SERVICE_RUNNING ||
1616                     s->deserialized_state == SERVICE_RELOAD ||
1617                     s->deserialized_state == SERVICE_STOP ||
1618                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1619                     s->deserialized_state == SERVICE_STOP_SIGKILL)
1620                         if (s->main_pid > 0) {
1621                                 r = unit_watch_pid(UNIT(s), s->main_pid);
1622                                 if (r < 0)
1623                                         return r;
1624                         }
1625
1626                 if (s->deserialized_state == SERVICE_START_PRE ||
1627                     s->deserialized_state == SERVICE_START ||
1628                     s->deserialized_state == SERVICE_START_POST ||
1629                     s->deserialized_state == SERVICE_RELOAD ||
1630                     s->deserialized_state == SERVICE_STOP ||
1631                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1632                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1633                     s->deserialized_state == SERVICE_STOP_POST ||
1634                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1635                     s->deserialized_state == SERVICE_FINAL_SIGKILL)
1636                         if (s->control_pid > 0) {
1637                                 r = unit_watch_pid(UNIT(s), s->control_pid);
1638                                 if (r < 0)
1639                                         return r;
1640                         }
1641
1642                 if (s->deserialized_state == SERVICE_START_POST ||
1643                     s->deserialized_state == SERVICE_RUNNING)
1644                         service_handle_watchdog(s);
1645
1646                 service_set_state(s, s->deserialized_state);
1647         }
1648         return 0;
1649 }
1650
1651 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1652         Iterator i;
1653         int r;
1654         int *rfds = NULL;
1655         unsigned rn_fds = 0;
1656         Unit *u;
1657
1658         assert(s);
1659         assert(fds);
1660         assert(n_fds);
1661
1662         if (s->socket_fd >= 0)
1663                 return 0;
1664
1665         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1666                 int *cfds;
1667                 unsigned cn_fds;
1668                 Socket *sock;
1669
1670                 if (u->type != UNIT_SOCKET)
1671                         continue;
1672
1673                 sock = SOCKET(u);
1674
1675                 r = socket_collect_fds(sock, &cfds, &cn_fds);
1676                 if (r < 0)
1677                         goto fail;
1678
1679                 if (!cfds)
1680                         continue;
1681
1682                 if (!rfds) {
1683                         rfds = cfds;
1684                         rn_fds = cn_fds;
1685                 } else {
1686                         int *t;
1687
1688                         t = new(int, rn_fds+cn_fds);
1689                         if (!t) {
1690                                 free(cfds);
1691                                 r = -ENOMEM;
1692                                 goto fail;
1693                         }
1694
1695                         memcpy(t, rfds, rn_fds * sizeof(int));
1696                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1697                         free(rfds);
1698                         free(cfds);
1699
1700                         rfds = t;
1701                         rn_fds = rn_fds+cn_fds;
1702                 }
1703         }
1704
1705         *fds = rfds;
1706         *n_fds = rn_fds;
1707
1708         return 0;
1709
1710 fail:
1711         free(rfds);
1712
1713         return r;
1714 }
1715
1716 static int service_spawn(
1717                 Service *s,
1718                 ExecCommand *c,
1719                 bool timeout,
1720                 bool pass_fds,
1721                 bool apply_permissions,
1722                 bool apply_chroot,
1723                 bool apply_tty_stdin,
1724                 bool set_notify_socket,
1725                 bool is_control,
1726                 pid_t *_pid) {
1727
1728         pid_t pid;
1729         int r;
1730         int *fds = NULL;
1731         _cleanup_free_ int *fdsbuf = NULL;
1732         unsigned n_fds = 0, n_env = 0;
1733         _cleanup_strv_free_ char
1734                 **argv = NULL, **final_env = NULL, **our_env = NULL;
1735         const char *path;
1736
1737         assert(s);
1738         assert(c);
1739         assert(_pid);
1740
1741         unit_realize_cgroup(UNIT(s));
1742
1743         if (pass_fds ||
1744             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1745             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1746             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1747
1748                 if (s->socket_fd >= 0) {
1749                         fds = &s->socket_fd;
1750                         n_fds = 1;
1751                 } else {
1752                         r = service_collect_fds(s, &fdsbuf, &n_fds);
1753                         if (r < 0)
1754                                 goto fail;
1755
1756                         fds = fdsbuf;
1757                 }
1758         }
1759
1760         if (timeout && s->timeout_start_usec) {
1761                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1762                                      s->timeout_start_usec, &s->timer_watch);
1763                 if (r < 0)
1764                         goto fail;
1765         } else
1766                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1767
1768         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1769         if (r < 0)
1770                 goto fail;
1771
1772         our_env = new0(char*, 5);
1773         if (!our_env) {
1774                 r = -ENOMEM;
1775                 goto fail;
1776         }
1777
1778         if (set_notify_socket)
1779                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1780                         r = -ENOMEM;
1781                         goto fail;
1782                 }
1783
1784         if (s->main_pid > 0)
1785                 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1786                         r = -ENOMEM;
1787                         goto fail;
1788                 }
1789
1790         if (s->watchdog_usec > 0)
1791                 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1792                         r = -ENOMEM;
1793                         goto fail;
1794                 }
1795
1796         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1797                 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1798                         r = -ENOMEM;
1799                         goto fail;
1800                 }
1801
1802         final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1803         if (!final_env) {
1804                 r = -ENOMEM;
1805                 goto fail;
1806         }
1807
1808         if (is_control && UNIT(s)->cgroup_path) {
1809                 path = strappenda(UNIT(s)->cgroup_path, "/control");
1810                 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1811         } else
1812                 path = UNIT(s)->cgroup_path;
1813
1814         r = exec_spawn(c,
1815                        argv,
1816                        &s->exec_context,
1817                        fds, n_fds,
1818                        final_env,
1819                        apply_permissions,
1820                        apply_chroot,
1821                        apply_tty_stdin,
1822                        UNIT(s)->manager->confirm_spawn,
1823                        UNIT(s)->manager->cgroup_supported,
1824                        path,
1825                        UNIT(s)->id,
1826                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1827                        &pid);
1828         if (r < 0)
1829                 goto fail;
1830
1831         r = unit_watch_pid(UNIT(s), pid);
1832         if (r < 0)
1833                 /* FIXME: we need to do something here */
1834                 goto fail;
1835
1836         *_pid = pid;
1837
1838         return 0;
1839
1840 fail:
1841         if (timeout)
1842                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1843
1844         return r;
1845 }
1846
1847 static int main_pid_good(Service *s) {
1848         assert(s);
1849
1850         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1851          * don't know */
1852
1853         /* If we know the pid file, then lets just check if it is
1854          * still valid */
1855         if (s->main_pid_known) {
1856
1857                 /* If it's an alien child let's check if it is still
1858                  * alive ... */
1859                 if (s->main_pid_alien && s->main_pid > 0)
1860                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1861
1862                 /* .. otherwise assume we'll get a SIGCHLD for it,
1863                  * which we really should wait for to collect exit
1864                  * status and code */
1865                 return s->main_pid > 0;
1866         }
1867
1868         /* We don't know the pid */
1869         return -EAGAIN;
1870 }
1871
1872 _pure_ static int control_pid_good(Service *s) {
1873         assert(s);
1874
1875         return s->control_pid > 0;
1876 }
1877
1878 static int cgroup_good(Service *s) {
1879         int r;
1880
1881         assert(s);
1882
1883         if (!UNIT(s)->cgroup_path)
1884                 return 0;
1885
1886         r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1887         if (r < 0)
1888                 return r;
1889
1890         return !r;
1891 }
1892
1893 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1894         int r;
1895         assert(s);
1896
1897         if (f != SERVICE_SUCCESS)
1898                 s->result = f;
1899
1900         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1901
1902         if (allow_restart &&
1903             !s->forbid_restart &&
1904             (s->restart == SERVICE_RESTART_ALWAYS ||
1905              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1906              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1907              (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1908              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1909                                                          s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1910             (s->result != SERVICE_FAILURE_EXIT_CODE ||
1911              !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1912             (s->result != SERVICE_FAILURE_SIGNAL ||
1913              !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1914                 ) {
1915
1916                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
1917                 if (r < 0)
1918                         goto fail;
1919
1920                 service_set_state(s, SERVICE_AUTO_RESTART);
1921         }
1922
1923         s->forbid_restart = false;
1924
1925         /* we want fresh tmpdirs in case service is started again immediately */
1926         exec_context_tmp_dirs_done(&s->exec_context);
1927
1928         /* Try to delete the pid file. At this point it will be
1929          * out-of-date, and some software might be confused by it, so
1930          * let's remove it. */
1931         if (s->pid_file)
1932                 unlink_noerrno(s->pid_file);
1933
1934         return;
1935
1936 fail:
1937         log_warning_unit(UNIT(s)->id,
1938                          "%s failed to run install restart timer: %s",
1939                          UNIT(s)->id, strerror(-r));
1940         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1941 }
1942
1943 static void service_enter_stop_post(Service *s, ServiceResult f) {
1944         int r;
1945         assert(s);
1946
1947         if (f != SERVICE_SUCCESS)
1948                 s->result = f;
1949
1950         service_unwatch_control_pid(s);
1951
1952         s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1953         if (s->control_command) {
1954                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1955
1956                 r = service_spawn(s,
1957                                   s->control_command,
1958                                   true,
1959                                   false,
1960                                   !s->permissions_start_only,
1961                                   !s->root_directory_start_only,
1962                                   true,
1963                                   false,
1964                                   true,
1965                                   &s->control_pid);
1966                 if (r < 0)
1967                         goto fail;
1968
1969
1970                 service_set_state(s, SERVICE_STOP_POST);
1971         } else
1972                 service_enter_dead(s, SERVICE_SUCCESS, true);
1973
1974         return;
1975
1976 fail:
1977         log_warning_unit(UNIT(s)->id,
1978                          "%s failed to run 'stop-post' task: %s",
1979                          UNIT(s)->id, strerror(-r));
1980         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1981 }
1982
1983 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1984         int r;
1985
1986         assert(s);
1987
1988         if (f != SERVICE_SUCCESS)
1989                 s->result = f;
1990
1991         r = unit_kill_context(
1992                         UNIT(s),
1993                         &s->kill_context,
1994                         state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1995                         s->main_pid,
1996                         s->control_pid,
1997                         s->main_pid_alien);
1998         if (r < 0)
1999                 goto fail;
2000
2001         if (r > 0) {
2002                 if (s->timeout_stop_usec > 0) {
2003                         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2004                                              s->timeout_stop_usec, &s->timer_watch);
2005                         if (r < 0)
2006                                 goto fail;
2007                 }
2008
2009                 service_set_state(s, state);
2010         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2011                 service_enter_stop_post(s, SERVICE_SUCCESS);
2012         else
2013                 service_enter_dead(s, SERVICE_SUCCESS, true);
2014
2015         return;
2016
2017 fail:
2018         log_warning_unit(UNIT(s)->id,
2019                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2020
2021         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2022                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2023         else
2024                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2025 }
2026
2027 static void service_enter_stop(Service *s, ServiceResult f) {
2028         int r;
2029
2030         assert(s);
2031
2032         if (f != SERVICE_SUCCESS)
2033                 s->result = f;
2034
2035         service_unwatch_control_pid(s);
2036
2037         s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2038         if (s->control_command) {
2039                 s->control_command_id = SERVICE_EXEC_STOP;
2040
2041                 r = service_spawn(s,
2042                                   s->control_command,
2043                                   true,
2044                                   false,
2045                                   !s->permissions_start_only,
2046                                   !s->root_directory_start_only,
2047                                   false,
2048                                   false,
2049                                   true,
2050                                   &s->control_pid);
2051                 if (r < 0)
2052                         goto fail;
2053
2054                 service_set_state(s, SERVICE_STOP);
2055         } else
2056                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2057
2058         return;
2059
2060 fail:
2061         log_warning_unit(UNIT(s)->id,
2062                          "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2063         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2064 }
2065
2066 static void service_enter_running(Service *s, ServiceResult f) {
2067         int main_pid_ok, cgroup_ok;
2068         assert(s);
2069
2070         if (f != SERVICE_SUCCESS)
2071                 s->result = f;
2072
2073         main_pid_ok = main_pid_good(s);
2074         cgroup_ok = cgroup_good(s);
2075
2076         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2077             (s->bus_name_good || s->type != SERVICE_DBUS))
2078                 service_set_state(s, SERVICE_RUNNING);
2079         else if (s->remain_after_exit)
2080                 service_set_state(s, SERVICE_EXITED);
2081         else
2082                 service_enter_stop(s, SERVICE_SUCCESS);
2083 }
2084
2085 static void service_enter_start_post(Service *s) {
2086         int r;
2087         assert(s);
2088
2089         service_unwatch_control_pid(s);
2090
2091         if (s->watchdog_usec > 0)
2092                 service_reset_watchdog(s);
2093
2094         s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2095         if (s->control_command) {
2096                 s->control_command_id = SERVICE_EXEC_START_POST;
2097
2098                 r = service_spawn(s,
2099                                   s->control_command,
2100                                   true,
2101                                   false,
2102                                   !s->permissions_start_only,
2103                                   !s->root_directory_start_only,
2104                                   false,
2105                                   false,
2106                                   true,
2107                                   &s->control_pid);
2108                 if (r < 0)
2109                         goto fail;
2110
2111                 service_set_state(s, SERVICE_START_POST);
2112         } else
2113                 service_enter_running(s, SERVICE_SUCCESS);
2114
2115         return;
2116
2117 fail:
2118         log_warning_unit(UNIT(s)->id,
2119                          "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2120         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2121 }
2122
2123 static void service_kill_control_processes(Service *s) {
2124         char *p;
2125
2126         if (!UNIT(s)->cgroup_path)
2127                 return;
2128
2129         p = strappenda(UNIT(s)->cgroup_path, "/control");
2130         cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2131 }
2132
2133 static void service_enter_start(Service *s) {
2134         ExecCommand *c;
2135         pid_t pid;
2136         int r;
2137
2138         assert(s);
2139
2140         assert(s->exec_command[SERVICE_EXEC_START]);
2141         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2142
2143         service_unwatch_control_pid(s);
2144         service_unwatch_main_pid(s);
2145
2146         /* We want to ensure that nobody leaks processes from
2147          * START_PRE here, so let's go on a killing spree, People
2148          * should not spawn long running processes from START_PRE. */
2149         service_kill_control_processes(s);
2150
2151         if (s->type == SERVICE_FORKING) {
2152                 s->control_command_id = SERVICE_EXEC_START;
2153                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2154
2155                 s->main_command = NULL;
2156         } else {
2157                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2158                 s->control_command = NULL;
2159
2160                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2161         }
2162
2163         r = service_spawn(s,
2164                           c,
2165                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2166                             s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2167                           true,
2168                           true,
2169                           true,
2170                           true,
2171                           s->notify_access != NOTIFY_NONE,
2172                           false,
2173                           &pid);
2174         if (r < 0)
2175                 goto fail;
2176
2177         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2178                 /* For simple services we immediately start
2179                  * the START_POST binaries. */
2180
2181                 service_set_main_pid(s, pid);
2182                 service_enter_start_post(s);
2183
2184         } else  if (s->type == SERVICE_FORKING) {
2185
2186                 /* For forking services we wait until the start
2187                  * process exited. */
2188
2189                 s->control_pid = pid;
2190                 service_set_state(s, SERVICE_START);
2191
2192         } else if (s->type == SERVICE_ONESHOT ||
2193                    s->type == SERVICE_DBUS ||
2194                    s->type == SERVICE_NOTIFY) {
2195
2196                 /* For oneshot services we wait until the start
2197                  * process exited, too, but it is our main process. */
2198
2199                 /* For D-Bus services we know the main pid right away,
2200                  * but wait for the bus name to appear on the
2201                  * bus. Notify services are similar. */
2202
2203                 service_set_main_pid(s, pid);
2204                 service_set_state(s, SERVICE_START);
2205         } else
2206                 assert_not_reached("Unknown service type");
2207
2208         return;
2209
2210 fail:
2211         log_warning_unit(UNIT(s)->id,
2212                          "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2213         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2214 }
2215
2216 static void service_enter_start_pre(Service *s) {
2217         int r;
2218
2219         assert(s);
2220
2221         service_unwatch_control_pid(s);
2222
2223         s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2224         if (s->control_command) {
2225                 /* Before we start anything, let's clear up what might
2226                  * be left from previous runs. */
2227                 service_kill_control_processes(s);
2228
2229                 s->control_command_id = SERVICE_EXEC_START_PRE;
2230
2231                 r = service_spawn(s,
2232                                   s->control_command,
2233                                   true,
2234                                   false,
2235                                   !s->permissions_start_only,
2236                                   !s->root_directory_start_only,
2237                                   true,
2238                                   false,
2239                                   true,
2240                                   &s->control_pid);
2241                 if (r < 0)
2242                         goto fail;
2243
2244                 service_set_state(s, SERVICE_START_PRE);
2245         } else
2246                 service_enter_start(s);
2247
2248         return;
2249
2250 fail:
2251         log_warning_unit(UNIT(s)->id,
2252                          "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2253         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2254 }
2255
2256 static void service_enter_restart(Service *s) {
2257         int r;
2258         DBusError error;
2259
2260         assert(s);
2261         dbus_error_init(&error);
2262
2263         if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2264                 /* Don't restart things if we are going down anyway */
2265                 log_info_unit(UNIT(s)->id,
2266                               "Stop job pending for unit, delaying automatic restart.");
2267
2268                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
2269                 if (r < 0)
2270                         goto fail;
2271
2272                 return;
2273         }
2274
2275         /* Any units that are bound to this service must also be
2276          * restarted. We use JOB_RESTART (instead of the more obvious
2277          * JOB_START) here so that those dependency jobs will be added
2278          * as well. */
2279         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2280         if (r < 0)
2281                 goto fail;
2282
2283         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2284          * it will be canceled as part of the service_stop() call that
2285          * is executed as part of JOB_RESTART. */
2286
2287         log_debug_unit(UNIT(s)->id,
2288                        "%s scheduled restart job.", UNIT(s)->id);
2289         return;
2290
2291 fail:
2292         log_warning_unit(UNIT(s)->id,
2293                          "%s failed to schedule restart job: %s",
2294                          UNIT(s)->id, bus_error(&error, -r));
2295         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2296
2297         dbus_error_free(&error);
2298 }
2299
2300 static void service_enter_reload(Service *s) {
2301         int r;
2302
2303         assert(s);
2304
2305         service_unwatch_control_pid(s);
2306
2307         s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2308         if (s->control_command) {
2309                 s->control_command_id = SERVICE_EXEC_RELOAD;
2310
2311                 r = service_spawn(s,
2312                                   s->control_command,
2313                                   true,
2314                                   false,
2315                                   !s->permissions_start_only,
2316                                   !s->root_directory_start_only,
2317                                   false,
2318                                   false,
2319                                   true,
2320                                   &s->control_pid);
2321                 if (r < 0)
2322                         goto fail;
2323
2324                 service_set_state(s, SERVICE_RELOAD);
2325         } else
2326                 service_enter_running(s, SERVICE_SUCCESS);
2327
2328         return;
2329
2330 fail:
2331         log_warning_unit(UNIT(s)->id,
2332                          "%s failed to run 'reload' task: %s",
2333                          UNIT(s)->id, strerror(-r));
2334         s->reload_result = SERVICE_FAILURE_RESOURCES;
2335         service_enter_running(s, SERVICE_SUCCESS);
2336 }
2337
2338 static void service_run_next_control(Service *s) {
2339         int r;
2340
2341         assert(s);
2342         assert(s->control_command);
2343         assert(s->control_command->command_next);
2344
2345         assert(s->control_command_id != SERVICE_EXEC_START);
2346
2347         s->control_command = s->control_command->command_next;
2348         service_unwatch_control_pid(s);
2349
2350         r = service_spawn(s,
2351                           s->control_command,
2352                           true,
2353                           false,
2354                           !s->permissions_start_only,
2355                           !s->root_directory_start_only,
2356                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2357                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2358                           false,
2359                           true,
2360                           &s->control_pid);
2361         if (r < 0)
2362                 goto fail;
2363
2364         return;
2365
2366 fail:
2367         log_warning_unit(UNIT(s)->id,
2368                          "%s failed to run next control task: %s",
2369                          UNIT(s)->id, strerror(-r));
2370
2371         if (s->state == SERVICE_START_PRE)
2372                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2373         else if (s->state == SERVICE_STOP)
2374                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2375         else if (s->state == SERVICE_STOP_POST)
2376                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2377         else if (s->state == SERVICE_RELOAD) {
2378                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2379                 service_enter_running(s, SERVICE_SUCCESS);
2380         } else
2381                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2382 }
2383
2384 static void service_run_next_main(Service *s) {
2385         pid_t pid;
2386         int r;
2387
2388         assert(s);
2389         assert(s->main_command);
2390         assert(s->main_command->command_next);
2391         assert(s->type == SERVICE_ONESHOT);
2392
2393         s->main_command = s->main_command->command_next;
2394         service_unwatch_main_pid(s);
2395
2396         r = service_spawn(s,
2397                           s->main_command,
2398                           true,
2399                           true,
2400                           true,
2401                           true,
2402                           true,
2403                           s->notify_access != NOTIFY_NONE,
2404                           false,
2405                           &pid);
2406         if (r < 0)
2407                 goto fail;
2408
2409         service_set_main_pid(s, pid);
2410
2411         return;
2412
2413 fail:
2414         log_warning_unit(UNIT(s)->id,
2415                          "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2416         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2417 }
2418
2419 static int service_start_limit_test(Service *s) {
2420         assert(s);
2421
2422         if (ratelimit_test(&s->start_limit))
2423                 return 0;
2424
2425         switch (s->start_limit_action) {
2426
2427         case SERVICE_START_LIMIT_NONE:
2428                 log_warning_unit(UNIT(s)->id,
2429                                  "%s start request repeated too quickly, refusing to start.",
2430                                  UNIT(s)->id);
2431                 break;
2432
2433         case SERVICE_START_LIMIT_REBOOT: {
2434                 DBusError error;
2435                 int r;
2436
2437                 dbus_error_init(&error);
2438
2439                 log_warning_unit(UNIT(s)->id,
2440                                  "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2441
2442                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2443                                             SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2444                                             true, &error, NULL);
2445                 if (r < 0) {
2446                         log_error_unit(UNIT(s)->id,
2447                                        "Failed to reboot: %s.", bus_error(&error, r));
2448                         dbus_error_free(&error);
2449                 }
2450
2451                 break;
2452         }
2453
2454         case SERVICE_START_LIMIT_REBOOT_FORCE:
2455                 log_warning_unit(UNIT(s)->id,
2456                                  "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2457                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2458                 break;
2459
2460         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2461                 log_warning_unit(UNIT(s)->id,
2462                                  "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2463                 sync();
2464                 reboot(RB_AUTOBOOT);
2465                 break;
2466
2467         default:
2468                 log_error_unit(UNIT(s)->id,
2469                                "start limit action=%i", s->start_limit_action);
2470                 assert_not_reached("Unknown StartLimitAction.");
2471         }
2472
2473         return -ECANCELED;
2474 }
2475
2476 static int service_start(Unit *u) {
2477         Service *s = SERVICE(u);
2478         int r;
2479
2480         assert(s);
2481
2482         /* We cannot fulfill this request right now, try again later
2483          * please! */
2484         if (s->state == SERVICE_STOP ||
2485             s->state == SERVICE_STOP_SIGTERM ||
2486             s->state == SERVICE_STOP_SIGKILL ||
2487             s->state == SERVICE_STOP_POST ||
2488             s->state == SERVICE_FINAL_SIGTERM ||
2489             s->state == SERVICE_FINAL_SIGKILL)
2490                 return -EAGAIN;
2491
2492         /* Already on it! */
2493         if (s->state == SERVICE_START_PRE ||
2494             s->state == SERVICE_START ||
2495             s->state == SERVICE_START_POST)
2496                 return 0;
2497
2498         /* A service that will be restarted must be stopped first to
2499          * trigger BindsTo and/or OnFailure dependencies. If a user
2500          * does not want to wait for the holdoff time to elapse, the
2501          * service should be manually restarted, not started. We
2502          * simply return EAGAIN here, so that any start jobs stay
2503          * queued, and assume that the auto restart timer will
2504          * eventually trigger the restart. */
2505         if (s->state == SERVICE_AUTO_RESTART)
2506                 return -EAGAIN;
2507
2508         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2509
2510         /* Make sure we don't enter a busy loop of some kind. */
2511         r = service_start_limit_test(s);
2512         if (r < 0) {
2513                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2514                 return r;
2515         }
2516
2517         s->result = SERVICE_SUCCESS;
2518         s->reload_result = SERVICE_SUCCESS;
2519         s->main_pid_known = false;
2520         s->main_pid_alien = false;
2521         s->forbid_restart = false;
2522
2523         service_enter_start_pre(s);
2524         return 0;
2525 }
2526
2527 static int service_stop(Unit *u) {
2528         Service *s = SERVICE(u);
2529
2530         assert(s);
2531
2532         /* Don't create restart jobs from here. */
2533         s->forbid_restart = true;
2534
2535         /* Already on it */
2536         if (s->state == SERVICE_STOP ||
2537             s->state == SERVICE_STOP_SIGTERM ||
2538             s->state == SERVICE_STOP_SIGKILL ||
2539             s->state == SERVICE_STOP_POST ||
2540             s->state == SERVICE_FINAL_SIGTERM ||
2541             s->state == SERVICE_FINAL_SIGKILL)
2542                 return 0;
2543
2544         /* A restart will be scheduled or is in progress. */
2545         if (s->state == SERVICE_AUTO_RESTART) {
2546                 service_set_state(s, SERVICE_DEAD);
2547                 return 0;
2548         }
2549
2550         /* If there's already something running we go directly into
2551          * kill mode. */
2552         if (s->state == SERVICE_START_PRE ||
2553             s->state == SERVICE_START ||
2554             s->state == SERVICE_START_POST ||
2555             s->state == SERVICE_RELOAD) {
2556                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2557                 return 0;
2558         }
2559
2560         assert(s->state == SERVICE_RUNNING ||
2561                s->state == SERVICE_EXITED);
2562
2563         service_enter_stop(s, SERVICE_SUCCESS);
2564         return 0;
2565 }
2566
2567 static int service_reload(Unit *u) {
2568         Service *s = SERVICE(u);
2569
2570         assert(s);
2571
2572         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2573
2574         service_enter_reload(s);
2575         return 0;
2576 }
2577
2578 _pure_ static bool service_can_reload(Unit *u) {
2579         Service *s = SERVICE(u);
2580
2581         assert(s);
2582
2583         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2584 }
2585
2586 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2587         Service *s = SERVICE(u);
2588
2589         assert(u);
2590         assert(f);
2591         assert(fds);
2592
2593         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2594         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2595         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2596
2597         if (s->control_pid > 0)
2598                 unit_serialize_item_format(u, f, "control-pid", "%lu",
2599                                            (unsigned long) s->control_pid);
2600
2601         if (s->main_pid_known && s->main_pid > 0)
2602                 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2603
2604         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2605
2606         if (s->status_text)
2607                 unit_serialize_item(u, f, "status-text", s->status_text);
2608
2609         /* FIXME: There's a minor uncleanliness here: if there are
2610          * multiple commands attached here, we will start from the
2611          * first one again */
2612         if (s->control_command_id >= 0)
2613                 unit_serialize_item(u, f, "control-command",
2614                                     service_exec_command_to_string(s->control_command_id));
2615
2616         if (s->socket_fd >= 0) {
2617                 int copy;
2618
2619                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2620                         return copy;
2621
2622                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2623         }
2624
2625         if (s->main_exec_status.pid > 0) {
2626                 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2627                                            (unsigned long) s->main_exec_status.pid);
2628                 dual_timestamp_serialize(f, "main-exec-status-start",
2629                                          &s->main_exec_status.start_timestamp);
2630                 dual_timestamp_serialize(f, "main-exec-status-exit",
2631                                          &s->main_exec_status.exit_timestamp);
2632
2633                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2634                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2635                                                    s->main_exec_status.code);
2636                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2637                                                    s->main_exec_status.status);
2638                 }
2639         }
2640         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2641                 dual_timestamp_serialize(f, "watchdog-timestamp",
2642                                          &s->watchdog_timestamp);
2643
2644         if (s->exec_context.tmp_dir)
2645                 unit_serialize_item(u, f, "tmp-dir", s->exec_context.tmp_dir);
2646
2647         if (s->exec_context.var_tmp_dir)
2648                 unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2649
2650         return 0;
2651 }
2652
2653 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2654         Service *s = SERVICE(u);
2655
2656         assert(u);
2657         assert(key);
2658         assert(value);
2659         assert(fds);
2660
2661         if (streq(key, "state")) {
2662                 ServiceState state;
2663
2664                 state = service_state_from_string(value);
2665                 if (state < 0)
2666                         log_debug_unit(u->id, "Failed to parse state value %s", value);
2667                 else
2668                         s->deserialized_state = state;
2669         } else if (streq(key, "result")) {
2670                 ServiceResult f;
2671
2672                 f = service_result_from_string(value);
2673                 if (f < 0)
2674                         log_debug_unit(u->id, "Failed to parse result value %s", value);
2675                 else if (f != SERVICE_SUCCESS)
2676                         s->result = f;
2677
2678         } else if (streq(key, "reload-result")) {
2679                 ServiceResult f;
2680
2681                 f = service_result_from_string(value);
2682                 if (f < 0)
2683                         log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2684                 else if (f != SERVICE_SUCCESS)
2685                         s->reload_result = f;
2686
2687         } else if (streq(key, "control-pid")) {
2688                 pid_t pid;
2689
2690                 if (parse_pid(value, &pid) < 0)
2691                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2692                 else
2693                         s->control_pid = pid;
2694         } else if (streq(key, "main-pid")) {
2695                 pid_t pid;
2696
2697                 if (parse_pid(value, &pid) < 0)
2698                         log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2699                 else
2700                         service_set_main_pid(s, (pid_t) pid);
2701         } else if (streq(key, "main-pid-known")) {
2702                 int b;
2703
2704                 b = parse_boolean(value);
2705                 if (b < 0)
2706                         log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2707                 else
2708                         s->main_pid_known = b;
2709         } else if (streq(key, "status-text")) {
2710                 char *t;
2711
2712                 t = strdup(value);
2713                 if (!t)
2714                         log_oom();
2715                 else {
2716                         free(s->status_text);
2717                         s->status_text = t;
2718                 }
2719
2720         } else if (streq(key, "control-command")) {
2721                 ServiceExecCommand id;
2722
2723                 id = service_exec_command_from_string(value);
2724                 if (id < 0)
2725                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2726                 else {
2727                         s->control_command_id = id;
2728                         s->control_command = s->exec_command[id];
2729                 }
2730         } else if (streq(key, "socket-fd")) {
2731                 int fd;
2732
2733                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2734                         log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2735                 else {
2736
2737                         if (s->socket_fd >= 0)
2738                                 close_nointr_nofail(s->socket_fd);
2739                         s->socket_fd = fdset_remove(fds, fd);
2740                 }
2741         } else if (streq(key, "main-exec-status-pid")) {
2742                 pid_t pid;
2743
2744                 if (parse_pid(value, &pid) < 0)
2745                         log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2746                 else
2747                         s->main_exec_status.pid = pid;
2748         } else if (streq(key, "main-exec-status-code")) {
2749                 int i;
2750
2751                 if (safe_atoi(value, &i) < 0)
2752                         log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2753                 else
2754                         s->main_exec_status.code = i;
2755         } else if (streq(key, "main-exec-status-status")) {
2756                 int i;
2757
2758                 if (safe_atoi(value, &i) < 0)
2759                         log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2760                 else
2761                         s->main_exec_status.status = i;
2762         } else if (streq(key, "main-exec-status-start"))
2763                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2764         else if (streq(key, "main-exec-status-exit"))
2765                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2766         else if (streq(key, "watchdog-timestamp"))
2767                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2768         else if (streq(key, "tmp-dir")) {
2769                 char *t;
2770
2771                 t = strdup(value);
2772                 if (!t)
2773                         return log_oom();
2774
2775                 s->exec_context.tmp_dir = t;
2776         } else if (streq(key, "var-tmp-dir")) {
2777                 char *t;
2778
2779                 t = strdup(value);
2780                 if (!t)
2781                         return log_oom();
2782
2783                 s->exec_context.var_tmp_dir = t;
2784         } else
2785                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2786
2787         return 0;
2788 }
2789
2790 _pure_ static UnitActiveState service_active_state(Unit *u) {
2791         const UnitActiveState *table;
2792
2793         assert(u);
2794
2795         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2796
2797         return table[SERVICE(u)->state];
2798 }
2799
2800 static const char *service_sub_state_to_string(Unit *u) {
2801         assert(u);
2802
2803         return service_state_to_string(SERVICE(u)->state);
2804 }
2805
2806 static bool service_check_gc(Unit *u) {
2807         Service *s = SERVICE(u);
2808
2809         assert(s);
2810
2811         /* Never clean up services that still have a process around,
2812          * even if the service is formally dead. */
2813         if (cgroup_good(s) > 0 ||
2814             main_pid_good(s) > 0 ||
2815             control_pid_good(s) > 0)
2816                 return true;
2817
2818 #ifdef HAVE_SYSV_COMPAT
2819         if (s->is_sysv)
2820                 return true;
2821 #endif
2822
2823         return false;
2824 }
2825
2826 _pure_ static bool service_check_snapshot(Unit *u) {
2827         Service *s = SERVICE(u);
2828
2829         assert(s);
2830
2831         return !s->got_socket_fd;
2832 }
2833
2834 static int service_retry_pid_file(Service *s) {
2835         int r;
2836
2837         assert(s->pid_file);
2838         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2839
2840         r = service_load_pid_file(s, false);
2841         if (r < 0)
2842                 return r;
2843
2844         service_unwatch_pid_file(s);
2845
2846         service_enter_running(s, SERVICE_SUCCESS);
2847         return 0;
2848 }
2849
2850 static int service_watch_pid_file(Service *s) {
2851         int r;
2852
2853         log_debug_unit(UNIT(s)->id,
2854                        "Setting watch for %s's PID file %s",
2855                        UNIT(s)->id, s->pid_file_pathspec->path);
2856         r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2857         if (r < 0)
2858                 goto fail;
2859
2860         /* the pidfile might have appeared just before we set the watch */
2861         log_debug_unit(UNIT(s)->id,
2862                        "Trying to read %s's PID file %s in case it changed",
2863                        UNIT(s)->id, s->pid_file_pathspec->path);
2864         service_retry_pid_file(s);
2865
2866         return 0;
2867 fail:
2868         log_error_unit(UNIT(s)->id,
2869                        "Failed to set a watch for %s's PID file %s: %s",
2870                        UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2871         service_unwatch_pid_file(s);
2872         return r;
2873 }
2874
2875 static int service_demand_pid_file(Service *s) {
2876         PathSpec *ps;
2877
2878         assert(s->pid_file);
2879         assert(!s->pid_file_pathspec);
2880
2881         ps = new0(PathSpec, 1);
2882         if (!ps)
2883                 return -ENOMEM;
2884
2885         ps->path = strdup(s->pid_file);
2886         if (!ps->path) {
2887                 free(ps);
2888                 return -ENOMEM;
2889         }
2890
2891         path_kill_slashes(ps->path);
2892
2893         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2894          * keep their PID file open all the time. */
2895         ps->type = PATH_MODIFIED;
2896         ps->inotify_fd = -1;
2897
2898         s->pid_file_pathspec = ps;
2899
2900         return service_watch_pid_file(s);
2901 }
2902
2903 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2904         Service *s = SERVICE(u);
2905
2906         assert(s);
2907         assert(fd >= 0);
2908         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2909         assert(s->pid_file_pathspec);
2910         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2911
2912         log_debug_unit(u->id, "inotify event for %s", u->id);
2913
2914         if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2915                 goto fail;
2916
2917         if (service_retry_pid_file(s) == 0)
2918                 return;
2919
2920         if (service_watch_pid_file(s) < 0)
2921                 goto fail;
2922
2923         return;
2924 fail:
2925         service_unwatch_pid_file(s);
2926         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2927 }
2928
2929 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2930         Service *s = SERVICE(u);
2931         ServiceResult f;
2932
2933         assert(s);
2934         assert(pid >= 0);
2935
2936         if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2937                                      is_clean_exit_lsb(code, status, &s->success_status))
2938                 f = SERVICE_SUCCESS;
2939         else if (code == CLD_EXITED)
2940                 f = SERVICE_FAILURE_EXIT_CODE;
2941         else if (code == CLD_KILLED)
2942                 f = SERVICE_FAILURE_SIGNAL;
2943         else if (code == CLD_DUMPED)
2944                 f = SERVICE_FAILURE_CORE_DUMP;
2945         else
2946                 assert_not_reached("Unknown code");
2947
2948         if (s->main_pid == pid) {
2949                 /* Forking services may occasionally move to a new PID.
2950                  * As long as they update the PID file before exiting the old
2951                  * PID, they're fine. */
2952                 if (service_load_pid_file(s, false) == 0)
2953                         return;
2954
2955                 s->main_pid = 0;
2956                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2957
2958                 if (s->main_command) {
2959                         /* If this is not a forking service than the
2960                          * main process got started and hence we copy
2961                          * the exit status so that it is recorded both
2962                          * as main and as control process exit
2963                          * status */
2964
2965                         s->main_command->exec_status = s->main_exec_status;
2966
2967                         if (s->main_command->ignore)
2968                                 f = SERVICE_SUCCESS;
2969                 } else if (s->exec_command[SERVICE_EXEC_START]) {
2970
2971                         /* If this is a forked process, then we should
2972                          * ignore the return value if this was
2973                          * configured for the starter process */
2974
2975                         if (s->exec_command[SERVICE_EXEC_START]->ignore)
2976                                 f = SERVICE_SUCCESS;
2977                 }
2978
2979                 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2980                            u->id,
2981                            "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2982                                   u->id, sigchld_code_to_string(code), status,
2983                                   strna(code == CLD_EXITED
2984                                         ? exit_status_to_string(status, EXIT_STATUS_FULL)
2985                                         : signal_to_string(status)),
2986                            "EXIT_CODE=%s", sigchld_code_to_string(code),
2987                            "EXIT_STATUS=%i", status,
2988                            NULL);
2989
2990                 if (f != SERVICE_SUCCESS)
2991                         s->result = f;
2992
2993                 if (s->main_command &&
2994                     s->main_command->command_next &&
2995                     f == SERVICE_SUCCESS) {
2996
2997                         /* There is another command to *
2998                          * execute, so let's do that. */
2999
3000                         log_debug_unit(u->id,
3001                                        "%s running next main command for state %s",
3002                                        u->id, service_state_to_string(s->state));
3003                         service_run_next_main(s);
3004
3005                 } else {
3006
3007                         /* The service exited, so the service is officially
3008                          * gone. */
3009                         s->main_command = NULL;
3010
3011                         switch (s->state) {
3012
3013                         case SERVICE_START_POST:
3014                         case SERVICE_RELOAD:
3015                         case SERVICE_STOP:
3016                                 /* Need to wait until the operation is
3017                                  * done */
3018                                 break;
3019
3020                         case SERVICE_START:
3021                                 if (s->type == SERVICE_ONESHOT) {
3022                                         /* This was our main goal, so let's go on */
3023                                         if (f == SERVICE_SUCCESS)
3024                                                 service_enter_start_post(s);
3025                                         else
3026                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3027                                         break;
3028                                 }
3029
3030                                 /* Fall through */
3031
3032                         case SERVICE_RUNNING:
3033                                 service_enter_running(s, f);
3034                                 break;
3035
3036                         case SERVICE_STOP_SIGTERM:
3037                         case SERVICE_STOP_SIGKILL:
3038
3039                                 if (!control_pid_good(s))
3040                                         service_enter_stop_post(s, f);
3041
3042                                 /* If there is still a control process, wait for that first */
3043                                 break;
3044
3045                         default:
3046                                 assert_not_reached("Uh, main process died at wrong time.");
3047                         }
3048                 }
3049
3050         } else if (s->control_pid == pid) {
3051                 s->control_pid = 0;
3052
3053                 if (s->control_command) {
3054                         exec_status_exit(&s->control_command->exec_status,
3055                                          &s->exec_context, pid, code, status);
3056
3057                         if (s->control_command->ignore)
3058                                 f = SERVICE_SUCCESS;
3059                 }
3060
3061                 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3062                               "%s: control process exited, code=%s status=%i",
3063                               u->id, sigchld_code_to_string(code), status);
3064
3065                 if (f != SERVICE_SUCCESS)
3066                         s->result = f;
3067
3068                 /* Immediately get rid of the cgroup, so that the
3069                  * kernel doesn't delay the cgroup empty messages for
3070                  * the service cgroup any longer than necessary */
3071                 service_kill_control_processes(s);
3072
3073                 if (s->control_command &&
3074                     s->control_command->command_next &&
3075                     f == SERVICE_SUCCESS) {
3076
3077                         /* There is another command to *
3078                          * execute, so let's do that. */
3079
3080                         log_debug_unit(u->id,
3081                                        "%s running next control command for state %s",
3082                                        u->id, service_state_to_string(s->state));
3083                         service_run_next_control(s);
3084
3085                 } else {
3086                         /* No further commands for this step, so let's
3087                          * figure out what to do next */
3088
3089                         s->control_command = NULL;
3090                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3091
3092                         log_debug_unit(u->id,
3093                                        "%s got final SIGCHLD for state %s",
3094                                        u->id, service_state_to_string(s->state));
3095
3096                         switch (s->state) {
3097
3098                         case SERVICE_START_PRE:
3099                                 if (f == SERVICE_SUCCESS)
3100                                         service_enter_start(s);
3101                                 else
3102                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3103                                 break;
3104
3105                         case SERVICE_START:
3106                                 if (s->type != SERVICE_FORKING)
3107                                         /* Maybe spurious event due to a reload that changed the type? */
3108                                         break;
3109
3110                                 if (f != SERVICE_SUCCESS) {
3111                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3112                                         break;
3113                                 }
3114
3115                                 if (s->pid_file) {
3116                                         bool has_start_post;
3117                                         int r;
3118
3119                                         /* Let's try to load the pid file here if we can.
3120                                          * The PID file might actually be created by a START_POST
3121                                          * script. In that case don't worry if the loading fails. */
3122
3123                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3124                                         r = service_load_pid_file(s, !has_start_post);
3125                                         if (!has_start_post && r < 0) {
3126                                                 r = service_demand_pid_file(s);
3127                                                 if (r < 0 || !cgroup_good(s))
3128                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3129                                                 break;
3130                                         }
3131                                 } else
3132     &