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