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