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