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