]> 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
networkd: update logging macros for parameter order, and errno, to match rest of...
[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
27 #include "async.h"
28 #include "manager.h"
29 #include "unit.h"
30 #include "service.h"
31 #include "load-fragment.h"
32 #include "load-dropin.h"
33 #include "log.h"
34 #include "strv.h"
35 #include "unit-name.h"
36 #include "unit-printf.h"
37 #include "dbus-service.h"
38 #include "special.h"
39 #include "exit-status.h"
40 #include "def.h"
41 #include "path-util.h"
42 #include "util.h"
43 #include "utf8.h"
44 #include "env-util.h"
45 #include "fileio.h"
46 #include "bus-error.h"
47 #include "bus-util.h"
48 #include "bus-kernel.h"
49
50 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
51 [SERVICE_DEAD] = UNIT_INACTIVE,
52 [SERVICE_START_PRE] = UNIT_ACTIVATING,
53 [SERVICE_START] = UNIT_ACTIVATING,
54 [SERVICE_START_POST] = UNIT_ACTIVATING,
55 [SERVICE_RUNNING] = UNIT_ACTIVE,
56 [SERVICE_EXITED] = UNIT_ACTIVE,
57 [SERVICE_RELOAD] = UNIT_RELOADING,
58 [SERVICE_STOP] = UNIT_DEACTIVATING,
59 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
60 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
61 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
62 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
63 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
64 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
65 [SERVICE_FAILED] = UNIT_FAILED,
66 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
67 };
68
69 /* For Type=idle we never want to delay any other jobs, hence we
70 * consider idle jobs active as soon as we start working on them */
71 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
72 [SERVICE_DEAD] = UNIT_INACTIVE,
73 [SERVICE_START_PRE] = UNIT_ACTIVE,
74 [SERVICE_START] = UNIT_ACTIVE,
75 [SERVICE_START_POST] = UNIT_ACTIVE,
76 [SERVICE_RUNNING] = UNIT_ACTIVE,
77 [SERVICE_EXITED] = UNIT_ACTIVE,
78 [SERVICE_RELOAD] = UNIT_RELOADING,
79 [SERVICE_STOP] = UNIT_DEACTIVATING,
80 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
81 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
82 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
83 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
84 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
85 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
86 [SERVICE_FAILED] = UNIT_FAILED,
87 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
88 };
89
90 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
91 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
92 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
93
94 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
95 static void service_enter_reload_by_notify(Service *s);
96
97 static void service_init(Unit *u) {
98 Service *s = SERVICE(u);
99
100 assert(u);
101 assert(u->load_state == UNIT_STUB);
102
103 s->timeout_start_usec = u->manager->default_timeout_start_usec;
104 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
105 s->restart_usec = u->manager->default_restart_usec;
106 s->type = _SERVICE_TYPE_INVALID;
107 s->socket_fd = -1;
108 s->bus_endpoint_fd = -1;
109 s->guess_main_pid = true;
110
111 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
112
113 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
114 }
115
116 static void service_unwatch_control_pid(Service *s) {
117 assert(s);
118
119 if (s->control_pid <= 0)
120 return;
121
122 unit_unwatch_pid(UNIT(s), s->control_pid);
123 s->control_pid = 0;
124 }
125
126 static void service_unwatch_main_pid(Service *s) {
127 assert(s);
128
129 if (s->main_pid <= 0)
130 return;
131
132 unit_unwatch_pid(UNIT(s), s->main_pid);
133 s->main_pid = 0;
134 }
135
136 static void service_unwatch_pid_file(Service *s) {
137 if (!s->pid_file_pathspec)
138 return;
139
140 log_unit_debug(UNIT(s)->id, "Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
141 path_spec_unwatch(s->pid_file_pathspec);
142 path_spec_done(s->pid_file_pathspec);
143 free(s->pid_file_pathspec);
144 s->pid_file_pathspec = NULL;
145 }
146
147 static int service_set_main_pid(Service *s, pid_t pid) {
148 pid_t ppid;
149
150 assert(s);
151
152 if (pid <= 1)
153 return -EINVAL;
154
155 if (pid == getpid())
156 return -EINVAL;
157
158 if (s->main_pid == pid && s->main_pid_known)
159 return 0;
160
161 if (s->main_pid != pid) {
162 service_unwatch_main_pid(s);
163 exec_status_start(&s->main_exec_status, pid);
164 }
165
166 s->main_pid = pid;
167 s->main_pid_known = true;
168
169 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
170 log_unit_warning(UNIT(s)->id, "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", UNIT(s)->id, pid);
171 s->main_pid_alien = true;
172 } else
173 s->main_pid_alien = false;
174
175 return 0;
176 }
177
178 static void service_close_socket_fd(Service *s) {
179 assert(s);
180
181 s->socket_fd = asynchronous_close(s->socket_fd);
182 }
183
184 static void service_connection_unref(Service *s) {
185 assert(s);
186
187 if (!UNIT_ISSET(s->accept_socket))
188 return;
189
190 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
191 unit_ref_unset(&s->accept_socket);
192 }
193
194 static void service_stop_watchdog(Service *s) {
195 assert(s);
196
197 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
198 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
199 }
200
201 static void service_start_watchdog(Service *s) {
202 int r;
203
204 assert(s);
205
206 if (s->watchdog_usec <= 0)
207 return;
208
209 if (s->watchdog_event_source) {
210 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
211 if (r < 0) {
212 log_unit_warning(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
213 return;
214 }
215
216 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
217 } else {
218 r = sd_event_add_time(
219 UNIT(s)->manager->event,
220 &s->watchdog_event_source,
221 CLOCK_MONOTONIC,
222 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
223 service_dispatch_watchdog, s);
224 if (r < 0) {
225 log_unit_warning(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
226 return;
227 }
228
229 /* Let's process everything else which might be a sign
230 * of living before we consider a service died. */
231 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
232 }
233
234 if (r < 0)
235 log_unit_warning(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
236 }
237
238 static void service_reset_watchdog(Service *s) {
239 assert(s);
240
241 dual_timestamp_get(&s->watchdog_timestamp);
242 service_start_watchdog(s);
243 }
244
245 static void service_done(Unit *u) {
246 Service *s = SERVICE(u);
247
248 assert(s);
249
250 free(s->pid_file);
251 s->pid_file = NULL;
252
253 free(s->status_text);
254 s->status_text = NULL;
255
256 free(s->reboot_arg);
257 s->reboot_arg = NULL;
258
259 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
260 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
261 s->control_command = NULL;
262 s->main_command = NULL;
263
264 exit_status_set_free(&s->restart_prevent_status);
265 exit_status_set_free(&s->restart_force_status);
266 exit_status_set_free(&s->success_status);
267
268 /* This will leak a process, but at least no memory or any of
269 * our resources */
270 service_unwatch_main_pid(s);
271 service_unwatch_control_pid(s);
272 service_unwatch_pid_file(s);
273
274 if (s->bus_name) {
275 unit_unwatch_bus_name(u, s->bus_name);
276 free(s->bus_name);
277 s->bus_name = NULL;
278 }
279
280 s->bus_endpoint_fd = safe_close(s->bus_endpoint_fd);
281 service_close_socket_fd(s);
282 service_connection_unref(s);
283
284 unit_ref_unset(&s->accept_socket);
285
286 service_stop_watchdog(s);
287
288 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
289 }
290
291 static int service_arm_timer(Service *s, usec_t usec) {
292 int r;
293
294 assert(s);
295
296 if (s->timer_event_source) {
297 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
298 if (r < 0)
299 return r;
300
301 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
302 }
303
304 return sd_event_add_time(
305 UNIT(s)->manager->event,
306 &s->timer_event_source,
307 CLOCK_MONOTONIC,
308 now(CLOCK_MONOTONIC) + usec, 0,
309 service_dispatch_timer, s);
310 }
311
312 static int service_verify(Service *s) {
313 assert(s);
314
315 if (UNIT(s)->load_state != UNIT_LOADED)
316 return 0;
317
318 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
319 log_unit_error(UNIT(s)->id, "%s lacks both ExecStart= and ExecStop= setting. Refusing.", UNIT(s)->id);
320 return -EINVAL;
321 }
322
323 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
324 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
325 return -EINVAL;
326 }
327
328 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
329 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.", UNIT(s)->id);
330 return -EINVAL;
331 }
332
333 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
334 log_unit_error(UNIT(s)->id, "%s has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
335 return -EINVAL;
336 }
337
338 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
339 log_unit_error(UNIT(s)->id, "%s has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
340 return -EINVAL;
341 }
342
343 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
344 log_unit_error(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
345 return -EINVAL;
346 }
347
348 if (s->type == SERVICE_DBUS && !s->bus_name) {
349 log_unit_error(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
350 return -EINVAL;
351 }
352
353 if (s->bus_name && s->type != SERVICE_DBUS)
354 log_unit_warning(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
355
356 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
357 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
358 return -EINVAL;
359 }
360
361 return 0;
362 }
363
364 static int service_add_default_dependencies(Service *s) {
365 int r;
366
367 assert(s);
368
369 /* Add a number of automatic dependencies useful for the
370 * majority of services. */
371
372 /* First, pull in base system */
373 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
374 if (r < 0)
375 return r;
376
377 /* Second, activate normal shutdown */
378 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
379 return r;
380 }
381
382 static void service_fix_output(Service *s) {
383 assert(s);
384
385 /* If nothing has been explicitly configured, patch default
386 * output in. If input is socket/tty we avoid this however,
387 * since in that case we want output to default to the same
388 * place as we read input from. */
389
390 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
391 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
392 s->exec_context.std_input == EXEC_INPUT_NULL)
393 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
394
395 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
396 s->exec_context.std_input == EXEC_INPUT_NULL)
397 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
398 }
399
400 static int service_load(Unit *u) {
401 Service *s = SERVICE(u);
402 int r;
403
404 assert(s);
405
406 /* Load a .service file */
407 r = unit_load_fragment(u);
408 if (r < 0)
409 return r;
410
411 /* Still nothing found? Then let's give up */
412 if (u->load_state == UNIT_STUB)
413 return -ENOENT;
414
415 /* This is a new unit? Then let's add in some extras */
416 if (u->load_state == UNIT_LOADED) {
417
418 /* We were able to load something, then let's add in
419 * the dropin directories. */
420 r = unit_load_dropin(u);
421 if (r < 0)
422 return r;
423
424 if (s->type == _SERVICE_TYPE_INVALID) {
425 /* Figure out a type automatically */
426 if (s->bus_name)
427 s->type = SERVICE_DBUS;
428 else if (s->exec_command[SERVICE_EXEC_START])
429 s->type = SERVICE_SIMPLE;
430 else
431 s->type = SERVICE_ONESHOT;
432 }
433
434 /* Oneshot services have disabled start timeout by default */
435 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
436 s->timeout_start_usec = 0;
437
438 service_fix_output(s);
439
440 r = unit_patch_contexts(u);
441 if (r < 0)
442 return r;
443
444 r = unit_add_exec_dependencies(u, &s->exec_context);
445 if (r < 0)
446 return r;
447
448 r = unit_add_default_slice(u, &s->cgroup_context);
449 if (r < 0)
450 return r;
451
452 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
453 s->notify_access = NOTIFY_MAIN;
454
455 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
456 s->notify_access = NOTIFY_MAIN;
457
458 if (s->bus_name) {
459 r = unit_watch_bus_name(u, s->bus_name);
460 if (r < 0)
461 return r;
462 }
463
464 if (u->default_dependencies) {
465 r = service_add_default_dependencies(s);
466 if (r < 0)
467
468 return r;
469 }
470 }
471
472 return service_verify(s);
473 }
474
475 static void service_dump(Unit *u, FILE *f, const char *prefix) {
476 ServiceExecCommand c;
477 Service *s = SERVICE(u);
478 const char *prefix2;
479
480 assert(s);
481
482 prefix = strempty(prefix);
483 prefix2 = strappenda(prefix, "\t");
484
485 fprintf(f,
486 "%sService State: %s\n"
487 "%sResult: %s\n"
488 "%sReload Result: %s\n"
489 "%sPermissionsStartOnly: %s\n"
490 "%sRootDirectoryStartOnly: %s\n"
491 "%sRemainAfterExit: %s\n"
492 "%sGuessMainPID: %s\n"
493 "%sType: %s\n"
494 "%sRestart: %s\n"
495 "%sNotifyAccess: %s\n"
496 "%sNotifyState: %s\n",
497 prefix, service_state_to_string(s->state),
498 prefix, service_result_to_string(s->result),
499 prefix, service_result_to_string(s->reload_result),
500 prefix, yes_no(s->permissions_start_only),
501 prefix, yes_no(s->root_directory_start_only),
502 prefix, yes_no(s->remain_after_exit),
503 prefix, yes_no(s->guess_main_pid),
504 prefix, service_type_to_string(s->type),
505 prefix, service_restart_to_string(s->restart),
506 prefix, notify_access_to_string(s->notify_access),
507 prefix, notify_state_to_string(s->notify_state));
508
509 if (s->control_pid > 0)
510 fprintf(f,
511 "%sControl PID: "PID_FMT"\n",
512 prefix, s->control_pid);
513
514 if (s->main_pid > 0)
515 fprintf(f,
516 "%sMain PID: "PID_FMT"\n"
517 "%sMain PID Known: %s\n"
518 "%sMain PID Alien: %s\n",
519 prefix, s->main_pid,
520 prefix, yes_no(s->main_pid_known),
521 prefix, yes_no(s->main_pid_alien));
522
523 if (s->pid_file)
524 fprintf(f,
525 "%sPIDFile: %s\n",
526 prefix, s->pid_file);
527
528 if (s->bus_name)
529 fprintf(f,
530 "%sBusName: %s\n"
531 "%sBus Name Good: %s\n",
532 prefix, s->bus_name,
533 prefix, yes_no(s->bus_name_good));
534
535 kill_context_dump(&s->kill_context, f, prefix);
536 exec_context_dump(&s->exec_context, f, prefix);
537
538 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
539
540 if (!s->exec_command[c])
541 continue;
542
543 fprintf(f, "%s-> %s:\n",
544 prefix, service_exec_command_to_string(c));
545
546 exec_command_dump_list(s->exec_command[c], f, prefix2);
547 }
548
549 #ifdef HAVE_SYSV_COMPAT
550 if (s->sysv_start_priority >= 0)
551 fprintf(f,
552 "%sSysVStartPriority: %i\n",
553 prefix, s->sysv_start_priority);
554 #endif
555
556 if (s->status_text)
557 fprintf(f, "%sStatus Text: %s\n",
558 prefix, s->status_text);
559 }
560
561 static int service_load_pid_file(Service *s, bool may_warn) {
562 _cleanup_free_ char *k = NULL;
563 int r;
564 pid_t pid;
565
566 assert(s);
567
568 if (!s->pid_file)
569 return -ENOENT;
570
571 r = read_one_line_file(s->pid_file, &k);
572 if (r < 0) {
573 if (may_warn)
574 log_unit_info(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
575 return r;
576 }
577
578 r = parse_pid(k, &pid);
579 if (r < 0) {
580 if (may_warn)
581 log_unit_info(UNIT(s)->id, "Failed to read PID from file %s: %s", s->pid_file, strerror(-r));
582 return r;
583 }
584
585 if (!pid_is_alive(pid)) {
586 if (may_warn)
587 log_unit_info(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
588 return -ESRCH;
589 }
590
591 if (s->main_pid_known) {
592 if (pid == s->main_pid)
593 return 0;
594
595 log_unit_debug(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
596
597 service_unwatch_main_pid(s);
598 s->main_pid_known = false;
599 } else
600 log_unit_debug(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
601
602 r = service_set_main_pid(s, pid);
603 if (r < 0)
604 return r;
605
606 r = unit_watch_pid(UNIT(s), pid);
607 if (r < 0) {
608 /* FIXME: we need to do something here */
609 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
610 return r;
611 }
612
613 return 0;
614 }
615
616 static int service_search_main_pid(Service *s) {
617 pid_t pid;
618 int r;
619
620 assert(s);
621
622 /* If we know it anyway, don't ever fallback to unreliable
623 * heuristics */
624 if (s->main_pid_known)
625 return 0;
626
627 if (!s->guess_main_pid)
628 return 0;
629
630 assert(s->main_pid <= 0);
631
632 pid = unit_search_main_pid(UNIT(s));
633 if (pid <= 0)
634 return -ENOENT;
635
636 log_unit_debug(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
637 r = service_set_main_pid(s, pid);
638 if (r < 0)
639 return r;
640
641 r = unit_watch_pid(UNIT(s), pid);
642 if (r < 0) {
643 /* FIXME: we need to do something here */
644 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
645 return r;
646 }
647
648 return 0;
649 }
650
651 static void service_set_state(Service *s, ServiceState state) {
652 ServiceState old_state;
653 const UnitActiveState *table;
654
655 assert(s);
656
657 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
658
659 old_state = s->state;
660 s->state = state;
661
662 service_unwatch_pid_file(s);
663
664 if (!IN_SET(state,
665 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
666 SERVICE_RELOAD,
667 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
668 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
669 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
670 SERVICE_AUTO_RESTART))
671 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
672
673 if (!IN_SET(state,
674 SERVICE_START, SERVICE_START_POST,
675 SERVICE_RUNNING, SERVICE_RELOAD,
676 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
677 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
678 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
679 service_unwatch_main_pid(s);
680 s->main_command = NULL;
681 }
682
683 if (!IN_SET(state,
684 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
685 SERVICE_RELOAD,
686 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
687 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
688 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
689 service_unwatch_control_pid(s);
690 s->control_command = NULL;
691 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
692 }
693
694 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
695 unit_unwatch_all_pids(UNIT(s));
696
697 if (!IN_SET(state,
698 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
699 SERVICE_RUNNING, SERVICE_RELOAD,
700 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
701 SERVICE_STOP_SIGABRT, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
702 !(state == SERVICE_DEAD && UNIT(s)->job)) {
703 service_close_socket_fd(s);
704 service_connection_unref(s);
705 }
706
707 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
708 service_stop_watchdog(s);
709
710 /* For the inactive states unit_notify() will trim the cgroup,
711 * but for exit we have to do that ourselves... */
712 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
713 unit_destroy_cgroup(UNIT(s));
714
715 /* For remain_after_exit services, let's see if we can "release" the
716 * hold on the console, since unit_notify() only does that in case of
717 * change of state */
718 if (state == SERVICE_EXITED &&
719 s->remain_after_exit &&
720 UNIT(s)->manager->n_on_console > 0) {
721
722 ExecContext *ec;
723
724 ec = unit_get_exec_context(UNIT(s));
725 if (ec && exec_context_may_touch_console(ec)) {
726 Manager *m = UNIT(s)->manager;
727
728 m->n_on_console --;
729 if (m->n_on_console == 0)
730 /* unset no_console_output flag, since the console is free */
731 m->no_console_output = false;
732 }
733 }
734
735 if (old_state != state)
736 log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
737
738 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
739 s->reload_result = SERVICE_SUCCESS;
740 }
741
742 static int service_coldplug(Unit *u) {
743 Service *s = SERVICE(u);
744 int r;
745
746 assert(s);
747 assert(s->state == SERVICE_DEAD);
748
749 if (s->deserialized_state != s->state) {
750
751 if (IN_SET(s->deserialized_state,
752 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
753 SERVICE_RELOAD,
754 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
755 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
756 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
757
758 usec_t k;
759
760 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
761
762 /* For the start/stop timeouts 0 means off */
763 if (k > 0) {
764 r = service_arm_timer(s, k);
765 if (r < 0)
766 return r;
767 }
768 }
769
770 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
771
772 /* The restart timeouts 0 means immediately */
773 r = service_arm_timer(s, s->restart_usec);
774 if (r < 0)
775 return r;
776 }
777
778 if (pid_is_unwaited(s->main_pid) &&
779 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
780 IN_SET(s->deserialized_state,
781 SERVICE_START, SERVICE_START_POST,
782 SERVICE_RUNNING, SERVICE_RELOAD,
783 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
784 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
785 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
786 r = unit_watch_pid(UNIT(s), s->main_pid);
787 if (r < 0)
788 return r;
789 }
790
791 if (pid_is_unwaited(s->control_pid) &&
792 IN_SET(s->deserialized_state,
793 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
794 SERVICE_RELOAD,
795 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
796 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
797 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
798 r = unit_watch_pid(UNIT(s), s->control_pid);
799 if (r < 0)
800 return r;
801 }
802
803 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
804 unit_watch_all_pids(UNIT(s));
805
806 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
807 service_start_watchdog(s);
808
809 service_set_state(s, s->deserialized_state);
810 }
811
812 return 0;
813 }
814
815 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
816 Iterator i;
817 int r;
818 int *rfds = NULL;
819 unsigned rn_fds = 0;
820 Unit *u;
821
822 assert(s);
823 assert(fds);
824 assert(n_fds);
825
826 if (s->socket_fd >= 0)
827 return 0;
828
829 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
830 int *cfds;
831 unsigned cn_fds;
832 Socket *sock;
833
834 if (u->type != UNIT_SOCKET)
835 continue;
836
837 sock = SOCKET(u);
838
839 r = socket_collect_fds(sock, &cfds, &cn_fds);
840 if (r < 0)
841 goto fail;
842
843 if (!cfds)
844 continue;
845
846 if (!rfds) {
847 rfds = cfds;
848 rn_fds = cn_fds;
849 } else {
850 int *t;
851
852 t = new(int, rn_fds+cn_fds);
853 if (!t) {
854 free(cfds);
855 r = -ENOMEM;
856 goto fail;
857 }
858
859 memcpy(t, rfds, rn_fds * sizeof(int));
860 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
861 free(rfds);
862 free(cfds);
863
864 rfds = t;
865 rn_fds = rn_fds+cn_fds;
866 }
867 }
868
869 *fds = rfds;
870 *n_fds = rn_fds;
871
872 return 0;
873
874 fail:
875 free(rfds);
876
877 return r;
878 }
879
880 static int service_spawn(
881 Service *s,
882 ExecCommand *c,
883 usec_t timeout,
884 bool pass_fds,
885 bool apply_permissions,
886 bool apply_chroot,
887 bool apply_tty_stdin,
888 bool is_control,
889 pid_t *_pid) {
890
891 pid_t pid;
892 int r;
893 int *fds = NULL;
894 _cleanup_free_ int *fdsbuf = NULL;
895 unsigned n_fds = 0, n_env = 0;
896 _cleanup_free_ char *bus_endpoint_path = NULL;
897 _cleanup_strv_free_ char
898 **argv = NULL, **final_env = NULL, **our_env = NULL;
899 const char *path;
900 ExecParameters exec_params = {
901 .apply_permissions = apply_permissions,
902 .apply_chroot = apply_chroot,
903 .apply_tty_stdin = apply_tty_stdin,
904 .bus_endpoint_fd = -1,
905 .selinux_context_net = s->socket_fd_selinux_context_net
906 };
907
908 assert(s);
909 assert(c);
910 assert(_pid);
911
912 unit_realize_cgroup(UNIT(s));
913
914 r = unit_setup_exec_runtime(UNIT(s));
915 if (r < 0)
916 goto fail;
917
918 if (pass_fds ||
919 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
920 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
921 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
922
923 if (s->socket_fd >= 0) {
924 fds = &s->socket_fd;
925 n_fds = 1;
926 } else {
927 r = service_collect_fds(s, &fdsbuf, &n_fds);
928 if (r < 0)
929 goto fail;
930
931 fds = fdsbuf;
932 }
933 }
934
935 if (timeout > 0) {
936 r = service_arm_timer(s, timeout);
937 if (r < 0)
938 goto fail;
939 } else
940 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
941
942 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
943 if (r < 0)
944 goto fail;
945
946 our_env = new0(char*, 4);
947 if (!our_env) {
948 r = -ENOMEM;
949 goto fail;
950 }
951
952 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
953 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
954 r = -ENOMEM;
955 goto fail;
956 }
957
958 if (s->main_pid > 0)
959 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
960 r = -ENOMEM;
961 goto fail;
962 }
963
964 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
965 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
966 r = -ENOMEM;
967 goto fail;
968 }
969
970 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
971 if (!final_env) {
972 r = -ENOMEM;
973 goto fail;
974 }
975
976 if (is_control && UNIT(s)->cgroup_path) {
977 path = strappenda(UNIT(s)->cgroup_path, "/control");
978 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
979 } else
980 path = UNIT(s)->cgroup_path;
981
982 #ifdef ENABLE_KDBUS
983 if (s->exec_context.bus_endpoint) {
984 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
985 UNIT(s)->id, &bus_endpoint_path);
986 if (r < 0)
987 goto fail;
988
989 /* Pass the fd to the exec_params so that the child process can upload the policy.
990 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
991 * as the service is running. */
992 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
993 }
994 #endif
995
996 exec_params.argv = argv;
997 exec_params.fds = fds;
998 exec_params.n_fds = n_fds;
999 exec_params.environment = final_env;
1000 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1001 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1002 exec_params.cgroup_path = path;
1003 exec_params.cgroup_delegate = s->cgroup_context.delegate;
1004 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1005 exec_params.unit_id = UNIT(s)->id;
1006 exec_params.watchdog_usec = s->watchdog_usec;
1007 exec_params.bus_endpoint_path = bus_endpoint_path;
1008 if (s->type == SERVICE_IDLE)
1009 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1010
1011 r = exec_spawn(c,
1012 &s->exec_context,
1013 &exec_params,
1014 s->exec_runtime,
1015 &pid);
1016 if (r < 0)
1017 goto fail;
1018
1019 r = unit_watch_pid(UNIT(s), pid);
1020 if (r < 0)
1021 /* FIXME: we need to do something here */
1022 goto fail;
1023
1024 *_pid = pid;
1025
1026 return 0;
1027
1028 fail:
1029 if (timeout)
1030 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1031
1032 return r;
1033 }
1034
1035 static int main_pid_good(Service *s) {
1036 assert(s);
1037
1038 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1039 * don't know */
1040
1041 /* If we know the pid file, then lets just check if it is
1042 * still valid */
1043 if (s->main_pid_known) {
1044
1045 /* If it's an alien child let's check if it is still
1046 * alive ... */
1047 if (s->main_pid_alien && s->main_pid > 0)
1048 return pid_is_alive(s->main_pid);
1049
1050 /* .. otherwise assume we'll get a SIGCHLD for it,
1051 * which we really should wait for to collect exit
1052 * status and code */
1053 return s->main_pid > 0;
1054 }
1055
1056 /* We don't know the pid */
1057 return -EAGAIN;
1058 }
1059
1060 _pure_ static int control_pid_good(Service *s) {
1061 assert(s);
1062
1063 return s->control_pid > 0;
1064 }
1065
1066 static int cgroup_good(Service *s) {
1067 int r;
1068
1069 assert(s);
1070
1071 if (!UNIT(s)->cgroup_path)
1072 return 0;
1073
1074 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1075 if (r < 0)
1076 return r;
1077
1078 return !r;
1079 }
1080
1081 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1082 int r;
1083 assert(s);
1084
1085 if (f != SERVICE_SUCCESS)
1086 s->result = f;
1087
1088 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1089
1090 if (s->result != SERVICE_SUCCESS) {
1091 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1092 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1093 }
1094
1095 if (allow_restart &&
1096 !s->forbid_restart &&
1097 (s->restart == SERVICE_RESTART_ALWAYS ||
1098 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1099 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1100 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1101 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1102 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1103 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1104 (IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) && set_contains(s->restart_force_status.signal, INT_TO_PTR(s->main_exec_status.status)))) &&
1105 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1106 (!IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) || !set_contains(s->restart_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1107
1108 r = service_arm_timer(s, s->restart_usec);
1109 if (r < 0)
1110 goto fail;
1111
1112 service_set_state(s, SERVICE_AUTO_RESTART);
1113 }
1114
1115 s->forbid_restart = false;
1116
1117 /* We want fresh tmpdirs in case service is started again immediately */
1118 exec_runtime_destroy(s->exec_runtime);
1119 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1120
1121 /* Also, remove the runtime directory in */
1122 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1123
1124 /* Try to delete the pid file. At this point it will be
1125 * out-of-date, and some software might be confused by it, so
1126 * let's remove it. */
1127 if (s->pid_file)
1128 unlink_noerrno(s->pid_file);
1129
1130 return;
1131
1132 fail:
1133 log_unit_warning(UNIT(s)->id, "%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1134 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1135 }
1136
1137 static void service_enter_stop_post(Service *s, ServiceResult f) {
1138 int r;
1139 assert(s);
1140
1141 if (f != SERVICE_SUCCESS)
1142 s->result = f;
1143
1144 service_unwatch_control_pid(s);
1145 unit_watch_all_pids(UNIT(s));
1146
1147 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1148 if (s->control_command) {
1149 s->control_command_id = SERVICE_EXEC_STOP_POST;
1150
1151 r = service_spawn(s,
1152 s->control_command,
1153 s->timeout_stop_usec,
1154 false,
1155 !s->permissions_start_only,
1156 !s->root_directory_start_only,
1157 true,
1158 true,
1159 &s->control_pid);
1160 if (r < 0)
1161 goto fail;
1162
1163 service_set_state(s, SERVICE_STOP_POST);
1164 } else
1165 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1166
1167 return;
1168
1169 fail:
1170 log_unit_warning(UNIT(s)->id, "%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1171 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1172 }
1173
1174 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1175 int r;
1176
1177 assert(s);
1178
1179 if (f != SERVICE_SUCCESS)
1180 s->result = f;
1181
1182 unit_watch_all_pids(UNIT(s));
1183
1184 r = unit_kill_context(
1185 UNIT(s),
1186 &s->kill_context,
1187 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1188 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
1189 s->main_pid,
1190 s->control_pid,
1191 s->main_pid_alien);
1192
1193 if (r < 0)
1194 goto fail;
1195
1196 if (r > 0) {
1197 if (s->timeout_stop_usec > 0) {
1198 r = service_arm_timer(s, s->timeout_stop_usec);
1199 if (r < 0)
1200 goto fail;
1201 }
1202
1203 service_set_state(s, state);
1204 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
1205 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1206 else if (state == SERVICE_STOP_SIGKILL)
1207 service_enter_stop_post(s, SERVICE_SUCCESS);
1208 else if (state == SERVICE_FINAL_SIGTERM)
1209 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1210 else
1211 service_enter_dead(s, SERVICE_SUCCESS, true);
1212
1213 return;
1214
1215 fail:
1216 log_unit_warning(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1217
1218 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1219 state == SERVICE_STOP_SIGABRT)
1220 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1221 else
1222 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1223 }
1224
1225 static void service_enter_stop_by_notify(Service *s) {
1226 assert(s);
1227
1228 unit_watch_all_pids(UNIT(s));
1229
1230 if (s->timeout_stop_usec > 0)
1231 service_arm_timer(s, s->timeout_stop_usec);
1232
1233 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1234 service_set_state(s, SERVICE_STOP_SIGTERM);
1235 }
1236
1237 static void service_enter_stop(Service *s, ServiceResult f) {
1238 int r;
1239
1240 assert(s);
1241
1242 if (f != SERVICE_SUCCESS)
1243 s->result = f;
1244
1245 service_unwatch_control_pid(s);
1246 unit_watch_all_pids(UNIT(s));
1247
1248 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1249 if (s->control_command) {
1250 s->control_command_id = SERVICE_EXEC_STOP;
1251
1252 r = service_spawn(s,
1253 s->control_command,
1254 s->timeout_stop_usec,
1255 false,
1256 !s->permissions_start_only,
1257 !s->root_directory_start_only,
1258 false,
1259 true,
1260 &s->control_pid);
1261 if (r < 0)
1262 goto fail;
1263
1264 service_set_state(s, SERVICE_STOP);
1265 } else
1266 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1267
1268 return;
1269
1270 fail:
1271 log_unit_warning(UNIT(s)->id, "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
1272 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1273 }
1274
1275 static void service_enter_running(Service *s, ServiceResult f) {
1276 int main_pid_ok, cgroup_ok;
1277 assert(s);
1278
1279 if (f != SERVICE_SUCCESS)
1280 s->result = f;
1281
1282 main_pid_ok = main_pid_good(s);
1283 cgroup_ok = cgroup_good(s);
1284
1285 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1286 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1287
1288 /* If there are any queued up sd_notify()
1289 * notifications, process them now */
1290 if (s->notify_state == NOTIFY_RELOADING)
1291 service_enter_reload_by_notify(s);
1292 else if (s->notify_state == NOTIFY_STOPPING)
1293 service_enter_stop_by_notify(s);
1294 else
1295 service_set_state(s, SERVICE_RUNNING);
1296
1297 } else if (s->remain_after_exit)
1298 service_set_state(s, SERVICE_EXITED);
1299 else
1300 service_enter_stop(s, SERVICE_SUCCESS);
1301 }
1302
1303 static void service_enter_start_post(Service *s) {
1304 int r;
1305 assert(s);
1306
1307 service_unwatch_control_pid(s);
1308 service_reset_watchdog(s);
1309
1310 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1311 if (s->control_command) {
1312 s->control_command_id = SERVICE_EXEC_START_POST;
1313
1314 r = service_spawn(s,
1315 s->control_command,
1316 s->timeout_start_usec,
1317 false,
1318 !s->permissions_start_only,
1319 !s->root_directory_start_only,
1320 false,
1321 true,
1322 &s->control_pid);
1323 if (r < 0)
1324 goto fail;
1325
1326 service_set_state(s, SERVICE_START_POST);
1327 } else
1328 service_enter_running(s, SERVICE_SUCCESS);
1329
1330 return;
1331
1332 fail:
1333 log_unit_warning(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1334 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1335 }
1336
1337 static void service_kill_control_processes(Service *s) {
1338 char *p;
1339
1340 if (!UNIT(s)->cgroup_path)
1341 return;
1342
1343 p = strappenda(UNIT(s)->cgroup_path, "/control");
1344 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1345 }
1346
1347 static void service_enter_start(Service *s) {
1348 ExecCommand *c;
1349 pid_t pid;
1350 int r;
1351
1352 assert(s);
1353
1354 service_unwatch_control_pid(s);
1355 service_unwatch_main_pid(s);
1356
1357 /* We want to ensure that nobody leaks processes from
1358 * START_PRE here, so let's go on a killing spree, People
1359 * should not spawn long running processes from START_PRE. */
1360 service_kill_control_processes(s);
1361
1362 if (s->type == SERVICE_FORKING) {
1363 s->control_command_id = SERVICE_EXEC_START;
1364 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1365
1366 s->main_command = NULL;
1367 } else {
1368 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1369 s->control_command = NULL;
1370
1371 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1372 }
1373
1374 if (!c) {
1375 assert(s->type == SERVICE_ONESHOT);
1376 service_enter_start_post(s);
1377 return;
1378 }
1379
1380 r = service_spawn(s,
1381 c,
1382 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1383 true,
1384 true,
1385 true,
1386 true,
1387 false,
1388 &pid);
1389 if (r < 0)
1390 goto fail;
1391
1392 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1393 /* For simple services we immediately start
1394 * the START_POST binaries. */
1395
1396 service_set_main_pid(s, pid);
1397 service_enter_start_post(s);
1398
1399 } else if (s->type == SERVICE_FORKING) {
1400
1401 /* For forking services we wait until the start
1402 * process exited. */
1403
1404 s->control_pid = pid;
1405 service_set_state(s, SERVICE_START);
1406
1407 } else if (s->type == SERVICE_ONESHOT ||
1408 s->type == SERVICE_DBUS ||
1409 s->type == SERVICE_NOTIFY) {
1410
1411 /* For oneshot services we wait until the start
1412 * process exited, too, but it is our main process. */
1413
1414 /* For D-Bus services we know the main pid right away,
1415 * but wait for the bus name to appear on the
1416 * bus. Notify services are similar. */
1417
1418 service_set_main_pid(s, pid);
1419 service_set_state(s, SERVICE_START);
1420 } else
1421 assert_not_reached("Unknown service type");
1422
1423 return;
1424
1425 fail:
1426 log_unit_warning(UNIT(s)->id, "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
1427 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1428 }
1429
1430 static void service_enter_start_pre(Service *s) {
1431 int r;
1432
1433 assert(s);
1434
1435 service_unwatch_control_pid(s);
1436
1437 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1438 if (s->control_command) {
1439 /* Before we start anything, let's clear up what might
1440 * be left from previous runs. */
1441 service_kill_control_processes(s);
1442
1443 s->control_command_id = SERVICE_EXEC_START_PRE;
1444
1445 r = service_spawn(s,
1446 s->control_command,
1447 s->timeout_start_usec,
1448 false,
1449 !s->permissions_start_only,
1450 !s->root_directory_start_only,
1451 true,
1452 true,
1453 &s->control_pid);
1454 if (r < 0)
1455 goto fail;
1456
1457 service_set_state(s, SERVICE_START_PRE);
1458 } else
1459 service_enter_start(s);
1460
1461 return;
1462
1463 fail:
1464 log_unit_warning(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1465 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1466 }
1467
1468 static void service_enter_restart(Service *s) {
1469 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1470 int r;
1471
1472 assert(s);
1473
1474 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1475 /* Don't restart things if we are going down anyway */
1476 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1477
1478 r = service_arm_timer(s, s->restart_usec);
1479 if (r < 0)
1480 goto fail;
1481
1482 return;
1483 }
1484
1485 /* Any units that are bound to this service must also be
1486 * restarted. We use JOB_RESTART (instead of the more obvious
1487 * JOB_START) here so that those dependency jobs will be added
1488 * as well. */
1489 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1490 if (r < 0)
1491 goto fail;
1492
1493 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1494 * it will be canceled as part of the service_stop() call that
1495 * is executed as part of JOB_RESTART. */
1496
1497 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1498 return;
1499
1500 fail:
1501 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1502 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1503 }
1504
1505 static void service_enter_reload_by_notify(Service *s) {
1506 assert(s);
1507
1508 if (s->timeout_start_usec > 0)
1509 service_arm_timer(s, s->timeout_start_usec);
1510
1511 service_set_state(s, SERVICE_RELOAD);
1512 }
1513
1514 static void service_enter_reload(Service *s) {
1515 int r;
1516
1517 assert(s);
1518
1519 service_unwatch_control_pid(s);
1520
1521 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1522 if (s->control_command) {
1523 s->control_command_id = SERVICE_EXEC_RELOAD;
1524
1525 r = service_spawn(s,
1526 s->control_command,
1527 s->timeout_start_usec,
1528 false,
1529 !s->permissions_start_only,
1530 !s->root_directory_start_only,
1531 false,
1532 true,
1533 &s->control_pid);
1534 if (r < 0)
1535 goto fail;
1536
1537 service_set_state(s, SERVICE_RELOAD);
1538 } else
1539 service_enter_running(s, SERVICE_SUCCESS);
1540
1541 return;
1542
1543 fail:
1544 log_unit_warning(UNIT(s)->id, "%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
1545 s->reload_result = SERVICE_FAILURE_RESOURCES;
1546 service_enter_running(s, SERVICE_SUCCESS);
1547 }
1548
1549 static void service_run_next_control(Service *s) {
1550 int r;
1551
1552 assert(s);
1553 assert(s->control_command);
1554 assert(s->control_command->command_next);
1555
1556 assert(s->control_command_id != SERVICE_EXEC_START);
1557
1558 s->control_command = s->control_command->command_next;
1559 service_unwatch_control_pid(s);
1560
1561 r = service_spawn(s,
1562 s->control_command,
1563 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1564 false,
1565 !s->permissions_start_only,
1566 !s->root_directory_start_only,
1567 s->control_command_id == SERVICE_EXEC_START_PRE ||
1568 s->control_command_id == SERVICE_EXEC_STOP_POST,
1569 true,
1570 &s->control_pid);
1571 if (r < 0)
1572 goto fail;
1573
1574 return;
1575
1576 fail:
1577 log_unit_warning(UNIT(s)->id, "%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
1578
1579 if (s->state == SERVICE_START_PRE)
1580 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1581 else if (s->state == SERVICE_STOP)
1582 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1583 else if (s->state == SERVICE_STOP_POST)
1584 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1585 else if (s->state == SERVICE_RELOAD) {
1586 s->reload_result = SERVICE_FAILURE_RESOURCES;
1587 service_enter_running(s, SERVICE_SUCCESS);
1588 } else
1589 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1590 }
1591
1592 static void service_run_next_main(Service *s) {
1593 pid_t pid;
1594 int r;
1595
1596 assert(s);
1597 assert(s->main_command);
1598 assert(s->main_command->command_next);
1599 assert(s->type == SERVICE_ONESHOT);
1600
1601 s->main_command = s->main_command->command_next;
1602 service_unwatch_main_pid(s);
1603
1604 r = service_spawn(s,
1605 s->main_command,
1606 s->timeout_start_usec,
1607 true,
1608 true,
1609 true,
1610 true,
1611 false,
1612 &pid);
1613 if (r < 0)
1614 goto fail;
1615
1616 service_set_main_pid(s, pid);
1617
1618 return;
1619
1620 fail:
1621 log_unit_warning(UNIT(s)->id, "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
1622 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1623 }
1624
1625 static int service_start_limit_test(Service *s) {
1626 assert(s);
1627
1628 if (ratelimit_test(&s->start_limit))
1629 return 0;
1630
1631 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1632
1633 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1634 }
1635
1636 static int service_start(Unit *u) {
1637 Service *s = SERVICE(u);
1638 int r;
1639
1640 assert(s);
1641
1642 /* We cannot fulfill this request right now, try again later
1643 * please! */
1644 if (s->state == SERVICE_STOP ||
1645 s->state == SERVICE_STOP_SIGABRT ||
1646 s->state == SERVICE_STOP_SIGTERM ||
1647 s->state == SERVICE_STOP_SIGKILL ||
1648 s->state == SERVICE_STOP_POST ||
1649 s->state == SERVICE_FINAL_SIGTERM ||
1650 s->state == SERVICE_FINAL_SIGKILL)
1651 return -EAGAIN;
1652
1653 /* Already on it! */
1654 if (s->state == SERVICE_START_PRE ||
1655 s->state == SERVICE_START ||
1656 s->state == SERVICE_START_POST)
1657 return 0;
1658
1659 /* A service that will be restarted must be stopped first to
1660 * trigger BindsTo and/or OnFailure dependencies. If a user
1661 * does not want to wait for the holdoff time to elapse, the
1662 * service should be manually restarted, not started. We
1663 * simply return EAGAIN here, so that any start jobs stay
1664 * queued, and assume that the auto restart timer will
1665 * eventually trigger the restart. */
1666 if (s->state == SERVICE_AUTO_RESTART)
1667 return -EAGAIN;
1668
1669 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1670
1671 /* Make sure we don't enter a busy loop of some kind. */
1672 r = service_start_limit_test(s);
1673 if (r < 0) {
1674 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1675 return r;
1676 }
1677
1678 s->result = SERVICE_SUCCESS;
1679 s->reload_result = SERVICE_SUCCESS;
1680 s->main_pid_known = false;
1681 s->main_pid_alien = false;
1682 s->forbid_restart = false;
1683
1684 free(s->status_text);
1685 s->status_text = NULL;
1686 s->status_errno = 0;
1687
1688 s->notify_state = NOTIFY_UNKNOWN;
1689
1690 service_enter_start_pre(s);
1691 return 0;
1692 }
1693
1694 static int service_stop(Unit *u) {
1695 Service *s = SERVICE(u);
1696
1697 assert(s);
1698
1699 /* Don't create restart jobs from here. */
1700 s->forbid_restart = true;
1701
1702 /* Already on it */
1703 if (s->state == SERVICE_STOP ||
1704 s->state == SERVICE_STOP_SIGABRT ||
1705 s->state == SERVICE_STOP_SIGTERM ||
1706 s->state == SERVICE_STOP_SIGKILL ||
1707 s->state == SERVICE_STOP_POST ||
1708 s->state == SERVICE_FINAL_SIGTERM ||
1709 s->state == SERVICE_FINAL_SIGKILL)
1710 return 0;
1711
1712 /* A restart will be scheduled or is in progress. */
1713 if (s->state == SERVICE_AUTO_RESTART) {
1714 service_set_state(s, SERVICE_DEAD);
1715 return 0;
1716 }
1717
1718 /* If there's already something running we go directly into
1719 * kill mode. */
1720 if (s->state == SERVICE_START_PRE ||
1721 s->state == SERVICE_START ||
1722 s->state == SERVICE_START_POST ||
1723 s->state == SERVICE_RELOAD) {
1724 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1725 return 0;
1726 }
1727
1728 assert(s->state == SERVICE_RUNNING ||
1729 s->state == SERVICE_EXITED);
1730
1731 service_enter_stop(s, SERVICE_SUCCESS);
1732 return 0;
1733 }
1734
1735 static int service_reload(Unit *u) {
1736 Service *s = SERVICE(u);
1737
1738 assert(s);
1739
1740 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1741
1742 service_enter_reload(s);
1743 return 0;
1744 }
1745
1746 _pure_ static bool service_can_reload(Unit *u) {
1747 Service *s = SERVICE(u);
1748
1749 assert(s);
1750
1751 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1752 }
1753
1754 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1755 Service *s = SERVICE(u);
1756
1757 assert(u);
1758 assert(f);
1759 assert(fds);
1760
1761 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1762 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1763 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1764
1765 if (s->control_pid > 0)
1766 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1767 s->control_pid);
1768
1769 if (s->main_pid_known && s->main_pid > 0)
1770 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1771
1772 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1773
1774 if (s->status_text)
1775 unit_serialize_item(u, f, "status-text", s->status_text);
1776
1777 /* FIXME: There's a minor uncleanliness here: if there are
1778 * multiple commands attached here, we will start from the
1779 * first one again */
1780 if (s->control_command_id >= 0)
1781 unit_serialize_item(u, f, "control-command",
1782 service_exec_command_to_string(s->control_command_id));
1783
1784 if (s->socket_fd >= 0) {
1785 int copy;
1786
1787 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1788 return copy;
1789
1790 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1791 }
1792
1793 if (s->bus_endpoint_fd >= 0) {
1794 int copy;
1795
1796 if ((copy = fdset_put_dup(fds, s->bus_endpoint_fd)) < 0)
1797 return copy;
1798
1799 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
1800 }
1801
1802 if (s->main_exec_status.pid > 0) {
1803 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1804 s->main_exec_status.pid);
1805 dual_timestamp_serialize(f, "main-exec-status-start",
1806 &s->main_exec_status.start_timestamp);
1807 dual_timestamp_serialize(f, "main-exec-status-exit",
1808 &s->main_exec_status.exit_timestamp);
1809
1810 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1811 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1812 s->main_exec_status.code);
1813 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1814 s->main_exec_status.status);
1815 }
1816 }
1817 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1818 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1819
1820 if (s->forbid_restart)
1821 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1822
1823 return 0;
1824 }
1825
1826 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1827 Service *s = SERVICE(u);
1828
1829 assert(u);
1830 assert(key);
1831 assert(value);
1832 assert(fds);
1833
1834 if (streq(key, "state")) {
1835 ServiceState state;
1836
1837 state = service_state_from_string(value);
1838 if (state < 0)
1839 log_unit_debug(u->id, "Failed to parse state value %s", value);
1840 else
1841 s->deserialized_state = state;
1842 } else if (streq(key, "result")) {
1843 ServiceResult f;
1844
1845 f = service_result_from_string(value);
1846 if (f < 0)
1847 log_unit_debug(u->id, "Failed to parse result value %s", value);
1848 else if (f != SERVICE_SUCCESS)
1849 s->result = f;
1850
1851 } else if (streq(key, "reload-result")) {
1852 ServiceResult f;
1853
1854 f = service_result_from_string(value);
1855 if (f < 0)
1856 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
1857 else if (f != SERVICE_SUCCESS)
1858 s->reload_result = f;
1859
1860 } else if (streq(key, "control-pid")) {
1861 pid_t pid;
1862
1863 if (parse_pid(value, &pid) < 0)
1864 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
1865 else
1866 s->control_pid = pid;
1867 } else if (streq(key, "main-pid")) {
1868 pid_t pid;
1869
1870 if (parse_pid(value, &pid) < 0)
1871 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
1872 else {
1873 service_set_main_pid(s, pid);
1874 unit_watch_pid(UNIT(s), pid);
1875 }
1876 } else if (streq(key, "main-pid-known")) {
1877 int b;
1878
1879 b = parse_boolean(value);
1880 if (b < 0)
1881 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
1882 else
1883 s->main_pid_known = b;
1884 } else if (streq(key, "status-text")) {
1885 char *t;
1886
1887 t = strdup(value);
1888 if (!t)
1889 log_oom();
1890 else {
1891 free(s->status_text);
1892 s->status_text = t;
1893 }
1894
1895 } else if (streq(key, "control-command")) {
1896 ServiceExecCommand id;
1897
1898 id = service_exec_command_from_string(value);
1899 if (id < 0)
1900 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
1901 else {
1902 s->control_command_id = id;
1903 s->control_command = s->exec_command[id];
1904 }
1905 } else if (streq(key, "socket-fd")) {
1906 int fd;
1907
1908 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1909 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
1910 else {
1911 asynchronous_close(s->socket_fd);
1912 s->socket_fd = fdset_remove(fds, fd);
1913 }
1914 } else if (streq(key, "endpoint-fd")) {
1915 int fd;
1916
1917 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1918 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
1919 else {
1920 safe_close(s->bus_endpoint_fd);
1921 s->bus_endpoint_fd = fdset_remove(fds, fd);
1922 }
1923 } else if (streq(key, "main-exec-status-pid")) {
1924 pid_t pid;
1925
1926 if (parse_pid(value, &pid) < 0)
1927 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
1928 else
1929 s->main_exec_status.pid = pid;
1930 } else if (streq(key, "main-exec-status-code")) {
1931 int i;
1932
1933 if (safe_atoi(value, &i) < 0)
1934 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
1935 else
1936 s->main_exec_status.code = i;
1937 } else if (streq(key, "main-exec-status-status")) {
1938 int i;
1939
1940 if (safe_atoi(value, &i) < 0)
1941 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
1942 else
1943 s->main_exec_status.status = i;
1944 } else if (streq(key, "main-exec-status-start"))
1945 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
1946 else if (streq(key, "main-exec-status-exit"))
1947 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
1948 else if (streq(key, "watchdog-timestamp"))
1949 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
1950 else if (streq(key, "forbid-restart")) {
1951 int b;
1952
1953 b = parse_boolean(value);
1954 if (b < 0)
1955 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
1956 else
1957 s->forbid_restart = b;
1958 } else
1959 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
1960
1961 return 0;
1962 }
1963
1964 _pure_ static UnitActiveState service_active_state(Unit *u) {
1965 const UnitActiveState *table;
1966
1967 assert(u);
1968
1969 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1970
1971 return table[SERVICE(u)->state];
1972 }
1973
1974 static const char *service_sub_state_to_string(Unit *u) {
1975 assert(u);
1976
1977 return service_state_to_string(SERVICE(u)->state);
1978 }
1979
1980 static bool service_check_gc(Unit *u) {
1981 Service *s = SERVICE(u);
1982
1983 assert(s);
1984
1985 /* Never clean up services that still have a process around,
1986 * even if the service is formally dead. */
1987 if (cgroup_good(s) > 0 ||
1988 main_pid_good(s) > 0 ||
1989 control_pid_good(s) > 0)
1990 return true;
1991
1992 return false;
1993 }
1994
1995 _pure_ static bool service_check_snapshot(Unit *u) {
1996 Service *s = SERVICE(u);
1997
1998 assert(s);
1999
2000 return s->socket_fd < 0;
2001 }
2002
2003 static int service_retry_pid_file(Service *s) {
2004 int r;
2005
2006 assert(s->pid_file);
2007 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2008
2009 r = service_load_pid_file(s, false);
2010 if (r < 0)
2011 return r;
2012
2013 service_unwatch_pid_file(s);
2014
2015 service_enter_running(s, SERVICE_SUCCESS);
2016 return 0;
2017 }
2018
2019 static int service_watch_pid_file(Service *s) {
2020 int r;
2021
2022 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2023
2024 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2025 if (r < 0)
2026 goto fail;
2027
2028 /* the pidfile might have appeared just before we set the watch */
2029 log_unit_debug(UNIT(s)->id, "Trying to read %s's PID file %s in case it changed", UNIT(s)->id, s->pid_file_pathspec->path);
2030 service_retry_pid_file(s);
2031
2032 return 0;
2033 fail:
2034 log_unit_error(UNIT(s)->id, "Failed to set a watch for %s's PID file %s: %s", UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2035 service_unwatch_pid_file(s);
2036 return r;
2037 }
2038
2039 static int service_demand_pid_file(Service *s) {
2040 PathSpec *ps;
2041
2042 assert(s->pid_file);
2043 assert(!s->pid_file_pathspec);
2044
2045 ps = new0(PathSpec, 1);
2046 if (!ps)
2047 return -ENOMEM;
2048
2049 ps->unit = UNIT(s);
2050 ps->path = strdup(s->pid_file);
2051 if (!ps->path) {
2052 free(ps);
2053 return -ENOMEM;
2054 }
2055
2056 path_kill_slashes(ps->path);
2057
2058 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2059 * keep their PID file open all the time. */
2060 ps->type = PATH_MODIFIED;
2061 ps->inotify_fd = -1;
2062
2063 s->pid_file_pathspec = ps;
2064
2065 return service_watch_pid_file(s);
2066 }
2067
2068 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2069 PathSpec *p = userdata;
2070 Service *s;
2071
2072 assert(p);
2073
2074 s = SERVICE(p->unit);
2075
2076 assert(s);
2077 assert(fd >= 0);
2078 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2079 assert(s->pid_file_pathspec);
2080 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2081
2082 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2083
2084 if (path_spec_fd_event(p, events) < 0)
2085 goto fail;
2086
2087 if (service_retry_pid_file(s) == 0)
2088 return 0;
2089
2090 if (service_watch_pid_file(s) < 0)
2091 goto fail;
2092
2093 return 0;
2094
2095 fail:
2096 service_unwatch_pid_file(s);
2097 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2098 return 0;
2099 }
2100
2101 static void service_notify_cgroup_empty_event(Unit *u) {
2102 Service *s = SERVICE(u);
2103
2104 assert(u);
2105
2106 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
2107
2108 switch (s->state) {
2109
2110 /* Waiting for SIGCHLD is usually more interesting,
2111 * because it includes return codes/signals. Which is
2112 * why we ignore the cgroup events for most cases,
2113 * except when we don't know pid which to expect the
2114 * SIGCHLD for. */
2115
2116 case SERVICE_START:
2117 case SERVICE_START_POST:
2118 /* If we were hoping for the daemon to write its PID file,
2119 * we can give up now. */
2120 if (s->pid_file_pathspec) {
2121 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2122
2123 service_unwatch_pid_file(s);
2124 if (s->state == SERVICE_START)
2125 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2126 else
2127 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2128 }
2129 break;
2130
2131 case SERVICE_RUNNING:
2132 /* service_enter_running() will figure out what to do */
2133 service_enter_running(s, SERVICE_SUCCESS);
2134 break;
2135
2136 case SERVICE_STOP_SIGABRT:
2137 case SERVICE_STOP_SIGTERM:
2138 case SERVICE_STOP_SIGKILL:
2139
2140 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2141 service_enter_stop_post(s, SERVICE_SUCCESS);
2142
2143 break;
2144
2145 case SERVICE_STOP_POST:
2146 case SERVICE_FINAL_SIGTERM:
2147 case SERVICE_FINAL_SIGKILL:
2148 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2149 service_enter_dead(s, SERVICE_SUCCESS, true);
2150
2151 break;
2152
2153 default:
2154 ;
2155 }
2156 }
2157
2158 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2159 Service *s = SERVICE(u);
2160 ServiceResult f;
2161
2162 assert(s);
2163 assert(pid >= 0);
2164
2165 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2166 is_clean_exit_lsb(code, status, &s->success_status))
2167 f = SERVICE_SUCCESS;
2168 else if (code == CLD_EXITED)
2169 f = SERVICE_FAILURE_EXIT_CODE;
2170 else if (code == CLD_KILLED)
2171 f = SERVICE_FAILURE_SIGNAL;
2172 else if (code == CLD_DUMPED)
2173 f = SERVICE_FAILURE_CORE_DUMP;
2174 else
2175 assert_not_reached("Unknown code");
2176
2177 if (s->main_pid == pid) {
2178 /* Forking services may occasionally move to a new PID.
2179 * As long as they update the PID file before exiting the old
2180 * PID, they're fine. */
2181 if (service_load_pid_file(s, false) == 0)
2182 return;
2183
2184 s->main_pid = 0;
2185 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2186
2187 if (s->main_command) {
2188 /* If this is not a forking service than the
2189 * main process got started and hence we copy
2190 * the exit status so that it is recorded both
2191 * as main and as control process exit
2192 * status */
2193
2194 s->main_command->exec_status = s->main_exec_status;
2195
2196 if (s->main_command->ignore)
2197 f = SERVICE_SUCCESS;
2198 } else if (s->exec_command[SERVICE_EXEC_START]) {
2199
2200 /* If this is a forked process, then we should
2201 * ignore the return value if this was
2202 * configured for the starter process */
2203
2204 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2205 f = SERVICE_SUCCESS;
2206 }
2207
2208 log_unit_struct(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2209 u->id,
2210 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2211 u->id, sigchld_code_to_string(code), status,
2212 strna(code == CLD_EXITED
2213 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2214 : signal_to_string(status)),
2215 "EXIT_CODE=%s", sigchld_code_to_string(code),
2216 "EXIT_STATUS=%i", status,
2217 NULL);
2218
2219 if (f != SERVICE_SUCCESS)
2220 s->result = f;
2221
2222 if (s->main_command &&
2223 s->main_command->command_next &&
2224 f == SERVICE_SUCCESS) {
2225
2226 /* There is another command to *
2227 * execute, so let's do that. */
2228
2229 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2230 service_run_next_main(s);
2231
2232 } else {
2233
2234 /* The service exited, so the service is officially
2235 * gone. */
2236 s->main_command = NULL;
2237
2238 switch (s->state) {
2239
2240 case SERVICE_START_POST:
2241 case SERVICE_RELOAD:
2242 case SERVICE_STOP:
2243 /* Need to wait until the operation is
2244 * done */
2245 break;
2246
2247 case SERVICE_START:
2248 if (s->type == SERVICE_ONESHOT) {
2249 /* This was our main goal, so let's go on */
2250 if (f == SERVICE_SUCCESS)
2251 service_enter_start_post(s);
2252 else
2253 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2254 break;
2255 }
2256
2257 /* Fall through */
2258
2259 case SERVICE_RUNNING:
2260 service_enter_running(s, f);
2261 break;
2262
2263 case SERVICE_STOP_SIGABRT:
2264 case SERVICE_STOP_SIGTERM:
2265 case SERVICE_STOP_SIGKILL:
2266
2267 if (!control_pid_good(s))
2268 service_enter_stop_post(s, f);
2269
2270 /* If there is still a control process, wait for that first */
2271 break;
2272
2273 case SERVICE_STOP_POST:
2274 case SERVICE_FINAL_SIGTERM:
2275 case SERVICE_FINAL_SIGKILL:
2276
2277 if (!control_pid_good(s))
2278 service_enter_dead(s, f, true);
2279 break;
2280
2281 default:
2282 assert_not_reached("Uh, main process died at wrong time.");
2283 }
2284 }
2285
2286 } else if (s->control_pid == pid) {
2287 s->control_pid = 0;
2288
2289 if (s->control_command) {
2290 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2291
2292 if (s->control_command->ignore)
2293 f = SERVICE_SUCCESS;
2294 }
2295
2296 log_unit_full(u->id,
2297 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2298 "%s: control process exited, code=%s status=%i",
2299 u->id, sigchld_code_to_string(code), status);
2300
2301 if (f != SERVICE_SUCCESS)
2302 s->result = f;
2303
2304 /* Immediately get rid of the cgroup, so that the
2305 * kernel doesn't delay the cgroup empty messages for
2306 * the service cgroup any longer than necessary */
2307 service_kill_control_processes(s);
2308
2309 if (s->control_command &&
2310 s->control_command->command_next &&
2311 f == SERVICE_SUCCESS) {
2312
2313 /* There is another command to *
2314 * execute, so let's do that. */
2315
2316 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2317 service_run_next_control(s);
2318
2319 } else {
2320 /* No further commands for this step, so let's
2321 * figure out what to do next */
2322
2323 s->control_command = NULL;
2324 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2325
2326 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2327
2328 switch (s->state) {
2329
2330 case SERVICE_START_PRE:
2331 if (f == SERVICE_SUCCESS)
2332 service_enter_start(s);
2333 else
2334 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2335 break;
2336
2337 case SERVICE_START:
2338 if (s->type != SERVICE_FORKING)
2339 /* Maybe spurious event due to a reload that changed the type? */
2340 break;
2341
2342 if (f != SERVICE_SUCCESS) {
2343 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2344 break;
2345 }
2346
2347 if (s->pid_file) {
2348 bool has_start_post;
2349 int r;
2350
2351 /* Let's try to load the pid file here if we can.
2352 * The PID file might actually be created by a START_POST
2353 * script. In that case don't worry if the loading fails. */
2354
2355 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2356 r = service_load_pid_file(s, !has_start_post);
2357 if (!has_start_post && r < 0) {
2358 r = service_demand_pid_file(s);
2359 if (r < 0 || !cgroup_good(s))
2360 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2361 break;
2362 }
2363 } else
2364 service_search_main_pid(s);
2365
2366 service_enter_start_post(s);
2367 break;
2368
2369 case SERVICE_START_POST:
2370 if (f != SERVICE_SUCCESS) {
2371 service_enter_stop(s, f);
2372 break;
2373 }
2374
2375 if (s->pid_file) {
2376 int r;
2377
2378 r = service_load_pid_file(s, true);
2379 if (r < 0) {
2380 r = service_demand_pid_file(s);
2381 if (r < 0 || !cgroup_good(s))
2382 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2383 break;
2384 }
2385 } else
2386 service_search_main_pid(s);
2387
2388 service_enter_running(s, SERVICE_SUCCESS);
2389 break;
2390
2391 case SERVICE_RELOAD:
2392 if (f == SERVICE_SUCCESS) {
2393 service_load_pid_file(s, true);
2394 service_search_main_pid(s);
2395 }
2396
2397 s->reload_result = f;
2398 service_enter_running(s, SERVICE_SUCCESS);
2399 break;
2400
2401 case SERVICE_STOP:
2402 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2403 break;
2404
2405 case SERVICE_STOP_SIGABRT:
2406 case SERVICE_STOP_SIGTERM:
2407 case SERVICE_STOP_SIGKILL:
2408 if (main_pid_good(s) <= 0)
2409 service_enter_stop_post(s, f);
2410
2411 /* If there is still a service
2412 * process around, wait until
2413 * that one quit, too */
2414 break;
2415
2416 case SERVICE_STOP_POST:
2417 case SERVICE_FINAL_SIGTERM:
2418 case SERVICE_FINAL_SIGKILL:
2419 if (main_pid_good(s) <= 0)
2420 service_enter_dead(s, f, true);
2421 break;
2422
2423 default:
2424 assert_not_reached("Uh, control process died at wrong time.");
2425 }
2426 }
2427 }
2428
2429 /* Notify clients about changed exit status */
2430 unit_add_to_dbus_queue(u);
2431
2432 /* We got one SIGCHLD for the service, let's watch all
2433 * processes that are now running of the service, and watch
2434 * that. Among the PIDs we then watch will be children
2435 * reassigned to us, which hopefully allows us to identify
2436 * when all children are gone */
2437 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2438 unit_watch_all_pids(u);
2439
2440 /* If the PID set is empty now, then let's finish this off */
2441 if (set_isempty(u->pids))
2442 service_notify_cgroup_empty_event(u);
2443 }
2444
2445 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2446 Service *s = SERVICE(userdata);
2447
2448 assert(s);
2449 assert(source == s->timer_event_source);
2450
2451 switch (s->state) {
2452
2453 case SERVICE_START_PRE:
2454 case SERVICE_START:
2455 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2456 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2457 break;
2458
2459 case SERVICE_START_POST:
2460 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2461 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2462 break;
2463
2464 case SERVICE_RELOAD:
2465 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2466 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2467 service_enter_running(s, SERVICE_SUCCESS);
2468 break;
2469
2470 case SERVICE_STOP:
2471 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2472 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2473 break;
2474
2475 case SERVICE_STOP_SIGABRT:
2476 log_unit_warning(UNIT(s)->id,
2477 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2478 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2479 break;
2480
2481 case SERVICE_STOP_SIGTERM:
2482 if (s->kill_context.send_sigkill) {
2483 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2484 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2485 } else {
2486 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2487 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2488 }
2489
2490 break;
2491
2492 case SERVICE_STOP_SIGKILL:
2493 /* Uh, we sent a SIGKILL and it is still not gone?
2494 * Must be something we cannot kill, so let's just be
2495 * weirded out and continue */
2496
2497 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2498 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2499 break;
2500
2501 case SERVICE_STOP_POST:
2502 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2503 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2504 break;
2505
2506 case SERVICE_FINAL_SIGTERM:
2507 if (s->kill_context.send_sigkill) {
2508 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2509 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2510 } else {
2511 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2512 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2513 }
2514
2515 break;
2516
2517 case SERVICE_FINAL_SIGKILL:
2518 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2519 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2520 break;
2521
2522 case SERVICE_AUTO_RESTART:
2523 log_unit_info(UNIT(s)->id,
2524 s->restart_usec > 0 ?
2525 "%s holdoff time over, scheduling restart." :
2526 "%s has no holdoff time, scheduling restart.",
2527 UNIT(s)->id);
2528 service_enter_restart(s);
2529 break;
2530
2531 default:
2532 assert_not_reached("Timeout at wrong time.");
2533 }
2534
2535 return 0;
2536 }
2537
2538 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2539 Service *s = SERVICE(userdata);
2540 char t[FORMAT_TIMESPAN_MAX];
2541
2542 assert(s);
2543 assert(source == s->watchdog_event_source);
2544
2545 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2546 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2547
2548 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2549
2550 return 0;
2551 }
2552
2553 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2554 Service *s = SERVICE(u);
2555 _cleanup_free_ char *cc = NULL;
2556 bool notify_dbus = false;
2557 const char *e;
2558
2559 assert(u);
2560
2561 cc = strv_join(tags, ", ");
2562 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2563 u->id, pid, isempty(cc) ? "n/a" : cc);
2564
2565 if (s->notify_access == NOTIFY_NONE) {
2566 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2567 return;
2568 }
2569
2570 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2571 if (s->main_pid != 0)
2572 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
2573 else
2574 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
2575 return;
2576 }
2577
2578 /* Interpret MAINPID= */
2579 e = strv_find_startswith(tags, "MAINPID=");
2580 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2581 if (parse_pid(e, &pid) < 0)
2582 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2583 else {
2584 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
2585
2586 service_set_main_pid(s, pid);
2587 unit_watch_pid(UNIT(s), pid);
2588 notify_dbus = true;
2589 }
2590 }
2591
2592 /* Interpret RELOADING= */
2593 if (strv_find(tags, "RELOADING=1")) {
2594
2595 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
2596 s->notify_state = NOTIFY_RELOADING;
2597
2598 if (s->state == SERVICE_RUNNING)
2599 service_enter_reload_by_notify(s);
2600
2601 notify_dbus = true;
2602 }
2603
2604 /* Interpret READY= */
2605 if (strv_find(tags, "READY=1")) {
2606
2607 log_unit_debug(u->id, "%s: got READY=1", u->id);
2608 s->notify_state = NOTIFY_READY;
2609
2610 /* Type=notify services inform us about completed
2611 * initialization with READY=1 */
2612 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2613 service_enter_start_post(s);
2614
2615 /* Sending READY=1 while we are reloading informs us
2616 * that the reloading is complete */
2617 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2618 service_enter_running(s, SERVICE_SUCCESS);
2619
2620 notify_dbus = true;
2621 }
2622
2623 /* Interpret STOPPING= */
2624 if (strv_find(tags, "STOPPING=1")) {
2625
2626 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
2627 s->notify_state = NOTIFY_STOPPING;
2628
2629 if (s->state == SERVICE_RUNNING)
2630 service_enter_stop_by_notify(s);
2631
2632 notify_dbus = true;
2633 }
2634
2635 /* Interpret STATUS= */
2636 e = strv_find_startswith(tags, "STATUS=");
2637 if (e) {
2638 _cleanup_free_ char *t = NULL;
2639
2640 if (!isempty(e)) {
2641 if (!utf8_is_valid(e))
2642 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
2643 else {
2644 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
2645
2646 t = strdup(e);
2647 if (!t)
2648 log_oom();
2649 }
2650 }
2651
2652 if (!streq_ptr(s->status_text, t)) {
2653
2654 free(s->status_text);
2655 s->status_text = t;
2656 t = NULL;
2657
2658 notify_dbus = true;
2659 }
2660 }
2661
2662 /* Interpret ERRNO= */
2663 e = strv_find_startswith(tags, "ERRNO=");
2664 if (e) {
2665 int status_errno;
2666
2667 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2668 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2669 else {
2670 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
2671
2672 if (s->status_errno != status_errno) {
2673 s->status_errno = status_errno;
2674 notify_dbus = true;
2675 }
2676 }
2677 }
2678
2679 /* Interpret WATCHDOG= */
2680 if (strv_find(tags, "WATCHDOG=1")) {
2681 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
2682 service_reset_watchdog(s);
2683 }
2684
2685 /* Notify clients about changed status or main pid */
2686 if (notify_dbus)
2687 unit_add_to_dbus_queue(u);
2688 }
2689
2690 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2691 Service *s = SERVICE(u);
2692 int r;
2693
2694 if (!s->timer_event_source)
2695 return 0;
2696
2697 r = sd_event_source_get_time(s->timer_event_source, timeout);
2698 if (r < 0)
2699 return r;
2700
2701 return 1;
2702 }
2703
2704 static void service_bus_name_owner_change(
2705 Unit *u,
2706 const char *name,
2707 const char *old_owner,
2708 const char *new_owner) {
2709
2710 Service *s = SERVICE(u);
2711 int r;
2712
2713 assert(s);
2714 assert(name);
2715
2716 assert(streq(s->bus_name, name));
2717 assert(old_owner || new_owner);
2718
2719 if (old_owner && new_owner)
2720 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2721 else if (old_owner)
2722 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2723 else
2724 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2725
2726 s->bus_name_good = !!new_owner;
2727
2728 if (s->type == SERVICE_DBUS) {
2729
2730 /* service_enter_running() will figure out what to
2731 * do */
2732 if (s->state == SERVICE_RUNNING)
2733 service_enter_running(s, SERVICE_SUCCESS);
2734 else if (s->state == SERVICE_START && new_owner)
2735 service_enter_start_post(s);
2736
2737 } else if (new_owner &&
2738 s->main_pid <= 0 &&
2739 (s->state == SERVICE_START ||
2740 s->state == SERVICE_START_POST ||
2741 s->state == SERVICE_RUNNING ||
2742 s->state == SERVICE_RELOAD)) {
2743
2744 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2745 pid_t pid;
2746
2747 /* Try to acquire PID from bus service */
2748
2749 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2750 if (r >= 0)
2751 r = sd_bus_creds_get_pid(creds, &pid);
2752 if (r >= 0) {
2753 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2754
2755 service_set_main_pid(s, pid);
2756 unit_watch_pid(UNIT(s), pid);
2757 }
2758 }
2759 }
2760
2761 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
2762 _cleanup_free_ char *peer = NULL;
2763 int r;
2764
2765 assert(s);
2766 assert(fd >= 0);
2767
2768 /* This is called by the socket code when instantiating a new
2769 * service for a stream socket and the socket needs to be
2770 * configured. */
2771
2772 if (UNIT(s)->load_state != UNIT_LOADED)
2773 return -EINVAL;
2774
2775 if (s->socket_fd >= 0)
2776 return -EBUSY;
2777
2778 if (s->state != SERVICE_DEAD)
2779 return -EAGAIN;
2780
2781 if (getpeername_pretty(fd, &peer) >= 0) {
2782
2783 if (UNIT(s)->description) {
2784 _cleanup_free_ char *a;
2785
2786 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2787 if (!a)
2788 return -ENOMEM;
2789
2790 r = unit_set_description(UNIT(s), a);
2791 } else
2792 r = unit_set_description(UNIT(s), peer);
2793
2794 if (r < 0)
2795 return r;
2796 }
2797
2798 s->socket_fd = fd;
2799 s->socket_fd_selinux_context_net = selinux_context_net;
2800
2801 unit_ref_set(&s->accept_socket, UNIT(sock));
2802
2803 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2804 }
2805
2806 static void service_reset_failed(Unit *u) {
2807 Service *s = SERVICE(u);
2808
2809 assert(s);
2810
2811 if (s->state == SERVICE_FAILED)
2812 service_set_state(s, SERVICE_DEAD);
2813
2814 s->result = SERVICE_SUCCESS;
2815 s->reload_result = SERVICE_SUCCESS;
2816
2817 RATELIMIT_RESET(s->start_limit);
2818 }
2819
2820 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2821 Service *s = SERVICE(u);
2822
2823 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2824 }
2825
2826 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2827 [SERVICE_DEAD] = "dead",
2828 [SERVICE_START_PRE] = "start-pre",
2829 [SERVICE_START] = "start",
2830 [SERVICE_START_POST] = "start-post",
2831 [SERVICE_RUNNING] = "running",
2832 [SERVICE_EXITED] = "exited",
2833 [SERVICE_RELOAD] = "reload",
2834 [SERVICE_STOP] = "stop",
2835 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
2836 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2837 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2838 [SERVICE_STOP_POST] = "stop-post",
2839 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2840 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2841 [SERVICE_FAILED] = "failed",
2842 [SERVICE_AUTO_RESTART] = "auto-restart",
2843 };
2844
2845 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2846
2847 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2848 [SERVICE_RESTART_NO] = "no",
2849 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2850 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2851 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2852 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2853 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2854 [SERVICE_RESTART_ALWAYS] = "always",
2855 };
2856
2857 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2858
2859 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2860 [SERVICE_SIMPLE] = "simple",
2861 [SERVICE_FORKING] = "forking",
2862 [SERVICE_ONESHOT] = "oneshot",
2863 [SERVICE_DBUS] = "dbus",
2864 [SERVICE_NOTIFY] = "notify",
2865 [SERVICE_IDLE] = "idle"
2866 };
2867
2868 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2869
2870 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2871 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2872 [SERVICE_EXEC_START] = "ExecStart",
2873 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2874 [SERVICE_EXEC_RELOAD] = "ExecReload",
2875 [SERVICE_EXEC_STOP] = "ExecStop",
2876 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2877 };
2878
2879 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2880
2881 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2882 [NOTIFY_NONE] = "none",
2883 [NOTIFY_MAIN] = "main",
2884 [NOTIFY_ALL] = "all"
2885 };
2886
2887 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2888
2889 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
2890 [NOTIFY_UNKNOWN] = "unknown",
2891 [NOTIFY_READY] = "ready",
2892 [NOTIFY_RELOADING] = "reloading",
2893 [NOTIFY_STOPPING] = "stopping",
2894 };
2895
2896 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
2897
2898 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2899 [SERVICE_SUCCESS] = "success",
2900 [SERVICE_FAILURE_RESOURCES] = "resources",
2901 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2902 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2903 [SERVICE_FAILURE_SIGNAL] = "signal",
2904 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2905 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2906 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2907 };
2908
2909 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2910
2911 const UnitVTable service_vtable = {
2912 .object_size = sizeof(Service),
2913 .exec_context_offset = offsetof(Service, exec_context),
2914 .cgroup_context_offset = offsetof(Service, cgroup_context),
2915 .kill_context_offset = offsetof(Service, kill_context),
2916 .exec_runtime_offset = offsetof(Service, exec_runtime),
2917
2918 .sections =
2919 "Unit\0"
2920 "Service\0"
2921 "Install\0",
2922 .private_section = "Service",
2923
2924 .init = service_init,
2925 .done = service_done,
2926 .load = service_load,
2927
2928 .coldplug = service_coldplug,
2929
2930 .dump = service_dump,
2931
2932 .start = service_start,
2933 .stop = service_stop,
2934 .reload = service_reload,
2935
2936 .can_reload = service_can_reload,
2937
2938 .kill = service_kill,
2939
2940 .serialize = service_serialize,
2941 .deserialize_item = service_deserialize_item,
2942
2943 .active_state = service_active_state,
2944 .sub_state_to_string = service_sub_state_to_string,
2945
2946 .check_gc = service_check_gc,
2947 .check_snapshot = service_check_snapshot,
2948
2949 .sigchld_event = service_sigchld_event,
2950
2951 .reset_failed = service_reset_failed,
2952
2953 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2954 .notify_message = service_notify_message,
2955
2956 .bus_name_owner_change = service_bus_name_owner_change,
2957
2958 .bus_interface = "org.freedesktop.systemd1.Service",
2959 .bus_vtable = bus_service_vtable,
2960 .bus_set_property = bus_service_set_property,
2961 .bus_commit_properties = bus_service_commit_properties,
2962
2963 .get_timeout = service_get_timeout,
2964 .can_transient = true,
2965
2966 .status_message_formats = {
2967 .starting_stopping = {
2968 [0] = "Starting %s...",
2969 [1] = "Stopping %s...",
2970 },
2971 .finished_start_job = {
2972 [JOB_DONE] = "Started %s.",
2973 [JOB_FAILED] = "Failed to start %s.",
2974 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2975 [JOB_TIMEOUT] = "Timed out starting %s.",
2976 },
2977 .finished_stop_job = {
2978 [JOB_DONE] = "Stopped %s.",
2979 [JOB_FAILED] = "Stopped (with error) %s.",
2980 [JOB_TIMEOUT] = "Timed out stopping %s.",
2981 },
2982 },
2983 };
Unnamed repository; edit this file 'description' to name the repository.