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