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