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