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