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