chiark / gitweb /
1e3e875c3fd36dde473baeef694733184537cb33
[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 "unit-printf.h"
37 #include "dbus-service.h"
38 #include "special.h"
39 #include "bus-errors.h"
40 #include "exit-status.h"
41 #include "def.h"
42 #include "path-util.h"
43 #include "util.h"
44 #include "utf8.h"
45
46 #ifdef HAVE_SYSV_COMPAT
47
48 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
49
50 typedef enum RunlevelType {
51         RUNLEVEL_UP,
52         RUNLEVEL_DOWN,
53         RUNLEVEL_SYSINIT
54 } RunlevelType;
55
56 static const struct {
57         const char *path;
58         const char *target;
59         const RunlevelType type;
60 } rcnd_table[] = {
61         /* Standard SysV runlevels for start-up */
62         { "rc1.d",  SPECIAL_RESCUE_TARGET,    RUNLEVEL_UP },
63         { "rc2.d",  SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
64         { "rc3.d",  SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
65         { "rc4.d",  SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
66         { "rc5.d",  SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
67
68 #ifdef TARGET_SUSE
69         /* SUSE style boot.d */
70         { "boot.d", SPECIAL_SYSINIT_TARGET,   RUNLEVEL_SYSINIT },
71 #endif
72
73 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
74         /* Debian style rcS.d */
75         { "rcS.d",  SPECIAL_SYSINIT_TARGET,   RUNLEVEL_SYSINIT },
76 #endif
77
78         /* Standard SysV runlevels for shutdown */
79         { "rc0.d",  SPECIAL_POWEROFF_TARGET,  RUNLEVEL_DOWN },
80         { "rc6.d",  SPECIAL_REBOOT_TARGET,    RUNLEVEL_DOWN }
81
82         /* Note that the order here matters, as we read the
83            directories in this order, and we want to make sure that
84            sysv_start_priority is known when we first load the
85            unit. And that value we only know from S links. Hence
86            UP/SYSINIT must be read before DOWN */
87 };
88
89 #define RUNLEVELS_UP "12345"
90 /* #define RUNLEVELS_DOWN "06" */
91 #define RUNLEVELS_BOOT "bBsS"
92 #endif
93
94 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
95         [SERVICE_DEAD] = UNIT_INACTIVE,
96         [SERVICE_START_PRE] = UNIT_ACTIVATING,
97         [SERVICE_START] = UNIT_ACTIVATING,
98         [SERVICE_START_POST] = UNIT_ACTIVATING,
99         [SERVICE_RUNNING] = UNIT_ACTIVE,
100         [SERVICE_EXITED] = UNIT_ACTIVE,
101         [SERVICE_RELOAD] = UNIT_RELOADING,
102         [SERVICE_STOP] = UNIT_DEACTIVATING,
103         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
104         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
105         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
106         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
107         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
108         [SERVICE_FAILED] = UNIT_FAILED,
109         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
110 };
111
112 /* For Type=idle we never want to delay any other jobs, hence we
113  * consider idle jobs active as soon as we start working on them */
114 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
115         [SERVICE_DEAD] = UNIT_INACTIVE,
116         [SERVICE_START_PRE] = UNIT_ACTIVE,
117         [SERVICE_START] = UNIT_ACTIVE,
118         [SERVICE_START_POST] = UNIT_ACTIVE,
119         [SERVICE_RUNNING] = UNIT_ACTIVE,
120         [SERVICE_EXITED] = UNIT_ACTIVE,
121         [SERVICE_RELOAD] = UNIT_RELOADING,
122         [SERVICE_STOP] = UNIT_DEACTIVATING,
123         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
124         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
125         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
126         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
127         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
128         [SERVICE_FAILED] = UNIT_FAILED,
129         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
130 };
131
132 static void service_init(Unit *u) {
133         Service *s = SERVICE(u);
134
135         assert(u);
136         assert(u->load_state == UNIT_STUB);
137
138         s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
139         s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
140         s->restart_usec = DEFAULT_RESTART_USEC;
141         s->type = _SERVICE_TYPE_INVALID;
142
143         s->watchdog_watch.type = WATCH_INVALID;
144
145         s->timer_watch.type = WATCH_INVALID;
146 #ifdef HAVE_SYSV_COMPAT
147         s->sysv_start_priority = -1;
148         s->sysv_start_priority_from_rcnd = -1;
149 #endif
150         s->socket_fd = -1;
151         s->guess_main_pid = true;
152
153         exec_context_init(&s->exec_context);
154         kill_context_init(&s->kill_context);
155
156         RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
157
158         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
159 }
160
161 static void service_unwatch_control_pid(Service *s) {
162         assert(s);
163
164         if (s->control_pid <= 0)
165                 return;
166
167         unit_unwatch_pid(UNIT(s), s->control_pid);
168         s->control_pid = 0;
169 }
170
171 static void service_unwatch_main_pid(Service *s) {
172         assert(s);
173
174         if (s->main_pid <= 0)
175                 return;
176
177         unit_unwatch_pid(UNIT(s), s->main_pid);
178         s->main_pid = 0;
179 }
180
181 static void service_unwatch_pid_file(Service *s) {
182         if (!s->pid_file_pathspec)
183                 return;
184
185         log_debug("Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
186         path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
187         path_spec_done(s->pid_file_pathspec);
188         free(s->pid_file_pathspec);
189         s->pid_file_pathspec = NULL;
190 }
191
192 static int service_set_main_pid(Service *s, pid_t pid) {
193         pid_t ppid;
194
195         assert(s);
196
197         if (pid <= 1)
198                 return -EINVAL;
199
200         if (pid == getpid())
201                 return -EINVAL;
202
203         s->main_pid = pid;
204         s->main_pid_known = true;
205
206         if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
207                 log_warning("%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
208                             UNIT(s)->id, (unsigned long) pid);
209
210                 s->main_pid_alien = true;
211         } else
212                 s->main_pid_alien = false;
213
214         exec_status_start(&s->main_exec_status, pid);
215
216         return 0;
217 }
218
219 static void service_close_socket_fd(Service *s) {
220         assert(s);
221
222         if (s->socket_fd < 0)
223                 return;
224
225         close_nointr_nofail(s->socket_fd);
226         s->socket_fd = -1;
227 }
228
229 static void service_connection_unref(Service *s) {
230         assert(s);
231
232         if (!UNIT_DEREF(s->accept_socket))
233                 return;
234
235         socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
236         unit_ref_unset(&s->accept_socket);
237 }
238
239 static void service_stop_watchdog(Service *s) {
240         assert(s);
241
242         unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
243         s->watchdog_timestamp.realtime = 0;
244         s->watchdog_timestamp.monotonic = 0;
245 }
246
247 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
248
249 static void service_handle_watchdog(Service *s) {
250         usec_t offset;
251         int r;
252
253         assert(s);
254
255         if (s->watchdog_usec == 0)
256                 return;
257
258         offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
259         if (offset >= s->watchdog_usec) {
260                 log_error("%s watchdog timeout!", UNIT(s)->id);
261                 service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
262                 return;
263         }
264
265         r = unit_watch_timer(UNIT(s), s->watchdog_usec - offset, &s->watchdog_watch);
266         if (r < 0)
267                 log_warning("%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
268 }
269
270 static void service_reset_watchdog(Service *s) {
271         assert(s);
272
273         dual_timestamp_get(&s->watchdog_timestamp);
274         service_handle_watchdog(s);
275 }
276
277 static void service_done(Unit *u) {
278         Service *s = SERVICE(u);
279
280         assert(s);
281
282         free(s->pid_file);
283         s->pid_file = NULL;
284
285 #ifdef HAVE_SYSV_COMPAT
286         free(s->sysv_runlevels);
287         s->sysv_runlevels = NULL;
288 #endif
289
290         free(s->status_text);
291         s->status_text = NULL;
292
293         exec_context_done(&s->exec_context);
294         exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
295         s->control_command = NULL;
296         s->main_command = NULL;
297
298         set_free(s->restart_ignore_status.code);
299         s->restart_ignore_status.code = NULL;
300         set_free(s->restart_ignore_status.signal);
301         s->restart_ignore_status.signal = NULL;
302
303         set_free(s->success_status.code);
304         s->success_status.code = NULL;
305         set_free(s->success_status.signal);
306         s->success_status.signal = NULL;
307
308         /* This will leak a process, but at least no memory or any of
309          * our resources */
310         service_unwatch_main_pid(s);
311         service_unwatch_control_pid(s);
312         service_unwatch_pid_file(s);
313
314         if (s->bus_name)  {
315                 unit_unwatch_bus_name(u, s->bus_name);
316                 free(s->bus_name);
317                 s->bus_name = NULL;
318         }
319
320         service_close_socket_fd(s);
321         service_connection_unref(s);
322
323         unit_ref_unset(&s->accept_socket);
324
325         service_stop_watchdog(s);
326
327         unit_unwatch_timer(u, &s->timer_watch);
328 }
329
330 #ifdef HAVE_SYSV_COMPAT
331 static char *sysv_translate_name(const char *name) {
332         char *r;
333
334         if (!(r = new(char, strlen(name) + sizeof(".service"))))
335                 return NULL;
336
337 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
338         if (endswith(name, ".sh"))
339                 /* Drop Debian-style .sh suffix */
340                 strcpy(stpcpy(r, name) - 3, ".service");
341 #endif
342 #ifdef TARGET_SUSE
343         if (startswith(name, "boot."))
344                 /* Drop SuSE-style boot. prefix */
345                 strcpy(stpcpy(r, name + 5), ".service");
346 #endif
347 #ifdef TARGET_FRUGALWARE
348         if (startswith(name, "rc."))
349                 /* Drop Frugalware-style rc. prefix */
350                 strcpy(stpcpy(r, name + 3), ".service");
351 #endif
352         else
353                 /* Normal init scripts */
354                 strcpy(stpcpy(r, name), ".service");
355
356         return r;
357 }
358
359 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
360
361         /* We silently ignore the $ prefix here. According to the LSB
362          * spec it simply indicates whether something is a
363          * standardized name or a distribution-specific one. Since we
364          * just follow what already exists and do not introduce new
365          * uses or names we don't care who introduced a new name. */
366
367         static const char * const table[] = {
368                 /* LSB defined facilities */
369                 "local_fs",             SPECIAL_LOCAL_FS_TARGET,
370 #if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
371 #else
372                 /* Due to unfortunate name selection in Mandriva,
373                  * $network is provided by network-up which is ordered
374                  * after network which actually starts interfaces.
375                  * To break the loop, just ignore it */
376                 "network",              SPECIAL_NETWORK_TARGET,
377 #endif
378                 "named",                SPECIAL_NSS_LOOKUP_TARGET,
379                 "portmap",              SPECIAL_RPCBIND_TARGET,
380                 "remote_fs",            SPECIAL_REMOTE_FS_TARGET,
381                 "syslog",               SPECIAL_SYSLOG_TARGET,
382                 "time",                 SPECIAL_TIME_SYNC_TARGET,
383
384                 /* common extensions */
385                 "mail-transfer-agent",  SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
386                 "x-display-manager",    SPECIAL_DISPLAY_MANAGER_SERVICE,
387                 "null",                 NULL,
388
389 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
390                 "mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
391 #endif
392
393 #ifdef TARGET_FEDORA
394                 "MTA",                  SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
395                 "smtpdaemon",           SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
396                 "httpd",                SPECIAL_HTTP_DAEMON_TARGET,
397 #endif
398
399 #ifdef TARGET_SUSE
400                 "smtp",                 SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
401 #endif
402         };
403
404         unsigned i;
405         char *r;
406         const char *n;
407
408         assert(name);
409         assert(_r);
410
411         n = *name == '$' ? name + 1 : name;
412
413         for (i = 0; i < ELEMENTSOF(table); i += 2) {
414
415                 if (!streq(table[i], n))
416                         continue;
417
418                 if (!table[i+1])
419                         return 0;
420
421                 if (!(r = strdup(table[i+1])))
422                         return -ENOMEM;
423
424                 goto finish;
425         }
426
427         /* If we don't know this name, fallback heuristics to figure
428          * out whether something is a target or a service alias. */
429
430         if (*name == '$') {
431                 if (!unit_prefix_is_valid(n))
432                         return -EINVAL;
433
434                 /* Facilities starting with $ are most likely targets */
435                 r = unit_name_build(n, NULL, ".target");
436         } else if (filename && streq(name, filename))
437                 /* Names equaling the file name of the services are redundant */
438                 return 0;
439         else
440                 /* Everything else we assume to be normal service names */
441                 r = sysv_translate_name(n);
442
443         if (!r)
444                 return -ENOMEM;
445
446 finish:
447         *_r = r;
448
449         return 1;
450 }
451
452 static int sysv_fix_order(Service *s) {
453         Unit *other;
454         int r;
455
456         assert(s);
457
458         if (s->sysv_start_priority < 0)
459                 return 0;
460
461         /* For each pair of services where at least one lacks a LSB
462          * header, we use the start priority value to order things. */
463
464         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
465                 Service *t;
466                 UnitDependency d;
467                 bool special_s, special_t;
468
469                 t = SERVICE(other);
470
471                 if (s == t)
472                         continue;
473
474                 if (UNIT(t)->load_state != UNIT_LOADED)
475                         continue;
476
477                 if (t->sysv_start_priority < 0)
478                         continue;
479
480                 /* If both units have modern headers we don't care
481                  * about the priorities */
482                 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
483                     (UNIT(t)->fragment_path || t->sysv_has_lsb))
484                         continue;
485
486                 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
487                 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
488
489                 if (special_t && !special_s)
490                         d = UNIT_AFTER;
491                 else if (special_s && !special_t)
492                         d = UNIT_BEFORE;
493                 else if (t->sysv_start_priority < s->sysv_start_priority)
494                         d = UNIT_AFTER;
495                 else if (t->sysv_start_priority > s->sysv_start_priority)
496                         d = UNIT_BEFORE;
497                 else
498                         continue;
499
500                 /* FIXME: Maybe we should compare the name here lexicographically? */
501
502                 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
503                         return r;
504         }
505
506         return 0;
507 }
508
509 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
510         ExecCommand *c;
511
512         if (!(c = new0(ExecCommand, 1)))
513                 return NULL;
514
515         if (!(c->path = strdup(path))) {
516                 free(c);
517                 return NULL;
518         }
519
520         if (!(c->argv = strv_new(path, arg1, NULL))) {
521                 free(c->path);
522                 free(c);
523                 return NULL;
524         }
525
526         return c;
527 }
528
529 static int sysv_exec_commands(Service *s) {
530         ExecCommand *c;
531
532         assert(s);
533         assert(s->is_sysv);
534         assert(UNIT(s)->source_path);
535
536         c = exec_command_new(UNIT(s)->source_path, "start");
537         if (!c)
538                 return -ENOMEM;
539         exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
540
541         c = exec_command_new(UNIT(s)->source_path, "stop");
542         if (!c)
543                 return -ENOMEM;
544         exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
545
546         c = exec_command_new(UNIT(s)->source_path, "reload");
547         if (!c)
548                 return -ENOMEM;
549         exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
550
551         return 0;
552 }
553
554 static int service_load_sysv_path(Service *s, const char *path) {
555         FILE *f;
556         Unit *u;
557         unsigned line = 0;
558         int r;
559         enum {
560                 NORMAL,
561                 DESCRIPTION,
562                 LSB,
563                 LSB_DESCRIPTION
564         } state = NORMAL;
565         char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
566         struct stat st;
567
568         assert(s);
569         assert(path);
570
571         u = UNIT(s);
572
573         f = fopen(path, "re");
574         if (!f) {
575                 r = errno == ENOENT ? 0 : -errno;
576                 goto finish;
577         }
578
579         if (fstat(fileno(f), &st) < 0) {
580                 r = -errno;
581                 goto finish;
582         }
583
584         free(u->source_path);
585         u->source_path = strdup(path);
586         if (!u->source_path) {
587                 r = -ENOMEM;
588                 goto finish;
589         }
590         u->source_mtime = timespec_load(&st.st_mtim);
591
592         if (null_or_empty(&st)) {
593                 u->load_state = UNIT_MASKED;
594                 r = 0;
595                 goto finish;
596         }
597
598         s->is_sysv = true;
599
600         while (!feof(f)) {
601                 char l[LINE_MAX], *t;
602
603                 if (!fgets(l, sizeof(l), f)) {
604                         if (feof(f))
605                                 break;
606
607                         r = -errno;
608                         log_error("Failed to read configuration file '%s': %s", path, strerror(-r));
609                         goto finish;
610                 }
611
612                 line++;
613
614                 t = strstrip(l);
615                 if (*t != '#')
616                         continue;
617
618                 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
619                         state = LSB;
620                         s->sysv_has_lsb = true;
621                         continue;
622                 }
623
624                 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
625                         state = NORMAL;
626                         continue;
627                 }
628
629                 t++;
630                 t += strspn(t, WHITESPACE);
631
632                 if (state == NORMAL) {
633
634                         /* Try to parse Red Hat style chkconfig headers */
635
636                         if (startswith_no_case(t, "chkconfig:")) {
637                                 int start_priority;
638                                 char runlevels[16], *k;
639
640                                 state = NORMAL;
641
642                                 if (sscanf(t+10, "%15s %i %*i",
643                                            runlevels,
644                                            &start_priority) != 2) {
645
646                                         log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
647                                         continue;
648                                 }
649
650                                 /* A start priority gathered from the
651                                  * symlink farms is preferred over the
652                                  * data from the LSB header. */
653                                 if (start_priority < 0 || start_priority > 99)
654                                         log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line);
655                                 else
656                                         s->sysv_start_priority = start_priority;
657
658                                 char_array_0(runlevels);
659                                 k = delete_chars(runlevels, WHITESPACE "-");
660
661                                 if (k[0]) {
662                                         char *d;
663
664                                         if (!(d = strdup(k))) {
665                                                 r = -ENOMEM;
666                                                 goto finish;
667                                         }
668
669                                         free(s->sysv_runlevels);
670                                         s->sysv_runlevels = d;
671                                 }
672
673                         } else if (startswith_no_case(t, "description:")) {
674
675                                 size_t k = strlen(t);
676                                 char *d;
677                                 const char *j;
678
679                                 if (t[k-1] == '\\') {
680                                         state = DESCRIPTION;
681                                         t[k-1] = 0;
682                                 }
683
684                                 if ((j = strstrip(t+12)) && *j) {
685                                         if (!(d = strdup(j))) {
686                                                 r = -ENOMEM;
687                                                 goto finish;
688                                         }
689                                 } else
690                                         d = NULL;
691
692                                 free(chkconfig_description);
693                                 chkconfig_description = d;
694
695                         } else if (startswith_no_case(t, "pidfile:")) {
696
697                                 char *fn;
698
699                                 state = NORMAL;
700
701                                 fn = strstrip(t+8);
702                                 if (!path_is_absolute(fn)) {
703                                         log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line);
704                                         continue;
705                                 }
706
707                                 if (!(fn = strdup(fn))) {
708                                         r = -ENOMEM;
709                                         goto finish;
710                                 }
711
712                                 free(s->pid_file);
713                                 s->pid_file = fn;
714                         }
715
716                 } else if (state == DESCRIPTION) {
717
718                         /* Try to parse Red Hat style description
719                          * continuation */
720
721                         size_t k = strlen(t);
722                         char *j;
723
724                         if (t[k-1] == '\\')
725                                 t[k-1] = 0;
726                         else
727                                 state = NORMAL;
728
729                         if ((j = strstrip(t)) && *j) {
730                                 char *d = NULL;
731
732                                 if (chkconfig_description)
733                                         d = strjoin(chkconfig_description, " ", j, NULL);
734                                 else
735                                         d = strdup(j);
736
737                                 if (!d) {
738                                         r = -ENOMEM;
739                                         goto finish;
740                                 }
741
742                                 free(chkconfig_description);
743                                 chkconfig_description = d;
744                         }
745
746                 } else if (state == LSB || state == LSB_DESCRIPTION) {
747
748                         if (startswith_no_case(t, "Provides:")) {
749                                 char *i, *w;
750                                 size_t z;
751
752                                 state = LSB;
753
754                                 FOREACH_WORD_QUOTED(w, z, t+9, i) {
755                                         char *n, *m;
756
757                                         if (!(n = strndup(w, z))) {
758                                                 r = -ENOMEM;
759                                                 goto finish;
760                                         }
761
762                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
763                                         free(n);
764
765                                         if (r < 0)
766                                                 goto finish;
767
768                                         if (r == 0)
769                                                 continue;
770
771                                         if (unit_name_to_type(m) == UNIT_SERVICE)
772                                                 r = unit_add_name(u, m);
773                                         else
774                                                 /* NB: SysV targets
775                                                  * which are provided
776                                                  * by a service are
777                                                  * pulled in by the
778                                                  * services, as an
779                                                  * indication that the
780                                                  * generic service is
781                                                  * now available. This
782                                                  * is strictly
783                                                  * one-way. The
784                                                  * targets do NOT pull
785                                                  * in the SysV
786                                                  * services! */
787                                                 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
788
789                                         if (r < 0)
790                                                 log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
791
792                                         free(m);
793                                 }
794
795                         } else if (startswith_no_case(t, "Required-Start:") ||
796                                    startswith_no_case(t, "Should-Start:") ||
797                                    startswith_no_case(t, "X-Start-Before:") ||
798                                    startswith_no_case(t, "X-Start-After:")) {
799                                 char *i, *w;
800                                 size_t z;
801
802                                 state = LSB;
803
804                                 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
805                                         char *n, *m;
806
807                                         if (!(n = strndup(w, z))) {
808                                                 r = -ENOMEM;
809                                                 goto finish;
810                                         }
811
812                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
813
814                                         if (r < 0) {
815                                                 log_error("[%s:%u] Failed to translate LSB dependency %s, ignoring: %s", path, line, n, strerror(-r));
816                                                 free(n);
817                                                 continue;
818                                         }
819
820                                         free(n);
821
822                                         if (r == 0)
823                                                 continue;
824
825                                         r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
826
827                                         if (r < 0)
828                                                 log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
829
830                                         free(m);
831                                 }
832                         } else if (startswith_no_case(t, "Default-Start:")) {
833                                 char *k, *d;
834
835                                 state = LSB;
836
837                                 k = delete_chars(t+14, WHITESPACE "-");
838
839                                 if (k[0] != 0) {
840                                         if (!(d = strdup(k))) {
841                                                 r = -ENOMEM;
842                                                 goto finish;
843                                         }
844
845                                         free(s->sysv_runlevels);
846                                         s->sysv_runlevels = d;
847                                 }
848
849                         } else if (startswith_no_case(t, "Description:")) {
850                                 char *d, *j;
851
852                                 state = LSB_DESCRIPTION;
853
854                                 if ((j = strstrip(t+12)) && *j) {
855                                         if (!(d = strdup(j))) {
856                                                 r = -ENOMEM;
857                                                 goto finish;
858                                         }
859                                 } else
860                                         d = NULL;
861
862                                 free(long_description);
863                                 long_description = d;
864
865                         } else if (startswith_no_case(t, "Short-Description:")) {
866                                 char *d, *j;
867
868                                 state = LSB;
869
870                                 if ((j = strstrip(t+18)) && *j) {
871                                         if (!(d = strdup(j))) {
872                                                 r = -ENOMEM;
873                                                 goto finish;
874                                         }
875                                 } else
876                                         d = NULL;
877
878                                 free(short_description);
879                                 short_description = d;
880
881                         } else if (state == LSB_DESCRIPTION) {
882
883                                 if (startswith(l, "#\t") || startswith(l, "#  ")) {
884                                         char *j;
885
886                                         if ((j = strstrip(t)) && *j) {
887                                                 char *d = NULL;
888
889                                                 if (long_description)
890                                                         d = strjoin(long_description, " ", t, NULL);
891                                                 else
892                                                         d = strdup(j);
893
894                                                 if (!d) {
895                                                         r = -ENOMEM;
896                                                         goto finish;
897                                                 }
898
899                                                 free(long_description);
900                                                 long_description = d;
901                                         }
902
903                                 } else
904                                         state = LSB;
905                         }
906                 }
907         }
908
909         if ((r = sysv_exec_commands(s)) < 0)
910                 goto finish;
911         if (s->sysv_runlevels &&
912             chars_intersect(RUNLEVELS_BOOT, s->sysv_runlevels) &&
913             chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
914                 /* Service has both boot and "up" runlevels
915                    configured.  Kill the "up" ones. */
916                 delete_chars(s->sysv_runlevels, RUNLEVELS_UP);
917         }
918
919         if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
920                 /* If there a runlevels configured for this service
921                  * but none of the standard ones, then we assume this
922                  * is some special kind of service (which might be
923                  * needed for early boot) and don't create any links
924                  * to it. */
925
926                 UNIT(s)->default_dependencies = false;
927
928                 /* Don't timeout special services during boot (like fsck) */
929                 s->timeout_start_usec = 0;
930                 s->timeout_stop_usec = 0;
931         } else {
932                 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
933                 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
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_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
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                                 }
2965
2966                                 /* Fall through */
2967
2968                         case SERVICE_RUNNING:
2969                                 service_enter_running(s, f);
2970                                 break;
2971
2972                         case SERVICE_STOP_SIGTERM:
2973                         case SERVICE_STOP_SIGKILL:
2974
2975                                 if (!control_pid_good(s))
2976                                         service_enter_stop_post(s, f);
2977
2978                                 /* If there is still a control process, wait for that first */
2979                                 break;
2980
2981                         default:
2982                                 assert_not_reached("Uh, main process died at wrong time.");
2983                         }
2984                 }
2985
2986         } else if (s->control_pid == pid) {
2987
2988                 s->control_pid = 0;
2989
2990                 if (s->control_command) {
2991                         exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2992
2993                         if (s->control_command->ignore)
2994                                 f = SERVICE_SUCCESS;
2995                 }
2996
2997                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2998                          "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2999
3000                 if (f != SERVICE_SUCCESS)
3001                         s->result = f;
3002
3003                 /* Immediately get rid of the cgroup, so that the
3004                  * kernel doesn't delay the cgroup empty messages for
3005                  * the service cgroup any longer than necessary */
3006                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
3007
3008                 if (s->control_command &&
3009                     s->control_command->command_next &&
3010                     f == SERVICE_SUCCESS) {
3011
3012                         /* There is another command to *
3013                          * execute, so let's do that. */
3014
3015                         log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
3016                         service_run_next_control(s);
3017
3018                 } else {
3019                         /* No further commands for this step, so let's
3020                          * figure out what to do next */
3021
3022                         s->control_command = NULL;
3023                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3024
3025                         log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
3026
3027                         switch (s->state) {
3028
3029                         case SERVICE_START_PRE:
3030                                 if (f == SERVICE_SUCCESS)
3031                                         service_enter_start(s);
3032                                 else
3033                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3034                                 break;
3035
3036                         case SERVICE_START:
3037                                 if (s->type != SERVICE_FORKING)
3038                                         /* Maybe spurious event due to a reload that changed the type? */
3039                                         break;
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