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