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