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