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