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