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