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