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