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