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