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