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