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