chiark / gitweb /
systemctl: properly initialize and free sd_bus_error in "systemctl cat"
[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 %lu which is not our child. We'll most likely not notice when it exits.",
214                                  UNIT(s)->id, (unsigned long) 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         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
1142                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1143                                                       SPECIAL_BASIC_TARGET, NULL, true);
1144                 if (r < 0)
1145                         return r;
1146
1147         } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
1148                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1149                                                       SPECIAL_SOCKETS_TARGET, NULL, true);
1150                 if (r < 0)
1151                         return r;
1152
1153                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1154                                                       SPECIAL_TIMERS_TARGET, NULL, true);
1155                 if (r < 0)
1156                         return r;
1157
1158                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1159                                                       SPECIAL_PATHS_TARGET, NULL, true);
1160                 if (r < 0)
1161                         return r;
1162         }
1163
1164         /* Second, activate normal shutdown */
1165         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1166                                               SPECIAL_SHUTDOWN_TARGET, NULL, true);
1167         return r;
1168 }
1169
1170 static void service_fix_output(Service *s) {
1171         assert(s);
1172
1173         /* If nothing has been explicitly configured, patch default
1174          * output in. If input is socket/tty we avoid this however,
1175          * since in that case we want output to default to the same
1176          * place as we read input from. */
1177
1178         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1179             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1180             s->exec_context.std_input == EXEC_INPUT_NULL)
1181                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1182
1183         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1184             s->exec_context.std_input == EXEC_INPUT_NULL)
1185                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1186 }
1187
1188 static int service_load(Unit *u) {
1189         int r;
1190         Service *s = SERVICE(u);
1191
1192         assert(s);
1193
1194         /* Load a .service file */
1195         r = unit_load_fragment(u);
1196         if (r < 0)
1197                 return r;
1198
1199 #ifdef HAVE_SYSV_COMPAT
1200         /* Load a classic init script as a fallback, if we couldn't find anything */
1201         if (u->load_state == UNIT_STUB) {
1202                 r = service_load_sysv(s);
1203                 if (r < 0)
1204                         return r;
1205         }
1206 #endif
1207
1208         /* Still nothing found? Then let's give up */
1209         if (u->load_state == UNIT_STUB)
1210                 return -ENOENT;
1211
1212         /* This is a new unit? Then let's add in some extras */
1213         if (u->load_state == UNIT_LOADED) {
1214
1215                 /* We were able to load something, then let's add in
1216                  * the dropin directories. */
1217                 r = unit_load_dropin(u);
1218                 if (r < 0)
1219                         return r;
1220
1221                 if (s->type == _SERVICE_TYPE_INVALID)
1222                         s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1223
1224                 /* Oneshot services have disabled start timeout by default */
1225                 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1226                         s->timeout_start_usec = 0;
1227
1228                 service_fix_output(s);
1229
1230                 r = unit_add_exec_dependencies(u, &s->exec_context);
1231                 if (r < 0)
1232                         return r;
1233
1234                 r = unit_add_default_slice(u);
1235                 if (r < 0)
1236                         return r;
1237
1238 #ifdef HAVE_SYSV_COMPAT
1239                 r = sysv_fix_order(s);
1240                 if (r < 0)
1241                         return r;
1242 #endif
1243
1244                 if (s->bus_name) {
1245                         r = unit_watch_bus_name(u, s->bus_name);
1246                         if (r < 0)
1247                                 return r;
1248                 }
1249
1250                 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1251                         s->notify_access = NOTIFY_MAIN;
1252
1253                 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1254                         s->notify_access = NOTIFY_MAIN;
1255
1256                 if (s->type == SERVICE_DBUS || s->bus_name) {
1257                         r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true);
1258                         if (r < 0)
1259                                 return r;
1260                 }
1261
1262                 if (UNIT(s)->default_dependencies) {
1263                         r = service_add_default_dependencies(s);
1264                         if (r < 0)
1265                                 return r;
1266                 }
1267
1268                 r = unit_exec_context_defaults(u, &s->exec_context);
1269                 if (r < 0)
1270                         return r;
1271         }
1272
1273         return service_verify(s);
1274 }
1275
1276 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1277
1278         ServiceExecCommand c;
1279         Service *s = SERVICE(u);
1280         const char *prefix2;
1281         _cleanup_free_ char *p2 = NULL;
1282
1283         assert(s);
1284
1285         p2 = strappend(prefix, "\t");
1286         prefix2 = p2 ? p2 : prefix;
1287
1288         fprintf(f,
1289                 "%sService State: %s\n"
1290                 "%sResult: %s\n"
1291                 "%sReload Result: %s\n"
1292                 "%sPermissionsStartOnly: %s\n"
1293                 "%sRootDirectoryStartOnly: %s\n"
1294                 "%sRemainAfterExit: %s\n"
1295                 "%sGuessMainPID: %s\n"
1296                 "%sType: %s\n"
1297                 "%sRestart: %s\n"
1298                 "%sNotifyAccess: %s\n",
1299                 prefix, service_state_to_string(s->state),
1300                 prefix, service_result_to_string(s->result),
1301                 prefix, service_result_to_string(s->reload_result),
1302                 prefix, yes_no(s->permissions_start_only),
1303                 prefix, yes_no(s->root_directory_start_only),
1304                 prefix, yes_no(s->remain_after_exit),
1305                 prefix, yes_no(s->guess_main_pid),
1306                 prefix, service_type_to_string(s->type),
1307                 prefix, service_restart_to_string(s->restart),
1308                 prefix, notify_access_to_string(s->notify_access));
1309
1310         if (s->control_pid > 0)
1311                 fprintf(f,
1312                         "%sControl PID: %lu\n",
1313                         prefix, (unsigned long) s->control_pid);
1314
1315         if (s->main_pid > 0)
1316                 fprintf(f,
1317                         "%sMain PID: %lu\n"
1318                         "%sMain PID Known: %s\n"
1319                         "%sMain PID Alien: %s\n",
1320                         prefix, (unsigned long) s->main_pid,
1321                         prefix, yes_no(s->main_pid_known),
1322                         prefix, yes_no(s->main_pid_alien));
1323
1324         if (s->pid_file)
1325                 fprintf(f,
1326                         "%sPIDFile: %s\n",
1327                         prefix, s->pid_file);
1328
1329         if (s->bus_name)
1330                 fprintf(f,
1331                         "%sBusName: %s\n"
1332                         "%sBus Name Good: %s\n",
1333                         prefix, s->bus_name,
1334                         prefix, yes_no(s->bus_name_good));
1335
1336         kill_context_dump(&s->kill_context, f, prefix);
1337         exec_context_dump(&s->exec_context, f, prefix);
1338
1339         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1340
1341                 if (!s->exec_command[c])
1342                         continue;
1343
1344                 fprintf(f, "%s-> %s:\n",
1345                         prefix, service_exec_command_to_string(c));
1346
1347                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1348         }
1349
1350 #ifdef HAVE_SYSV_COMPAT
1351         if (s->is_sysv)
1352                 fprintf(f,
1353                         "%sSysV Init Script has LSB Header: %s\n"
1354                         "%sSysVEnabled: %s\n",
1355                         prefix, yes_no(s->sysv_has_lsb),
1356                         prefix, yes_no(s->sysv_enabled));
1357
1358         if (s->sysv_start_priority >= 0)
1359                 fprintf(f,
1360                         "%sSysVStartPriority: %i\n",
1361                         prefix, s->sysv_start_priority);
1362
1363         if (s->sysv_runlevels)
1364                 fprintf(f, "%sSysVRunLevels: %s\n",
1365                         prefix, s->sysv_runlevels);
1366 #endif
1367
1368         if (s->status_text)
1369                 fprintf(f, "%sStatus Text: %s\n",
1370                         prefix, s->status_text);
1371 }
1372
1373 static int service_load_pid_file(Service *s, bool may_warn) {
1374         _cleanup_free_ char *k = NULL;
1375         int r;
1376         pid_t pid;
1377
1378         assert(s);
1379
1380         if (!s->pid_file)
1381                 return -ENOENT;
1382
1383         r = read_one_line_file(s->pid_file, &k);
1384         if (r < 0) {
1385                 if (may_warn)
1386                         log_info_unit(UNIT(s)->id,
1387                                       "PID file %s not readable (yet?) after %s.",
1388                                       s->pid_file, service_state_to_string(s->state));
1389                 return r;
1390         }
1391
1392         r = parse_pid(k, &pid);
1393         if (r < 0) {
1394                 if (may_warn)
1395                         log_info_unit(UNIT(s)->id,
1396                                       "Failed to read PID from file %s: %s",
1397                                       s->pid_file, strerror(-r));
1398                 return r;
1399         }
1400
1401         if (kill(pid, 0) < 0 && errno != EPERM) {
1402                 if (may_warn)
1403                         log_info_unit(UNIT(s)->id,
1404                                       "PID %lu read from file %s does not exist.",
1405                                       (unsigned long) pid, s->pid_file);
1406                 return -ESRCH;
1407         }
1408
1409         if (s->main_pid_known) {
1410                 if (pid == s->main_pid)
1411                         return 0;
1412
1413                 log_debug_unit(UNIT(s)->id,
1414                                "Main PID changing: %lu -> %lu",
1415                                (unsigned long) s->main_pid, (unsigned long) pid);
1416                 service_unwatch_main_pid(s);
1417                 s->main_pid_known = false;
1418         } else
1419                 log_debug_unit(UNIT(s)->id,
1420                                "Main PID loaded: %lu", (unsigned long) pid);
1421
1422         r = service_set_main_pid(s, pid);
1423         if (r < 0)
1424                 return r;
1425
1426         r = unit_watch_pid(UNIT(s), pid);
1427         if (r < 0) {
1428                 /* FIXME: we need to do something here */
1429                 log_warning_unit(UNIT(s)->id,
1430                                  "Failed to watch PID %lu from service %s",
1431                                  (unsigned long) pid, UNIT(s)->id);
1432                 return r;
1433         }
1434
1435         return 0;
1436 }
1437
1438 static int service_search_main_pid(Service *s) {
1439         pid_t pid;
1440         int r;
1441
1442         assert(s);
1443
1444         /* If we know it anyway, don't ever fallback to unreliable
1445          * heuristics */
1446         if (s->main_pid_known)
1447                 return 0;
1448
1449         if (!s->guess_main_pid)
1450                 return 0;
1451
1452         assert(s->main_pid <= 0);
1453
1454         pid = unit_search_main_pid(UNIT(s));
1455         if (pid <= 0)
1456                 return -ENOENT;
1457
1458         log_debug_unit(UNIT(s)->id,
1459                        "Main PID guessed: %lu", (unsigned long) pid);
1460         r = service_set_main_pid(s, pid);
1461         if (r < 0)
1462                 return r;
1463
1464         r = unit_watch_pid(UNIT(s), pid);
1465         if (r < 0)
1466                 /* FIXME: we need to do something here */
1467                 log_warning_unit(UNIT(s)->id,
1468                                  "Failed to watch PID %lu from service %s",
1469                                  (unsigned long) pid, UNIT(s)->id);
1470                 return r;
1471
1472         return 0;
1473 }
1474
1475 static void service_set_state(Service *s, ServiceState state) {
1476         ServiceState old_state;
1477         const UnitActiveState *table;
1478
1479         assert(s);
1480
1481         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1482
1483         old_state = s->state;
1484         s->state = state;
1485
1486         service_unwatch_pid_file(s);
1487
1488         if (!IN_SET(state,
1489                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1490                     SERVICE_RELOAD,
1491                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1492                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1493                     SERVICE_AUTO_RESTART))
1494                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1495
1496         if (!IN_SET(state,
1497                     SERVICE_START, SERVICE_START_POST,
1498                     SERVICE_RUNNING, SERVICE_RELOAD,
1499                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL)) {
1500                 service_unwatch_main_pid(s);
1501                 s->main_command = NULL;
1502         }
1503
1504         if (!IN_SET(state,
1505                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1506                     SERVICE_RELOAD,
1507                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1508                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1509                 service_unwatch_control_pid(s);
1510                 s->control_command = NULL;
1511                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1512         }
1513
1514         if (!IN_SET(state,
1515                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1516                     SERVICE_RUNNING, SERVICE_RELOAD,
1517                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1518                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1519             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1520                 service_close_socket_fd(s);
1521                 service_connection_unref(s);
1522         }
1523
1524         if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1525                 service_stop_watchdog(s);
1526
1527         /* For the inactive states unit_notify() will trim the cgroup,
1528          * but for exit we have to do that ourselves... */
1529         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1530                 unit_destroy_cgroup(UNIT(s));
1531
1532         /* For remain_after_exit services, let's see if we can "release" the
1533          * hold on the console, since unit_notify() only does that in case of
1534          * change of state */
1535         if (state == SERVICE_EXITED && s->remain_after_exit &&
1536             UNIT(s)->manager->n_on_console > 0) {
1537                 ExecContext *ec = unit_get_exec_context(UNIT(s));
1538                 if (ec && exec_context_may_touch_console(ec)) {
1539                         Manager *m = UNIT(s)->manager;
1540
1541                         m->n_on_console --;
1542                         if (m->n_on_console == 0)
1543                                 /* unset no_console_output flag, since the console is free */
1544                                 m->no_console_output = false;
1545                 }
1546         }
1547
1548         if (old_state != state)
1549                 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1550
1551         unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1552         s->reload_result = SERVICE_SUCCESS;
1553 }
1554
1555 static int service_coldplug(Unit *u) {
1556         Service *s = SERVICE(u);
1557         int r;
1558
1559         assert(s);
1560         assert(s->state == SERVICE_DEAD);
1561
1562         if (s->deserialized_state != s->state) {
1563
1564                 if (s->deserialized_state == SERVICE_START_PRE ||
1565                     s->deserialized_state == SERVICE_START ||
1566                     s->deserialized_state == SERVICE_START_POST ||
1567                     s->deserialized_state == SERVICE_RELOAD ||
1568                     s->deserialized_state == SERVICE_STOP ||
1569                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1570                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1571                     s->deserialized_state == SERVICE_STOP_POST ||
1572                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1573                     s->deserialized_state == SERVICE_FINAL_SIGKILL) {
1574
1575                         usec_t k;
1576
1577                         k = s->deserialized_state == SERVICE_START_PRE || s->deserialized_state == SERVICE_START ||
1578                                 s->deserialized_state == SERVICE_START_POST || s->deserialized_state == SERVICE_RELOAD ?
1579                                 s->timeout_start_usec : s->timeout_stop_usec;
1580
1581                         /* For the start/stop timeouts 0 means off */
1582                         if (k > 0) {
1583                                 r = service_arm_timer(s, k);
1584                                 if (r < 0)
1585                                         return r;
1586                         }
1587                 }
1588
1589                 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
1590
1591                         /* The restart timeouts 0 means immediately */
1592                         r = service_arm_timer(s, s->restart_usec);
1593                         if (r < 0)
1594                                 return r;
1595                 }
1596
1597                 if ((s->deserialized_state == SERVICE_START &&
1598                      (s->type == SERVICE_FORKING ||
1599                       s->type == SERVICE_DBUS ||
1600                       s->type == SERVICE_ONESHOT ||
1601                       s->type == SERVICE_NOTIFY)) ||
1602                     s->deserialized_state == SERVICE_START_POST ||
1603                     s->deserialized_state == SERVICE_RUNNING ||
1604                     s->deserialized_state == SERVICE_RELOAD ||
1605                     s->deserialized_state == SERVICE_STOP ||
1606                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1607                     s->deserialized_state == SERVICE_STOP_SIGKILL)
1608                         if (s->main_pid > 0) {
1609                                 r = unit_watch_pid(UNIT(s), s->main_pid);
1610                                 if (r < 0)
1611                                         return r;
1612                         }
1613
1614                 if (s->deserialized_state == SERVICE_START_PRE ||
1615                     s->deserialized_state == SERVICE_START ||
1616                     s->deserialized_state == SERVICE_START_POST ||
1617                     s->deserialized_state == SERVICE_RELOAD ||
1618                     s->deserialized_state == SERVICE_STOP ||
1619                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1620                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1621                     s->deserialized_state == SERVICE_STOP_POST ||
1622                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1623                     s->deserialized_state == SERVICE_FINAL_SIGKILL)
1624                         if (s->control_pid > 0) {
1625                                 r = unit_watch_pid(UNIT(s), s->control_pid);
1626                                 if (r < 0)
1627                                         return r;
1628                         }
1629
1630                 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1631                         service_start_watchdog(s);
1632
1633                 service_set_state(s, s->deserialized_state);
1634         }
1635
1636         return 0;
1637 }
1638
1639 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1640         Iterator i;
1641         int r;
1642         int *rfds = NULL;
1643         unsigned rn_fds = 0;
1644         Unit *u;
1645
1646         assert(s);
1647         assert(fds);
1648         assert(n_fds);
1649
1650         if (s->socket_fd >= 0)
1651                 return 0;
1652
1653         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1654                 int *cfds;
1655                 unsigned cn_fds;
1656                 Socket *sock;
1657
1658                 if (u->type != UNIT_SOCKET)
1659                         continue;
1660
1661                 sock = SOCKET(u);
1662
1663                 r = socket_collect_fds(sock, &cfds, &cn_fds);
1664                 if (r < 0)
1665                         goto fail;
1666
1667                 if (!cfds)
1668                         continue;
1669
1670                 if (!rfds) {
1671                         rfds = cfds;
1672                         rn_fds = cn_fds;
1673                 } else {
1674                         int *t;
1675
1676                         t = new(int, rn_fds+cn_fds);
1677                         if (!t) {
1678                                 free(cfds);
1679                                 r = -ENOMEM;
1680                                 goto fail;
1681                         }
1682
1683                         memcpy(t, rfds, rn_fds * sizeof(int));
1684                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1685                         free(rfds);
1686                         free(cfds);
1687
1688                         rfds = t;
1689                         rn_fds = rn_fds+cn_fds;
1690                 }
1691         }
1692
1693         *fds = rfds;
1694         *n_fds = rn_fds;
1695
1696         return 0;
1697
1698 fail:
1699         free(rfds);
1700
1701         return r;
1702 }
1703
1704 static int service_spawn(
1705                 Service *s,
1706                 ExecCommand *c,
1707                 bool timeout,
1708                 bool pass_fds,
1709                 bool apply_permissions,
1710                 bool apply_chroot,
1711                 bool apply_tty_stdin,
1712                 bool set_notify_socket,
1713                 bool is_control,
1714                 pid_t *_pid) {
1715
1716         pid_t pid;
1717         int r;
1718         int *fds = NULL;
1719         _cleanup_free_ int *fdsbuf = NULL;
1720         unsigned n_fds = 0, n_env = 0;
1721         _cleanup_strv_free_ char
1722                 **argv = NULL, **final_env = NULL, **our_env = NULL;
1723         const char *path;
1724
1725         assert(s);
1726         assert(c);
1727         assert(_pid);
1728
1729         unit_realize_cgroup(UNIT(s));
1730
1731         r = unit_setup_exec_runtime(UNIT(s));
1732         if (r < 0)
1733                 goto fail;
1734
1735         if (pass_fds ||
1736             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1737             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1738             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1739
1740                 if (s->socket_fd >= 0) {
1741                         fds = &s->socket_fd;
1742                         n_fds = 1;
1743                 } else {
1744                         r = service_collect_fds(s, &fdsbuf, &n_fds);
1745                         if (r < 0)
1746                                 goto fail;
1747
1748                         fds = fdsbuf;
1749                 }
1750         }
1751
1752         if (timeout && s->timeout_start_usec > 0) {
1753                 r = service_arm_timer(s, s->timeout_start_usec);
1754                 if (r < 0)
1755                         goto fail;
1756         } else
1757                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1758
1759         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1760         if (r < 0)
1761                 goto fail;
1762
1763         our_env = new0(char*, 5);
1764         if (!our_env) {
1765                 r = -ENOMEM;
1766                 goto fail;
1767         }
1768
1769         if (set_notify_socket)
1770                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1771                         r = -ENOMEM;
1772                         goto fail;
1773                 }
1774
1775         if (s->main_pid > 0)
1776                 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1777                         r = -ENOMEM;
1778                         goto fail;
1779                 }
1780
1781         if (s->watchdog_usec > 0)
1782                 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1783                         r = -ENOMEM;
1784                         goto fail;
1785                 }
1786
1787         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1788                 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1789                         r = -ENOMEM;
1790                         goto fail;
1791                 }
1792
1793         final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1794         if (!final_env) {
1795                 r = -ENOMEM;
1796                 goto fail;
1797         }
1798
1799         if (is_control && UNIT(s)->cgroup_path) {
1800                 path = strappenda(UNIT(s)->cgroup_path, "/control");
1801                 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1802         } else
1803                 path = UNIT(s)->cgroup_path;
1804
1805         r = exec_spawn(c,
1806                        argv,
1807                        &s->exec_context,
1808                        fds, n_fds,
1809                        final_env,
1810                        apply_permissions,
1811                        apply_chroot,
1812                        apply_tty_stdin,
1813                        UNIT(s)->manager->confirm_spawn,
1814                        UNIT(s)->manager->cgroup_supported,
1815                        path,
1816                        UNIT(s)->id,
1817                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1818                        s->exec_runtime,
1819                        &pid);
1820         if (r < 0)
1821                 goto fail;
1822
1823         r = unit_watch_pid(UNIT(s), pid);
1824         if (r < 0)
1825                 /* FIXME: we need to do something here */
1826                 goto fail;
1827
1828         *_pid = pid;
1829
1830         return 0;
1831
1832 fail:
1833         if (timeout)
1834                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1835
1836         return r;
1837 }
1838
1839 static int main_pid_good(Service *s) {
1840         assert(s);
1841
1842         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1843          * don't know */
1844
1845         /* If we know the pid file, then lets just check if it is
1846          * still valid */
1847         if (s->main_pid_known) {
1848
1849                 /* If it's an alien child let's check if it is still
1850                  * alive ... */
1851                 if (s->main_pid_alien && s->main_pid > 0)
1852                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1853
1854                 /* .. otherwise assume we'll get a SIGCHLD for it,
1855                  * which we really should wait for to collect exit
1856                  * status and code */
1857                 return s->main_pid > 0;
1858         }
1859
1860         /* We don't know the pid */
1861         return -EAGAIN;
1862 }
1863
1864 _pure_ static int control_pid_good(Service *s) {
1865         assert(s);
1866
1867         return s->control_pid > 0;
1868 }
1869
1870 static int cgroup_good(Service *s) {
1871         int r;
1872
1873         assert(s);
1874
1875         if (!UNIT(s)->cgroup_path)
1876                 return 0;
1877
1878         r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1879         if (r < 0)
1880                 return r;
1881
1882         return !r;
1883 }
1884
1885 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1886         int r;
1887         assert(s);
1888
1889         if (f != SERVICE_SUCCESS)
1890                 s->result = f;
1891
1892         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1893
1894         if (allow_restart &&
1895             !s->forbid_restart &&
1896             (s->restart == SERVICE_RESTART_ALWAYS ||
1897              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1898              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1899              (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1900              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1901                                                          s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1902             (s->result != SERVICE_FAILURE_EXIT_CODE ||
1903              !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1904             (s->result != SERVICE_FAILURE_SIGNAL ||
1905              !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1906
1907                 r = service_arm_timer(s, s->restart_usec);
1908                 if (r < 0)
1909                         goto fail;
1910
1911                 service_set_state(s, SERVICE_AUTO_RESTART);
1912         }
1913
1914         s->forbid_restart = false;
1915
1916         /* we want fresh tmpdirs in case service is started again immediately */
1917         exec_runtime_destroy(s->exec_runtime);
1918         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1919
1920         /* Try to delete the pid file. At this point it will be
1921          * out-of-date, and some software might be confused by it, so
1922          * let's remove it. */
1923         if (s->pid_file)
1924                 unlink_noerrno(s->pid_file);
1925
1926         return;
1927
1928 fail:
1929         log_warning_unit(UNIT(s)->id,
1930                          "%s failed to run install restart timer: %s",
1931                          UNIT(s)->id, strerror(-r));
1932         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1933 }
1934
1935 static void service_enter_stop_post(Service *s, ServiceResult f) {
1936         int r;
1937         assert(s);
1938
1939         if (f != SERVICE_SUCCESS)
1940                 s->result = f;
1941
1942         service_unwatch_control_pid(s);
1943
1944         s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1945         if (s->control_command) {
1946                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1947
1948                 r = service_spawn(s,
1949                                   s->control_command,
1950                                   true,
1951                                   false,
1952                                   !s->permissions_start_only,
1953                                   !s->root_directory_start_only,
1954                                   true,
1955                                   false,
1956                                   true,
1957                                   &s->control_pid);
1958                 if (r < 0)
1959                         goto fail;
1960
1961
1962                 service_set_state(s, SERVICE_STOP_POST);
1963         } else
1964                 service_enter_dead(s, SERVICE_SUCCESS, true);
1965
1966         return;
1967
1968 fail:
1969         log_warning_unit(UNIT(s)->id,
1970                          "%s failed to run 'stop-post' task: %s",
1971                          UNIT(s)->id, strerror(-r));
1972         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1973 }
1974
1975 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1976         int r;
1977
1978         assert(s);
1979
1980         if (f != SERVICE_SUCCESS)
1981                 s->result = f;
1982
1983         r = unit_kill_context(
1984                         UNIT(s),
1985                         &s->kill_context,
1986                         state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1987                         s->main_pid,
1988                         s->control_pid,
1989                         s->main_pid_alien);
1990         if (r < 0)
1991                 goto fail;
1992
1993         if (r > 0) {
1994                 if (s->timeout_stop_usec > 0) {
1995                         r = service_arm_timer(s, s->timeout_stop_usec);
1996                         if (r < 0)
1997                                 goto fail;
1998                 }
1999
2000                 service_set_state(s, state);
2001         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2002                 service_enter_stop_post(s, SERVICE_SUCCESS);
2003         else
2004                 service_enter_dead(s, SERVICE_SUCCESS, true);
2005
2006         return;
2007
2008 fail:
2009         log_warning_unit(UNIT(s)->id,
2010                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2011
2012         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2013                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2014         else
2015                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2016 }
2017
2018 static void service_enter_stop(Service *s, ServiceResult f) {
2019         int r;
2020
2021         assert(s);
2022
2023         if (f != SERVICE_SUCCESS)
2024                 s->result = f;
2025
2026         service_unwatch_control_pid(s);
2027
2028         s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2029         if (s->control_command) {
2030                 s->control_command_id = SERVICE_EXEC_STOP;
2031
2032                 r = service_spawn(s,
2033                                   s->control_command,
2034                                   true,
2035                                   false,
2036                                   !s->permissions_start_only,
2037                                   !s->root_directory_start_only,
2038                                   false,
2039                                   false,
2040                                   true,
2041                                   &s->control_pid);
2042                 if (r < 0)
2043                         goto fail;
2044
2045                 service_set_state(s, SERVICE_STOP);
2046         } else
2047                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2048
2049         return;
2050
2051 fail:
2052         log_warning_unit(UNIT(s)->id,
2053                          "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2054         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2055 }
2056
2057 static void service_enter_running(Service *s, ServiceResult f) {
2058         int main_pid_ok, cgroup_ok;
2059         assert(s);
2060
2061         if (f != SERVICE_SUCCESS)
2062                 s->result = f;
2063
2064         main_pid_ok = main_pid_good(s);
2065         cgroup_ok = cgroup_good(s);
2066
2067         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2068             (s->bus_name_good || s->type != SERVICE_DBUS))
2069                 service_set_state(s, SERVICE_RUNNING);
2070         else if (s->remain_after_exit)
2071                 service_set_state(s, SERVICE_EXITED);
2072         else
2073                 service_enter_stop(s, SERVICE_SUCCESS);
2074 }
2075
2076 static void service_enter_start_post(Service *s) {
2077         int r;
2078         assert(s);
2079
2080         service_unwatch_control_pid(s);
2081         service_reset_watchdog(s);
2082
2083         s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2084         if (s->control_command) {
2085                 s->control_command_id = SERVICE_EXEC_START_POST;
2086
2087                 r = service_spawn(s,
2088                                   s->control_command,
2089                                   true,
2090                                   false,
2091                                   !s->permissions_start_only,
2092                                   !s->root_directory_start_only,
2093                                   false,
2094                                   false,
2095                                   true,
2096                                   &s->control_pid);
2097                 if (r < 0)
2098                         goto fail;
2099
2100                 service_set_state(s, SERVICE_START_POST);
2101         } else
2102                 service_enter_running(s, SERVICE_SUCCESS);
2103
2104         return;
2105
2106 fail:
2107         log_warning_unit(UNIT(s)->id,
2108                          "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2109         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2110 }
2111
2112 static void service_kill_control_processes(Service *s) {
2113         char *p;
2114
2115         if (!UNIT(s)->cgroup_path)
2116                 return;
2117
2118         p = strappenda(UNIT(s)->cgroup_path, "/control");
2119         cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2120 }
2121
2122 static void service_enter_start(Service *s) {
2123         ExecCommand *c;
2124         pid_t pid;
2125         int r;
2126
2127         assert(s);
2128
2129         assert(s->exec_command[SERVICE_EXEC_START]);
2130         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2131
2132         service_unwatch_control_pid(s);
2133         service_unwatch_main_pid(s);
2134
2135         /* We want to ensure that nobody leaks processes from
2136          * START_PRE here, so let's go on a killing spree, People
2137          * should not spawn long running processes from START_PRE. */
2138         service_kill_control_processes(s);
2139
2140         if (s->type == SERVICE_FORKING) {
2141                 s->control_command_id = SERVICE_EXEC_START;
2142                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2143
2144                 s->main_command = NULL;
2145         } else {
2146                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2147                 s->control_command = NULL;
2148
2149                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2150         }
2151
2152         r = service_spawn(s,
2153                           c,
2154                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2155                             s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2156                           true,
2157                           true,
2158                           true,
2159                           true,
2160                           s->notify_access != NOTIFY_NONE,
2161                           false,
2162                           &pid);
2163         if (r < 0)
2164                 goto fail;
2165
2166         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2167                 /* For simple services we immediately start
2168                  * the START_POST binaries. */
2169
2170                 service_set_main_pid(s, pid);
2171                 service_enter_start_post(s);
2172
2173         } else  if (s->type == SERVICE_FORKING) {
2174
2175                 /* For forking services we wait until the start
2176                  * process exited. */
2177
2178                 s->control_pid = pid;
2179                 service_set_state(s, SERVICE_START);
2180
2181         } else if (s->type == SERVICE_ONESHOT ||
2182                    s->type == SERVICE_DBUS ||
2183                    s->type == SERVICE_NOTIFY) {
2184
2185                 /* For oneshot services we wait until the start
2186                  * process exited, too, but it is our main process. */
2187
2188                 /* For D-Bus services we know the main pid right away,
2189                  * but wait for the bus name to appear on the
2190                  * bus. Notify services are similar. */
2191
2192                 service_set_main_pid(s, pid);
2193                 service_set_state(s, SERVICE_START);
2194         } else
2195                 assert_not_reached("Unknown service type");
2196
2197         return;
2198
2199 fail:
2200         log_warning_unit(UNIT(s)->id,
2201                          "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2202         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2203 }
2204
2205 static void service_enter_start_pre(Service *s) {
2206         int r;
2207
2208         assert(s);
2209
2210         service_unwatch_control_pid(s);
2211
2212         s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2213         if (s->control_command) {
2214                 /* Before we start anything, let's clear up what might
2215                  * be left from previous runs. */
2216                 service_kill_control_processes(s);
2217
2218                 s->control_command_id = SERVICE_EXEC_START_PRE;
2219
2220                 r = service_spawn(s,
2221                                   s->control_command,
2222                                   true,
2223                                   false,
2224                                   !s->permissions_start_only,
2225                                   !s->root_directory_start_only,
2226                                   true,
2227                                   false,
2228                                   true,
2229                                   &s->control_pid);
2230                 if (r < 0)
2231                         goto fail;
2232
2233                 service_set_state(s, SERVICE_START_PRE);
2234         } else
2235                 service_enter_start(s);
2236
2237         return;
2238
2239 fail:
2240         log_warning_unit(UNIT(s)->id,
2241                          "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2242         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2243 }
2244
2245 static void service_enter_restart(Service *s) {
2246         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2247         int r;
2248
2249         assert(s);
2250
2251         if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2252                 /* Don't restart things if we are going down anyway */
2253                 log_info_unit(UNIT(s)->id,
2254                               "Stop job pending for unit, delaying automatic restart.");
2255
2256                 r = service_arm_timer(s, s->restart_usec);
2257                 if (r < 0)
2258                         goto fail;
2259
2260                 return;
2261         }
2262
2263         /* Any units that are bound to this service must also be
2264          * restarted. We use JOB_RESTART (instead of the more obvious
2265          * JOB_START) here so that those dependency jobs will be added
2266          * as well. */
2267         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2268         if (r < 0)
2269                 goto fail;
2270
2271         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2272          * it will be canceled as part of the service_stop() call that
2273          * is executed as part of JOB_RESTART. */
2274
2275         log_debug_unit(UNIT(s)->id,
2276                        "%s scheduled restart job.", UNIT(s)->id);
2277         return;
2278
2279 fail:
2280         log_warning_unit(UNIT(s)->id,
2281                          "%s failed to schedule restart job: %s",
2282                          UNIT(s)->id, bus_error_message(&error, -r));
2283         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2284 }
2285
2286 static void service_enter_reload(Service *s) {
2287         int r;
2288
2289         assert(s);
2290
2291         service_unwatch_control_pid(s);
2292
2293         s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2294         if (s->control_command) {
2295                 s->control_command_id = SERVICE_EXEC_RELOAD;
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                                   false,
2304                                   false,
2305                                   true,
2306                                   &s->control_pid);
2307                 if (r < 0)
2308                         goto fail;
2309
2310                 service_set_state(s, SERVICE_RELOAD);
2311         } else
2312                 service_enter_running(s, SERVICE_SUCCESS);
2313
2314         return;
2315
2316 fail:
2317         log_warning_unit(UNIT(s)->id,
2318                          "%s failed to run 'reload' task: %s",
2319                          UNIT(s)->id, strerror(-r));
2320         s->reload_result = SERVICE_FAILURE_RESOURCES;
2321         service_enter_running(s, SERVICE_SUCCESS);
2322 }
2323
2324 static void service_run_next_control(Service *s) {
2325         int r;
2326
2327         assert(s);
2328         assert(s->control_command);
2329         assert(s->control_command->command_next);
2330
2331         assert(s->control_command_id != SERVICE_EXEC_START);
2332
2333         s->control_command = s->control_command->command_next;
2334         service_unwatch_control_pid(s);
2335
2336         r = service_spawn(s,
2337                           s->control_command,
2338                           true,
2339                           false,
2340                           !s->permissions_start_only,
2341                           !s->root_directory_start_only,
2342                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2343                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2344                           false,
2345                           true,
2346                           &s->control_pid);
2347         if (r < 0)
2348                 goto fail;
2349
2350         return;
2351
2352 fail:
2353         log_warning_unit(UNIT(s)->id,
2354                          "%s failed to run next control task: %s",
2355                          UNIT(s)->id, strerror(-r));
2356
2357         if (s->state == SERVICE_START_PRE)
2358                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2359         else if (s->state == SERVICE_STOP)
2360                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2361         else if (s->state == SERVICE_STOP_POST)
2362                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2363         else if (s->state == SERVICE_RELOAD) {
2364                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2365                 service_enter_running(s, SERVICE_SUCCESS);
2366         } else
2367                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2368 }
2369
2370 static void service_run_next_main(Service *s) {
2371         pid_t pid;
2372         int r;
2373
2374         assert(s);
2375         assert(s->main_command);
2376         assert(s->main_command->command_next);
2377         assert(s->type == SERVICE_ONESHOT);
2378
2379         s->main_command = s->main_command->command_next;
2380         service_unwatch_main_pid(s);
2381
2382         r = service_spawn(s,
2383                           s->main_command,
2384                           true,
2385                           true,
2386                           true,
2387                           true,
2388                           true,
2389                           s->notify_access != NOTIFY_NONE,
2390                           false,
2391                           &pid);
2392         if (r < 0)
2393                 goto fail;
2394
2395         service_set_main_pid(s, pid);
2396
2397         return;
2398
2399 fail:
2400         log_warning_unit(UNIT(s)->id,
2401                          "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2402         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2403 }
2404
2405 static int service_start_limit_test(Service *s) {
2406         assert(s);
2407
2408         if (ratelimit_test(&s->start_limit))
2409                 return 0;
2410
2411         switch (s->start_limit_action) {
2412
2413         case SERVICE_START_LIMIT_NONE:
2414                 log_warning_unit(UNIT(s)->id,
2415                                  "%s start request repeated too quickly, refusing to start.",
2416                                  UNIT(s)->id);
2417                 break;
2418
2419         case SERVICE_START_LIMIT_REBOOT: {
2420                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2421                 int r;
2422
2423                 log_warning_unit(UNIT(s)->id,
2424                                  "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2425
2426                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2427                                             SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2428                                             true, &error, NULL);
2429                 if (r < 0)
2430                         log_error_unit(UNIT(s)->id,
2431                                        "Failed to reboot: %s.", bus_error_message(&error, r));
2432
2433                 break;
2434         }
2435
2436         case SERVICE_START_LIMIT_REBOOT_FORCE:
2437                 log_warning_unit(UNIT(s)->id,
2438                                  "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2439                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2440                 break;
2441
2442         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2443                 log_warning_unit(UNIT(s)->id,
2444                                  "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2445                 sync();
2446                 reboot(RB_AUTOBOOT);
2447                 break;
2448
2449         default:
2450                 log_error_unit(UNIT(s)->id,
2451                                "start limit action=%i", s->start_limit_action);
2452                 assert_not_reached("Unknown StartLimitAction.");
2453         }
2454
2455         return -ECANCELED;
2456 }
2457
2458 static int service_start(Unit *u) {
2459         Service *s = SERVICE(u);
2460         int r;
2461
2462         assert(s);
2463
2464         /* We cannot fulfill this request right now, try again later
2465          * please! */
2466         if (s->state == SERVICE_STOP ||
2467             s->state == SERVICE_STOP_SIGTERM ||
2468             s->state == SERVICE_STOP_SIGKILL ||
2469             s->state == SERVICE_STOP_POST ||
2470             s->state == SERVICE_FINAL_SIGTERM ||
2471             s->state == SERVICE_FINAL_SIGKILL)
2472                 return -EAGAIN;
2473
2474         /* Already on it! */
2475         if (s->state == SERVICE_START_PRE ||
2476             s->state == SERVICE_START ||
2477             s->state == SERVICE_START_POST)
2478                 return 0;
2479
2480         /* A service that will be restarted must be stopped first to
2481          * trigger BindsTo and/or OnFailure dependencies. If a user
2482          * does not want to wait for the holdoff time to elapse, the
2483          * service should be manually restarted, not started. We
2484          * simply return EAGAIN here, so that any start jobs stay
2485          * queued, and assume that the auto restart timer will
2486          * eventually trigger the restart. */
2487         if (s->state == SERVICE_AUTO_RESTART)
2488                 return -EAGAIN;
2489
2490         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2491
2492         /* Make sure we don't enter a busy loop of some kind. */
2493         r = service_start_limit_test(s);
2494         if (r < 0) {
2495                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2496                 return r;
2497         }
2498
2499         s->result = SERVICE_SUCCESS;
2500         s->reload_result = SERVICE_SUCCESS;
2501         s->main_pid_known = false;
2502         s->main_pid_alien = false;
2503         s->forbid_restart = false;
2504
2505         service_enter_start_pre(s);
2506         return 0;
2507 }
2508
2509 static int service_stop(Unit *u) {
2510         Service *s = SERVICE(u);
2511
2512         assert(s);
2513
2514         /* Don't create restart jobs from here. */
2515         s->forbid_restart = true;
2516
2517         /* Already on it */
2518         if (s->state == SERVICE_STOP ||
2519             s->state == SERVICE_STOP_SIGTERM ||
2520             s->state == SERVICE_STOP_SIGKILL ||
2521             s->state == SERVICE_STOP_POST ||
2522             s->state == SERVICE_FINAL_SIGTERM ||
2523             s->state == SERVICE_FINAL_SIGKILL)
2524                 return 0;
2525
2526         /* A restart will be scheduled or is in progress. */
2527         if (s->state == SERVICE_AUTO_RESTART) {
2528                 service_set_state(s, SERVICE_DEAD);
2529                 return 0;
2530         }
2531
2532         /* If there's already something running we go directly into
2533          * kill mode. */
2534         if (s->state == SERVICE_START_PRE ||
2535             s->state == SERVICE_START ||
2536             s->state == SERVICE_START_POST ||
2537             s->state == SERVICE_RELOAD) {
2538                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2539                 return 0;
2540         }
2541
2542         assert(s->state == SERVICE_RUNNING ||
2543                s->state == SERVICE_EXITED);
2544
2545         service_enter_stop(s, SERVICE_SUCCESS);
2546         return 0;
2547 }
2548
2549 static int service_reload(Unit *u) {
2550         Service *s = SERVICE(u);
2551
2552         assert(s);
2553
2554         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2555
2556         service_enter_reload(s);
2557         return 0;
2558 }
2559
2560 _pure_ static bool service_can_reload(Unit *u) {
2561         Service *s = SERVICE(u);
2562
2563         assert(s);
2564
2565         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2566 }
2567
2568 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2569         Service *s = SERVICE(u);
2570
2571         assert(u);
2572         assert(f);
2573         assert(fds);
2574
2575         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2576         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2577         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2578
2579         if (s->control_pid > 0)
2580                 unit_serialize_item_format(u, f, "control-pid", "%lu",
2581                                            (unsigned long) s->control_pid);
2582
2583         if (s->main_pid_known && s->main_pid > 0)
2584                 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2585
2586         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2587
2588         if (s->status_text)
2589                 unit_serialize_item(u, f, "status-text", s->status_text);
2590
2591         /* FIXME: There's a minor uncleanliness here: if there are
2592          * multiple commands attached here, we will start from the
2593          * first one again */
2594         if (s->control_command_id >= 0)
2595                 unit_serialize_item(u, f, "control-command",
2596                                     service_exec_command_to_string(s->control_command_id));
2597
2598         if (s->socket_fd >= 0) {
2599                 int copy;
2600
2601                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2602                         return copy;
2603
2604                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2605         }
2606
2607         if (s->main_exec_status.pid > 0) {
2608                 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2609                                            (unsigned long) s->main_exec_status.pid);
2610                 dual_timestamp_serialize(f, "main-exec-status-start",
2611                                          &s->main_exec_status.start_timestamp);
2612                 dual_timestamp_serialize(f, "main-exec-status-exit",
2613                                          &s->main_exec_status.exit_timestamp);
2614
2615                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2616                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2617                                                    s->main_exec_status.code);
2618                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2619                                                    s->main_exec_status.status);
2620                 }
2621         }
2622         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2623                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2624
2625         if (s->forbid_restart)
2626                 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2627
2628         return 0;
2629 }
2630
2631 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2632         Service *s = SERVICE(u);
2633
2634         assert(u);
2635         assert(key);
2636         assert(value);
2637         assert(fds);
2638
2639         if (streq(key, "state")) {
2640                 ServiceState state;
2641
2642                 state = service_state_from_string(value);
2643                 if (state < 0)
2644                         log_debug_unit(u->id, "Failed to parse state value %s", value);
2645                 else
2646                         s->deserialized_state = state;
2647         } else if (streq(key, "result")) {
2648                 ServiceResult f;
2649
2650                 f = service_result_from_string(value);
2651                 if (f < 0)
2652                         log_debug_unit(u->id, "Failed to parse result value %s", value);
2653                 else if (f != SERVICE_SUCCESS)
2654                         s->result = f;
2655
2656         } else if (streq(key, "reload-result")) {
2657                 ServiceResult f;
2658
2659                 f = service_result_from_string(value);
2660                 if (f < 0)
2661                         log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2662                 else if (f != SERVICE_SUCCESS)
2663                         s->reload_result = f;
2664
2665         } else if (streq(key, "control-pid")) {
2666                 pid_t pid;
2667
2668                 if (parse_pid(value, &pid) < 0)
2669                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2670                 else
2671                         s->control_pid = pid;
2672         } else if (streq(key, "main-pid")) {
2673                 pid_t pid;
2674
2675                 if (parse_pid(value, &pid) < 0)
2676                         log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2677                 else {
2678                         service_set_main_pid(s, pid);
2679                         unit_watch_pid(UNIT(s), pid);
2680                 }
2681         } else if (streq(key, "main-pid-known")) {
2682                 int b;
2683
2684                 b = parse_boolean(value);
2685                 if (b < 0)
2686                         log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2687                 else
2688                         s->main_pid_known = b;
2689         } else if (streq(key, "status-text")) {
2690                 char *t;
2691
2692                 t = strdup(value);
2693                 if (!t)
2694                         log_oom();
2695                 else {
2696                         free(s->status_text);
2697                         s->status_text = t;
2698                 }
2699
2700         } else if (streq(key, "control-command")) {
2701                 ServiceExecCommand id;
2702
2703                 id = service_exec_command_from_string(value);
2704                 if (id < 0)
2705                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2706                 else {
2707                         s->control_command_id = id;
2708                         s->control_command = s->exec_command[id];
2709                 }
2710         } else if (streq(key, "socket-fd")) {
2711                 int fd;
2712
2713                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2714                         log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2715                 else {
2716
2717                         if (s->socket_fd >= 0)
2718                                 close_nointr_nofail(s->socket_fd);
2719                         s->socket_fd = fdset_remove(fds, fd);
2720                 }
2721         } else if (streq(key, "main-exec-status-pid")) {
2722                 pid_t pid;
2723
2724                 if (parse_pid(value, &pid) < 0)
2725                         log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2726                 else
2727                         s->main_exec_status.pid = pid;
2728         } else if (streq(key, "main-exec-status-code")) {
2729                 int i;
2730
2731                 if (safe_atoi(value, &i) < 0)
2732                         log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2733                 else
2734                         s->main_exec_status.code = i;
2735         } else if (streq(key, "main-exec-status-status")) {
2736                 int i;
2737
2738                 if (safe_atoi(value, &i) < 0)
2739                         log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2740                 else
2741                         s->main_exec_status.status = i;
2742         } else if (streq(key, "main-exec-status-start"))
2743                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2744         else if (streq(key, "main-exec-status-exit"))
2745                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2746         else if (streq(key, "watchdog-timestamp"))
2747                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2748         else if (streq(key, "forbid-restart")) {
2749                 int b;
2750
2751                 b = parse_boolean(value);
2752                 if (b < 0)
2753                         log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2754                 else
2755                         s->forbid_restart = b;
2756         } else
2757                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2758
2759         return 0;
2760 }
2761
2762 _pure_ static UnitActiveState service_active_state(Unit *u) {
2763         const UnitActiveState *table;
2764
2765         assert(u);
2766
2767         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2768
2769         return table[SERVICE(u)->state];
2770 }
2771
2772 static const char *service_sub_state_to_string(Unit *u) {
2773         assert(u);
2774
2775         return service_state_to_string(SERVICE(u)->state);
2776 }
2777
2778 static bool service_check_gc(Unit *u) {
2779         Service *s = SERVICE(u);
2780
2781         assert(s);
2782
2783         /* Never clean up services that still have a process around,
2784          * even if the service is formally dead. */
2785         if (cgroup_good(s) > 0 ||
2786             main_pid_good(s) > 0 ||
2787             control_pid_good(s) > 0)
2788                 return true;
2789
2790 #ifdef HAVE_SYSV_COMPAT
2791         if (s->is_sysv)
2792                 return true;
2793 #endif
2794
2795         return false;
2796 }
2797
2798 _pure_ static bool service_check_snapshot(Unit *u) {
2799         Service *s = SERVICE(u);
2800
2801         assert(s);
2802
2803         return (s->socket_fd < 0);
2804 }
2805
2806 static int service_retry_pid_file(Service *s) {
2807         int r;
2808
2809         assert(s->pid_file);
2810         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2811
2812         r = service_load_pid_file(s, false);
2813         if (r < 0)
2814                 return r;
2815
2816         service_unwatch_pid_file(s);
2817
2818         service_enter_running(s, SERVICE_SUCCESS);
2819         return 0;
2820 }
2821
2822 static int service_watch_pid_file(Service *s) {
2823         int r;
2824
2825         log_debug_unit(UNIT(s)->id,
2826                        "Setting watch for %s's PID file %s",
2827                        UNIT(s)->id, s->pid_file_pathspec->path);
2828         r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2829         if (r < 0)
2830                 goto fail;
2831
2832         /* the pidfile might have appeared just before we set the watch */
2833         log_debug_unit(UNIT(s)->id,
2834                        "Trying to read %s's PID file %s in case it changed",
2835                        UNIT(s)->id, s->pid_file_pathspec->path);
2836         service_retry_pid_file(s);
2837
2838         return 0;
2839 fail:
2840         log_error_unit(UNIT(s)->id,
2841                        "Failed to set a watch for %s's PID file %s: %s",
2842                        UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2843         service_unwatch_pid_file(s);
2844         return r;
2845 }
2846
2847 static int service_demand_pid_file(Service *s) {
2848         PathSpec *ps;
2849
2850         assert(s->pid_file);
2851         assert(!s->pid_file_pathspec);
2852
2853         ps = new0(PathSpec, 1);
2854         if (!ps)
2855                 return -ENOMEM;
2856
2857         ps->unit = UNIT(s);
2858         ps->path = strdup(s->pid_file);
2859         if (!ps->path) {
2860                 free(ps);
2861                 return -ENOMEM;
2862         }
2863
2864         path_kill_slashes(ps->path);
2865
2866         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2867          * keep their PID file open all the time. */
2868         ps->type = PATH_MODIFIED;
2869         ps->inotify_fd = -1;
2870
2871         s->pid_file_pathspec = ps;
2872
2873         return service_watch_pid_file(s);
2874 }
2875
2876 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2877         PathSpec *p = userdata;
2878         Service *s;
2879
2880         assert(p);
2881
2882         s = SERVICE(p->unit);
2883
2884         assert(s);
2885         assert(fd >= 0);
2886         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2887         assert(s->pid_file_pathspec);
2888         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2889
2890         log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2891
2892         if (path_spec_fd_event(p, events) < 0)
2893                 goto fail;
2894
2895         if (service_retry_pid_file(s) == 0)
2896                 return 0;
2897
2898         if (service_watch_pid_file(s) < 0)
2899                 goto fail;
2900
2901         return 0;
2902
2903 fail:
2904         service_unwatch_pid_file(s);
2905         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2906         return 0;
2907 }
2908
2909 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2910         Service *s = SERVICE(u);
2911         ServiceResult f;
2912
2913         assert(s);
2914         assert(pid >= 0);
2915
2916         if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2917                                      is_clean_exit_lsb(code, status, &s->success_status))
2918                 f = SERVICE_SUCCESS;
2919         else if (code == CLD_EXITED)
2920                 f = SERVICE_FAILURE_EXIT_CODE;
2921         else if (code == CLD_KILLED)
2922                 f = SERVICE_FAILURE_SIGNAL;
2923         else if (code == CLD_DUMPED)
2924                 f = SERVICE_FAILURE_CORE_DUMP;
2925         else
2926                 assert_not_reached("Unknown code");
2927
2928         if (s->main_pid == pid) {
2929                 /* Forking services may occasionally move to a new PID.
2930                  * As long as they update the PID file before exiting the old
2931                  * PID, they're fine. */
2932                 if (service_load_pid_file(s, false) == 0)
2933                         return;
2934
2935                 s->main_pid = 0;
2936                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2937
2938                 if (s->main_command) {
2939                         /* If this is not a forking service than the
2940                          * main process got started and hence we copy
2941                          * the exit status so that it is recorded both
2942                          * as main and as control process exit
2943                          * status */
2944
2945                         s->main_command->exec_status = s->main_exec_status;
2946
2947                         if (s->main_command->ignore)
2948                                 f = SERVICE_SUCCESS;
2949                 } else if (s->exec_command[SERVICE_EXEC_START]) {
2950
2951                         /* If this is a forked process, then we should
2952                          * ignore the return value if this was
2953                          * configured for the starter process */
2954
2955                         if (s->exec_command[SERVICE_EXEC_START]->ignore)
2956                                 f = SERVICE_SUCCESS;
2957                 }
2958
2959                 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2960                            u->id,
2961                            "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2962                                   u->id, sigchld_code_to_string(code), status,
2963                                   strna(code == CLD_EXITED
2964                                         ? exit_status_to_string(status, EXIT_STATUS_FULL)
2965                                         : signal_to_string(status)),
2966                            "EXIT_CODE=%s", sigchld_code_to_string(code),
2967                            "EXIT_STATUS=%i", status,
2968                            NULL);
2969
2970                 if (f != SERVICE_SUCCESS)
2971                         s->result = f;
2972
2973                 if (s->main_command &&
2974                     s->main_command->command_next &&
2975                     f == SERVICE_SUCCESS) {
2976
2977                         /* There is another command to *
2978                          * execute, so let's do that. */
2979
2980                         log_debug_unit(u->id,
2981                                        "%s running next main command for state %s",
2982                                        u->id, service_state_to_string(s->state));
2983                         service_run_next_main(s);
2984
2985                 } else {
2986
2987                         /* The service exited, so the service is officially
2988                          * gone. */
2989                         s->main_command = NULL;
2990
2991                         switch (s->state) {
2992
2993                         case SERVICE_START_POST:
2994                         case SERVICE_RELOAD:
2995                         case SERVICE_STOP:
2996                                 /* Need to wait until the operation is
2997                                  * done */
2998                                 break;
2999
3000                         case SERVICE_START:
3001                                 if (s->type == SERVICE_ONESHOT) {
3002                                         /* This was our main goal, so let's go on */
3003                                         if (f == SERVICE_SUCCESS)
3004                                                 service_enter_start_post(s);
3005                                         else
3006                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3007                                         break;
3008                                 }
3009
3010                                 /* Fall through */
3011
3012                         case SERVICE_RUNNING:
3013                                 service_enter_running(s, f);
3014                                 break;
3015
3016                         case SERVICE_STOP_SIGTERM:
3017                         case SERVICE_STOP_SIGKILL:
3018
3019                                 if (!control_pid_good(s))
3020                                         service_enter_stop_post(s, f);
3021
3022                                 /* If there is still a control process, wait for that first */
3023                                 break;
3024
3025                         default:
3026                                 assert_not_reached("Uh, main process died at wrong time.");
3027                         }
3028                 }
3029
3030         } else if (s->control_pid == pid) {
3031                 s->control_pid = 0;
3032
3033                 if (s->control_command) {
3034                         exec_status_exit(&s->control_command->exec_status,
3035                                          &s->exec_context, pid, code, status);
3036
3037                         if (s->control_command->ignore)
3038                                 f = SERVICE_SUCCESS;
3039                 }
3040
3041                 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3042                               "%s: control process exited, code=%s status=%i",
3043                               u->id, sigchld_code_to_string(code), status);
3044
3045                 if (f != SERVICE_SUCCESS)
3046                         s->result = f;
3047
3048                 /* Immediately get rid of the cgroup, so that the
3049                  * kernel doesn't delay the cgroup empty messages for
3050                  * the service cgroup any longer than necessary */
3051                 service_kill_control_processes(s);
3052
3053                 if (s->control_command &&
3054                     s->control_command->command_next &&
3055                     f == SERVICE_SUCCESS) {
3056
3057                         /* There is another command to *
3058                          * execute, so let's do that. */
3059
3060                         log_debug_unit(u->id,
3061                                        "%s running next control command for state %s",
3062                                        u->id, service_state_to_string(s->state));
3063                         service_run_next_control(s);
3064
3065                 } else {
3066                         /* No further commands for this step, so let's
3067                          * figure out what to do next */
3068
3069                         s->control_command = NULL;
3070                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3071
3072                         log_debug_unit(u->id,
3073                                        "%s got final SIGCHLD for state %s",
3074                                        u->id, service_state_to_string(s->state));
3075
3076                         switch (s->state) {
3077
3078                         case SERVICE_START_PRE:
3079                                 if (f == SERVICE_SUCCESS)
3080                                         service_enter_start(s);
3081                                 else
3082                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3083                                 break;
3084
3085                         case SERVICE_START:
3086                                 if (s->type != SERVICE_FORKING)
3087                                         /* Maybe spurious event due to a reload that changed the type? */
3088                                         break;
3089
3090                                 if (f != SERVICE_SUCCESS) {
3091                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3092                                         break;
3093                                 }
3094
3095                                 if (s->pid_file) {
3096                                         bool has_start_post;
3097                                         int r;
3098
3099                                         /* Let's try to load the pid file here if we can.
3100                                          * The PID file might actually be created by a START_POST
3101                                          * script. In that case don't worry if the loading fails. */
3102
3103                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3104                                         r = service_load_pid_file(s, !has_start_post);
3105                                         if (!has_start_post && r < 0) {
3106                                                 r = service_demand_pid_file(s);
3107                                                 if (r < 0 || !cgroup_good(s))
3108                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3109                                                 break;
3110                                         }
3111                                 } else
3112                                         service_search_main_pid(s);
3113
3114                                 service_enter_start_post(s);
3115                                 break;
3116
3117                         case SERVICE_START_POST:
3118                                 if (f != SERVICE_SUCCESS) {
3119                                         service_enter_stop(s, f);
3120                                         break;
3121                                 }
3122
3123                                 if (s->pid_file) {
3124                                         int r;
3125
3126                                         r = service_load_pid_file(s, true);
3127                                         if (r < 0) {
3128                                                 r = service_demand_pid_file(s);
3129                                                 if (r < 0 || !cgroup_good(s))
3130                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3131                                                 break;
3132                                         }
3133                                 } else
3134                                         service_search_main_pid(s);
3135
3136                                 service_enter_running(s, SERVICE_SUCCESS);
3137                                 break;
3138
3139                         case SERVICE_RELOAD:
3140                                 if (f == SERVICE_SUCCESS) {
3141                                         service_load_pid_file(s, true);
3142                                         service_search_main_pid(s);
3143                                 }
3144
3145                                 s->reload_result = f;
3146                                 service_enter_running(s, SERVICE_SUCCESS);
3147                                 break;
3148
3149                         case SERVICE_STOP:
3150                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3151                                 break;
3152
3153                         case SERVICE_STOP_SIGTERM:
3154                         case SERVICE_STOP_SIGKILL:
3155                                 if (main_pid_good(s) <= 0)
3156                                         service_enter_stop_post(s, f);
3157
3158                                 /* If there is still a service
3159                                  * process around, wait until
3160                                  * that one quit, too */
3161                                 break;
3162
3163                         case SERVICE_STOP_POST:
3164                         case SERVICE_FINAL_SIGTERM:
3165                         case SERVICE_FINAL_SIGKILL:
3166                                 service_enter_dead(s, f, true);
3167                                 break;
3168
3169                         default:
3170                                 assert_not_reached("Uh, control process died at wrong time.");
3171                         }
3172                 }
3173         }
3174
3175         /* Notify clients about changed exit status */
3176         unit_add_to_dbus_queue(u);
3177 }
3178
3179 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3180         Service *s = SERVICE(userdata);
3181
3182         assert(s);
3183         assert(source == s->timer_event_source);
3184
3185         switch (s->state) {
3186
3187         case SERVICE_START_PRE:
3188         case SERVICE_START:
3189                 log_warning_unit(UNIT(s)->id,
3190                                  "%s operation timed out. Terminating.", UNIT(s)->id);
3191                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3192                 break;
3193
3194         case SERVICE_START_POST:
3195                 log_warning_unit(UNIT(s)->id,
3196                                  "%s operation timed out. Stopping.", UNIT(s)->id);
3197                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3198                 break;
3199
3200         case SERVICE_RELOAD:
3201                 log_warning_unit(UNIT(s)->id,
3202                                  "%s operation timed out. Stopping.", UNIT(s)->id);
3203                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3204                 service_enter_running(s, SERVICE_SUCCESS);
3205                 break;
3206
3207         case SERVICE_STOP:
3208                 log_warning_unit(UNIT(s)->id,
3209                                  "%s stopping timed out. Terminating.", UNIT(s)->id);
3210                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3211                 break;
3212
3213         case SERVICE_STOP_SIGTERM:
3214                 if (s->kill_context.send_sigkill) {
3215                         log_warning_unit(UNIT(s)->id,
3216                                          "%s stopping timed out. Killing.", UNIT(s)->id);
3217                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3218                 } else {
3219                         log_warning_unit(UNIT(s)->id,
3220                                          "%s stopping timed out. Skipping SIGKILL.", UNIT(s)->id);
3221                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3222                 }
3223
3224                 break;
3225
3226         case SERVICE_STOP_SIGKILL:
3227                 /* Uh, we sent a SIGKILL and it is still not gone?
3228                  * Must be something we cannot kill, so let's just be
3229                  * weirded out and continue */
3230
3231                 log_warning_unit(UNIT(s)->id,
3232                                  "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
3233                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3234                 break;
3235
3236         case SERVICE_STOP_POST:
3237                 log_warning_unit(UNIT(s)->id,
3238                                  "%s stopping timed out (2). Terminating.", UNIT(s)->id);
3239                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3240                 break;
3241
3242         case SERVICE_FINAL_SIGTERM:
3243                 if (s->kill_context.send_sigkill) {
3244                         log_warning_unit(UNIT(s)->id,
3245                                          "%s stopping timed out (2). Killing.", UNIT(s)->id);
3246                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3247                 } else {
3248                         log_warning_unit(UNIT(s)->id,
3249                                          "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3250                                          UNIT(s)->id);
3251                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3252                 }
3253
3254                 break;
3255
3256         case SERVICE_FINAL_SIGKILL:
3257                 log_warning_unit(UNIT(s)->id,
3258                                  "%s still around after SIGKILL (2). Entering failed mode.", UNIT(s)->id);
3259                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3260                 break;
3261
3262         case SERVICE_AUTO_RESTART:
3263                 log_info_unit(UNIT(s)->id,
3264                               "%s holdoff time over, scheduling restart.", UNIT(s)->id);
3265                 service_enter_restart(s);
3266                 break;
3267
3268         default:
3269                 assert_not_reached("Timeout at wrong time.");
3270         }
3271
3272         return 0;
3273 }
3274
3275 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3276         Service *s = SERVICE(userdata);
3277
3278         assert(s);
3279         assert(source == s->watchdog_event_source);
3280
3281         log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
3282         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
3283
3284         return 0;
3285 }
3286
3287 static void service_notify_cgroup_empty_event(Unit *u) {
3288         Service *s = SERVICE(u);
3289
3290         assert(u);
3291
3292         log_debug_unit(u->id, "%s: cgroup is empty", u->id);
3293
3294         switch (s->state) {
3295
3296                 /* Waiting for SIGCHLD is usually more interesting,
3297                  * because it includes return codes/signals. Which is
3298                  * why we ignore the cgroup events for most cases,
3299                  * except when we don't know pid which to expect the
3300                  * SIGCHLD for. */
3301
3302         case SERVICE_START:
3303         case SERVICE_START_POST:
3304                 /* If we were hoping for the daemon to write its PID file,
3305                  * we can give up now. */
3306                 if (s->pid_file_pathspec) {
3307                         log_warning_unit(u->id,
3308                                          "%s never wrote its PID file. Failing.", UNIT(s)->id);
3309                         service_unwatch_pid_file(s);
3310                         if (s->state == SERVICE_START)
3311                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3312                         else
3313                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3314                 }
3315                 break;
3316
3317         case SERVICE_RUNNING:
3318                 /* service_enter_running() will figure out what to do */
3319                 service_enter_running(s, SERVICE_SUCCESS);
3320                 break;
3321
3322         case SERVICE_STOP_SIGTERM:
3323         case SERVICE_STOP_SIGKILL:
3324
3325                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3326                         service_enter_stop_post(s, SERVICE_SUCCESS);
3327
3328                 break;
3329
3330         case SERVICE_FINAL_SIGTERM:
3331         case SERVICE_FINAL_SIGKILL:
3332                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3333                         service_enter_dead(s, SERVICE_SUCCESS, true);
3334
3335                 break;
3336
3337         default:
3338                 ;
3339         }
3340 }
3341
3342 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3343         Service *s = SERVICE(u);
3344         const char *e;
3345
3346         assert(u);
3347
3348         if (s->notify_access == NOTIFY_NONE) {
3349                 log_warning_unit(u->id,
3350                                  "%s: Got notification message from PID %lu, but reception is disabled.",
3351                                  u->id, (unsigned long) pid);
3352                 return;
3353         }
3354
3355         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3356                 log_warning_unit(u->id,
3357                                  "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3358                                  u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3359                 return;
3360         }
3361
3362         log_debug_unit(u->id,
3363                        "%s: Got message", u->id);
3364
3365         /* Interpret MAINPID= */
3366         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3367             (s->state == SERVICE_START ||
3368              s->state == SERVICE_START_POST ||
3369              s->state == SERVICE_RUNNING ||
3370              s->state == SERVICE_RELOAD)) {
3371
3372                 if (parse_pid(e + 8, &pid) < 0)
3373                         log_warning_unit(u->id,
3374                                          "Failed to parse notification message %s", e);
3375                 else {
3376                         log_debug_unit(u->id,
3377                                        "%s: got %s", u->id, e);
3378                         service_set_main_pid(s, pid);
3379                         unit_watch_pid(UNIT(s), pid);
3380                 }
3381         }
3382
3383         /* Interpret READY= */
3384         if (s->type == SERVICE_NOTIFY &&
3385             s->state == SERVICE_START &&
3386             strv_find(tags, "READY=1")) {
3387                 log_debug_unit(u->id,
3388                                "%s: got READY=1", u->id);
3389
3390                 service_enter_start_post(s);
3391         }
3392
3393         /* Interpret STATUS= */
3394         e = strv_find_prefix(tags, "STATUS=");
3395         if (e) {
3396                 char *t;
3397
3398                 if (e[7]) {
3399
3400                         if (!utf8_is_valid(e+7)) {
3401                                 log_warning_unit(u->id,
3402                                                  "Status message in notification is not UTF-8 clean.");
3403                                 return;
3404                         }
3405
3406                         t = strdup(e+7);
3407                         if (!t) {
3408                                 log_error_unit(u->id,
3409                                                "Failed to allocate string.");
3410                                 return;
3411                         }
3412
3413                         log_debug_unit(u->id,
3414                                        "%s: got %s", u->id, e);
3415
3416                         free(s->status_text);
3417                         s->status_text = t;
3418                 } else {
3419                         free(s->status_text);
3420                         s->status_text = NULL;
3421                 }
3422
3423         }
3424
3425         if (strv_find(tags, "WATCHDOG=1")) {
3426                 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
3427                 service_reset_watchdog(s);
3428         }
3429
3430         /* Notify clients about changed status or main pid */
3431         unit_add_to_dbus_queue(u);
3432 }
3433
3434 #ifdef HAVE_SYSV_COMPAT
3435
3436 static int service_enumerate(Manager *m) {
3437         char **p;
3438         unsigned i;
3439         _cleanup_closedir_ DIR *d = NULL;
3440         _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3441         Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3442         _cleanup_set_free_ Set *shutdown_services = NULL;
3443         Unit *service;
3444         Iterator j;
3445         int r;
3446
3447         assert(m);
3448
3449         if (m->running_as != SYSTEMD_SYSTEM)
3450                 return 0;
3451
3452         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3453                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3454                         struct dirent *de;
3455
3456                         free(path);
3457                         path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3458                         if (!path) {
3459                                 r = -ENOMEM;
3460                                 goto finish;
3461                         }
3462
3463                         if (d)
3464                                 closedir(d);
3465
3466                         d = opendir(path);
3467                         if (!d) {
3468                                 if (errno != ENOENT)
3469                                         log_warning("opendir(%s) failed: %m", path);
3470
3471                                 continue;
3472                         }
3473
3474                         while ((de = readdir(d))) {
3475                                 int a, b;
3476
3477                                 if (ignore_file(de->d_name))
3478                                         continue;
3479
3480                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3481                                         continue;
3482
3483                                 if (strlen(de->d_name) < 4)
3484                                         continue;
3485
3486                                 a = undecchar(de->d_name[1]);
3487                                 b = undecchar(de->d_name[2]);
3488
3489                                 if (a < 0 || b < 0)
3490                                         continue;
3491
3492                                 free(fpath);
3493                                 fpath = strjoin(path, "/", de->d_name, NULL);
3494                                 if (!fpath) {
3495                                         r = -ENOMEM;
3496                                         goto finish;
3497                                 }
3498
3499                                 if (access(fpath, X_OK) < 0) {
3500
3501                                         if (errno != ENOENT)
3502                                                 log_warning("access() failed on %s: %m", fpath);
3503
3504                                         continue;
3505                                 }
3506
3507                                 free(name);
3508                                 name = sysv_translate_name(de->d_name + 3);
3509                                 if (!name) {
3510                                         r = log_oom();
3511                                         goto finish;
3512                                 }
3513
3514                                 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3515                                 if (r < 0) {
3516                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3517                                         continue;
3518                                 }
3519
3520                                 if (de->d_name[0] == 'S')  {
3521
3522                                         if (rcnd_table[i].type == RUNLEVEL_UP) {
3523                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3524                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3525
3526                                                 SERVICE(service)->sysv_enabled = true;
3527                                         }
3528
3529                                         r = set_ensure_allocated(&runlevel_services[i],
3530                                                                  trivial_hash_func, trivial_compare_func);
3531                                         if (r < 0)
3532                                                 goto finish;
3533
3534                                         r = set_put(runlevel_services[i], service);
3535                                         if (r < 0)
3536                                                 goto finish;
3537
3538                                 } else if (de->d_name[0] == 'K' &&
3539                                            (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3540
3541                                         r = set_ensure_allocated(&shutdown_services,
3542                                                                  trivial_hash_func, trivial_compare_func);
3543                                         if (r < 0)
3544                                                 goto finish;
3545
3546                                         r = set_put(shutdown_services, service);
3547                                         if (r < 0)