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