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