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