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