]> 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
journald: Log error when failed to get machine-id on start
[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
LP		 24#include <dirent.h>
25#include <unistd.h>
4b939747 26#include <sys/reboot.h>
5cb5a6ff 27
4b939747 28#include "manager.h"
87f0e418 29#include "unit.h"
5cb5a6ff
LP		 30#include "service.h"
31#include "load-fragment.h"
32#include "load-dropin.h"
034c6ed7 33#include "log.h"
2c4104f0 34#include "strv.h"
9e2f7c11 35#include "unit-name.h"
41f9172f 36#include "unit-printf.h"
4139c1b2 37#include "dbus-service.h"
514f4ef5 38#include "special.h"
449101fc 39#include "dbus-common.h"
9a57c629 40#include "exit-status.h"
f6a6225e 41#include "def.h"
9eb977db 42#include "path-util.h"
f6a6225e 43#include "util.h"
7f110ff9 44#include "utf8.h"
4d1a6904 45#include "env-util.h"
a5c32cff 46#include "fileio.h"
034c6ed7 47
07459bb6 48#ifdef HAVE_SYSV_COMPAT
f34277d9 49
f6a6225e 50#define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
f34277d9 51
09cd1ab1
LP		 52typedef enum RunlevelType {
53 RUNLEVEL_UP,
3cdebc21 54 RUNLEVEL_DOWN
09cd1ab1
LP		 55} RunlevelType;
56
57static const struct {
58 const char *path;
59 const char *target;
60 const RunlevelType type;
61} rcnd_table[] = {
9d25f5ed 62 /* Standard SysV runlevels for start-up */
514f4ef5 63 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
fbe9f3a9
LP		 64 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
65 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
66 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
67 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
fbe9f3a9 68
9d25f5ed
LP		 69 /* Standard SysV runlevels for shutdown */
70 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
71 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
72
73 /* Note that the order here matters, as we read the
74 directories in this order, and we want to make sure that
75 sysv_start_priority is known when we first load the
76 unit. And that value we only know from S links. Hence
3cdebc21 77 UP must be read before DOWN */
23a177ef
LP		 78};
79
09cd1ab1 80#define RUNLEVELS_UP "12345"
07459bb6 81#endif
09cd1ab1 82
acbb0225 83static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
87f0e418
LP		 84 [SERVICE_DEAD] = UNIT_INACTIVE,
85 [SERVICE_START_PRE] = UNIT_ACTIVATING,
86 [SERVICE_START] = UNIT_ACTIVATING,
87 [SERVICE_START_POST] = UNIT_ACTIVATING,
88 [SERVICE_RUNNING] = UNIT_ACTIVE,
80876c20 89 [SERVICE_EXITED] = UNIT_ACTIVE,
032ff4af 90 [SERVICE_RELOAD] = UNIT_RELOADING,
87f0e418
LP		 91 [SERVICE_STOP] = UNIT_DEACTIVATING,
92 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
93 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
94 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
95 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
96 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
fdf20a31 97 [SERVICE_FAILED] = UNIT_FAILED,
6124958c 98 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
034c6ed7 99};
5cb5a6ff 100
e056b01d
LP		 101/* For Type=idle we never want to delay any other jobs, hence we
102 * consider idle jobs active as soon as we start working on them */
103static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
104 [SERVICE_DEAD] = UNIT_INACTIVE,
105 [SERVICE_START_PRE] = UNIT_ACTIVE,
106 [SERVICE_START] = UNIT_ACTIVE,
107 [SERVICE_START_POST] = UNIT_ACTIVE,
108 [SERVICE_RUNNING] = UNIT_ACTIVE,
109 [SERVICE_EXITED] = UNIT_ACTIVE,
110 [SERVICE_RELOAD] = UNIT_RELOADING,
111 [SERVICE_STOP] = UNIT_DEACTIVATING,
112 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
113 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
114 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
115 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
116 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
117 [SERVICE_FAILED] = UNIT_FAILED,
118 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
119};
120
a16e1123
LP		 121static void service_init(Unit *u) {
122 Service *s = SERVICE(u);
123
124 assert(u);
ac155bb8 125 assert(u->load_state == UNIT_STUB);
a16e1123 126
d568a335
MS		 127 s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
128 s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
a16e1123 129 s->restart_usec = DEFAULT_RESTART_USEC;
0b86feac 130 s->type = _SERVICE_TYPE_INVALID;
bb242b7b 131
68b29a9f
LP		 132 watch_init(&s->watchdog_watch);
133 watch_init(&s->timer_watch);
bb242b7b 134
07459bb6 135#ifdef HAVE_SYSV_COMPAT
a16e1123 136 s->sysv_start_priority = -1;
ea87ca5a 137 s->sysv_start_priority_from_rcnd = -1;
07459bb6 138#endif
a16e1123 139 s->socket_fd = -1;
3185a36b 140 s->guess_main_pid = true;
a16e1123
LP		 141
142 exec_context_init(&s->exec_context);
4819ff03 143 kill_context_init(&s->kill_context);
4ad49000 144 cgroup_context_init(&s->cgroup_context);
a16e1123 145
4b939747 146 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
a16e1123
LP		 147
148 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
149}
150
5e94833f
LP		 151static void service_unwatch_control_pid(Service *s) {
152 assert(s);
153
154 if (s->control_pid <= 0)
155 return;
156
157 unit_unwatch_pid(UNIT(s), s->control_pid);
158 s->control_pid = 0;
159}
160
161static void service_unwatch_main_pid(Service *s) {
162 assert(s);
163
164 if (s->main_pid <= 0)
165 return;
166
167 unit_unwatch_pid(UNIT(s), s->main_pid);
168 s->main_pid = 0;
169}
170
3e52541e
MS		 171static void service_unwatch_pid_file(Service *s) {
172 if (!s->pid_file_pathspec)
173 return;
174
66870f90
ZJS		 175 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
176 UNIT(s)->id, s->pid_file_pathspec->path);
3e52541e
MS		 177 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
178 path_spec_done(s->pid_file_pathspec);
179 free(s->pid_file_pathspec);
180 s->pid_file_pathspec = NULL;
181}
182
5925dd3c 183static int service_set_main_pid(Service *s, pid_t pid) {
e55224ca
LP		 184 pid_t ppid;
185
5925dd3c
LP		 186 assert(s);
187
188 if (pid <= 1)
189 return -EINVAL;
190
191 if (pid == getpid())
192 return -EINVAL;
193
41efeaec
LP		 194 service_unwatch_main_pid(s);
195
6dfa5494
LP		 196 s->main_pid = pid;
197 s->main_pid_known = true;
198
199 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
66870f90
ZJS		 200 log_warning_unit(UNIT(s)->id,
201 "%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
202 UNIT(s)->id, (unsigned long) pid);
e55224ca 203
6dfa5494
LP		 204 s->main_pid_alien = true;
205 } else
206 s->main_pid_alien = false;
5925dd3c 207
b58b4116
LP		 208 exec_status_start(&s->main_exec_status, pid);
209
5925dd3c
LP		 210 return 0;
211}
212
4f2d528d
LP		 213static void service_close_socket_fd(Service *s) {
214 assert(s);
215
216 if (s->socket_fd < 0)
217 return;
218
219 close_nointr_nofail(s->socket_fd);
220 s->socket_fd = -1;
221}
222
6cf6bbc2
LP		 223static void service_connection_unref(Service *s) {
224 assert(s);
225
9444b1f2 226 if (!UNIT_ISSET(s->accept_socket))
6cf6bbc2
LP		 227 return;
228
57020a3a
LP		 229 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
230 unit_ref_unset(&s->accept_socket);
6cf6bbc2
LP		 231}
232
a6927d7f
MO		 233static void service_stop_watchdog(Service *s) {
234 assert(s);
235
bb242b7b 236 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
a6927d7f
MO		 237 s->watchdog_timestamp.realtime = 0;
238 s->watchdog_timestamp.monotonic = 0;
239}
240
9e9c3abc 241static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
bb242b7b
MO		 242
243static void service_handle_watchdog(Service *s) {
244 usec_t offset;
245 int r;
246
247 assert(s);
248
249 if (s->watchdog_usec == 0)
250 return;
251
252 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
253 if (offset >= s->watchdog_usec) {
66870f90 254 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
af471339 255 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_WATCHDOG);
bb242b7b
MO		 256 return;
257 }
258
36697dc0 259 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->watchdog_usec - offset, &s->watchdog_watch);
bb242b7b 260 if (r < 0)
66870f90
ZJS		 261 log_warning_unit(UNIT(s)->id,
262 "%s failed to install watchdog timer: %s",
263 UNIT(s)->id, strerror(-r));
bb242b7b
MO		 264}
265
a6927d7f
MO		 266static void service_reset_watchdog(Service *s) {
267 assert(s);
268
269 dual_timestamp_get(&s->watchdog_timestamp);
bb242b7b 270 service_handle_watchdog(s);
a6927d7f
MO		 271}
272
87f0e418
LP		 273static void service_done(Unit *u) {
274 Service *s = SERVICE(u);
44d8db9e
LP		 275
276 assert(s);
277
278 free(s->pid_file);
279 s->pid_file = NULL;
280
07459bb6 281#ifdef HAVE_SYSV_COMPAT
8309400a
LP		 282 free(s->sysv_runlevels);
283 s->sysv_runlevels = NULL;
07459bb6 284#endif
8309400a 285
8c47c732
LP		 286 free(s->status_text);
287 s->status_text = NULL;
288
4ad49000 289 cgroup_context_done(&s->cgroup_context);
c17ec25e 290 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
e537352b 291 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
44d8db9e 292 s->control_command = NULL;
867b3b7d 293 s->main_command = NULL;
44d8db9e 294
96342de6
LN		 295 set_free(s->restart_ignore_status.code);
296 s->restart_ignore_status.code = NULL;
297 set_free(s->restart_ignore_status.signal);
298 s->restart_ignore_status.signal = NULL;
299
300 set_free(s->success_status.code);
301 s->success_status.code = NULL;
302 set_free(s->success_status.signal);
303 s->success_status.signal = NULL;
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
4f2d528d 317 service_close_socket_fd(s);
6cf6bbc2 318 service_connection_unref(s);
4f2d528d 319
57020a3a 320 unit_ref_unset(&s->accept_socket);
f976f3f6 321
bb242b7b
MO		 322 service_stop_watchdog(s);
323
acbb0225 324 unit_unwatch_timer(u, &s->timer_watch);
44d8db9e
LP		 325}
326
07459bb6 327#ifdef HAVE_SYSV_COMPAT
b7ccee3c
LP		 328static char *sysv_translate_name(const char *name) {
329 char *r;
330
5d4caf56
LP		 331 r = new(char, strlen(name) + sizeof(".service"));
332 if (!r)
b7ccee3c
LP		 333 return NULL;
334
5b819198 335 if (endswith(name, ".sh"))
85a3fa0e 336 /* Drop .sh suffix */
5b819198 337 strcpy(stpcpy(r, name) - 3, ".service");
b7ccee3c 338 else
85a3fa0e 339 /* Normal init script name */
b7ccee3c
LP		 340 strcpy(stpcpy(r, name), ".service");
341
342 return r;
343}
344
ee95669f 345static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
2c4104f0 346
a7d3cc26
LP		 347 /* We silently ignore the $ prefix here. According to the LSB
348 * spec it simply indicates whether something is a
349 * standardized name or a distribution-specific one. Since we
350 * just follow what already exists and do not introduce new
351 * uses or names we don't care who introduced a new name. */
352
2c4104f0 353 static const char * const table[] = {
6464aa08 354 /* LSB defined facilities */
5d4caf56 355 "local_fs", NULL,
a7d3cc26
LP		 356 "network", SPECIAL_NETWORK_TARGET,
357 "named", SPECIAL_NSS_LOOKUP_TARGET,
358 "portmap", SPECIAL_RPCBIND_TARGET,
359 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
5d4caf56 360 "syslog", NULL,
4466194c 361 "time", SPECIAL_TIME_SYNC_TARGET,
2c4104f0
LP		 362 };
363
364 unsigned i;
365 char *r;
ee95669f 366 const char *n;
2c4104f0 367
ee95669f
LP		 368 assert(name);
369 assert(_r);
a7d3cc26 370
ee95669f 371 n = *name == '$' ? name + 1 : name;
a7d3cc26 372
ee95669f 373 for (i = 0; i < ELEMENTSOF(table); i += 2) {
a7d3cc26 374
ee95669f
LP		 375 if (!streq(table[i], n))
376 continue;
2c4104f0 377
ee95669f
LP		 378 if (!table[i+1])
379 return 0;
380
5d4caf56
LP		 381 r = strdup(table[i+1]);
382 if (!r)
383 return log_oom();
ee95669f
LP		 384
385 goto finish;
386 }
2c4104f0 387
a7d3cc26 388 /* If we don't know this name, fallback heuristics to figure
0003d1ab 389 * out whether something is a target or a service alias. */
a7d3cc26 390
e83c7c0b
LP		 391 if (*name == '$') {
392 if (!unit_prefix_is_valid(n))
393 return -EINVAL;
394
ee95669f
LP		 395 /* Facilities starting with $ are most likely targets */
396 r = unit_name_build(n, NULL, ".target");
e83c7c0b 397 } else if (filename && streq(name, filename))
35b8ca3a 398 /* Names equaling the file name of the services are redundant */
ee95669f 399 return 0;
32159d3a 400 else
ee95669f
LP		 401 /* Everything else we assume to be normal service names */
402 r = sysv_translate_name(n);
2c4104f0 403
32159d3a 404 if (!r)
2c4104f0
LP		 405 return -ENOMEM;
406
407finish:
b4353094 408 *_r = r;
2c4104f0
LP		 409
410 return 1;
411}
412
56d748b4 413static int sysv_fix_order(Service *s) {
ac155bb8 414 Unit *other;
2c4104f0
LP		 415 int r;
416
417 assert(s);
418
419 if (s->sysv_start_priority < 0)
420 return 0;
421
23a177ef
LP		 422 /* For each pair of services where at least one lacks a LSB
423 * header, we use the start priority value to order things. */
2c4104f0 424
1124fe6f 425 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
2c4104f0
LP		 426 Service *t;
427 UnitDependency d;
eeaafddc 428 bool special_s, special_t;
2c4104f0 429
595ed347 430 t = SERVICE(other);
2c4104f0
LP		 431
432 if (s == t)
433 continue;
9f151f29 434
1124fe6f 435 if (UNIT(t)->load_state != UNIT_LOADED)
9f151f29 436 continue;
2c4104f0
LP		 437
438 if (t->sysv_start_priority < 0)
439 continue;
440
51a1a79d
LP		 441 /* If both units have modern headers we don't care
442 * about the priorities */
1124fe6f
MS		 443 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
444 (UNIT(t)->fragment_path || t->sysv_has_lsb))
23a177ef
LP		 445 continue;
446
eeaafddc
LP		 447 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
448 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
449
450 if (special_t && !special_s)
451 d = UNIT_AFTER;
452 else if (special_s && !special_t)
453 d = UNIT_BEFORE;
454 else if (t->sysv_start_priority < s->sysv_start_priority)
2c4104f0
LP		 455 d = UNIT_AFTER;
456 else if (t->sysv_start_priority > s->sysv_start_priority)
457 d = UNIT_BEFORE;
458 else
459 continue;
460
461 /* FIXME: Maybe we should compare the name here lexicographically? */
462
da19d5c1 463 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
2c4104f0
LP		 464 return r;
465 }
466
467 return 0;
468}
469
470static ExecCommand *exec_command_new(const char *path, const char *arg1) {
471 ExecCommand *c;
472
473 if (!(c = new0(ExecCommand, 1)))
474 return NULL;
475
476 if (!(c->path = strdup(path))) {
477 free(c);
478 return NULL;
479 }
480
481 if (!(c->argv = strv_new(path, arg1, NULL))) {
482 free(c->path);
483 free(c);
484 return NULL;
485 }
486
487 return c;
488}
489
37e2941d 490static int sysv_exec_commands(Service *s, const bool supports_reload) {
2c4104f0
LP		 491 ExecCommand *c;
492
493 assert(s);
1b64d026
LP		 494 assert(s->is_sysv);
495 assert(UNIT(s)->source_path);
2c4104f0 496
1b64d026
LP		 497 c = exec_command_new(UNIT(s)->source_path, "start");
498 if (!c)
2c4104f0
LP		 499 return -ENOMEM;
500 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
501
1b64d026
LP		 502 c = exec_command_new(UNIT(s)->source_path, "stop");
503 if (!c)
2c4104f0
LP		 504 return -ENOMEM;
505 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
506
37e2941d
MS		 507 if (supports_reload) {
508 c = exec_command_new(UNIT(s)->source_path, "reload");
509 if (!c)
510 return -ENOMEM;
511 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
512 }
2c4104f0
LP		 513
514 return 0;
515}
516
37e2941d
MS		 517static bool usage_contains_reload(const char *line) {
518 return (strcasestr(line, "{reload|") ||
519 strcasestr(line, "{reload}") ||
520 strcasestr(line, "{reload\"") ||
521 strcasestr(line, "|reload|") ||
522 strcasestr(line, "|reload}") ||
523 strcasestr(line, "|reload\""));
524}
525
e537352b 526static int service_load_sysv_path(Service *s, const char *path) {
2c4104f0
LP		 527 FILE *f;
528 Unit *u;
529 unsigned line = 0;
530 int r;
531 enum {
532 NORMAL,
533 DESCRIPTION,
534 LSB,
37e2941d
MS		 535 LSB_DESCRIPTION,
536 USAGE_CONTINUATION
2c4104f0 537 } state = NORMAL;
0b5d26f9 538 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
5f4b19f4 539 struct stat st;
37e2941d 540 bool supports_reload = false;
23a177ef
LP		 541
542 assert(s);
543 assert(path);
2c4104f0
LP		 544
545 u = UNIT(s);
546
1b64d026
LP		 547 f = fopen(path, "re");
548 if (!f) {
2c4104f0
LP		 549 r = errno == ENOENT ? 0 : -errno;
550 goto finish;
551 }
552
5f4b19f4
LP		 553 if (fstat(fileno(f), &st) < 0) {
554 r = -errno;
555 goto finish;
556 }
557
1b64d026
LP		 558 free(u->source_path);
559 u->source_path = strdup(path);
560 if (!u->source_path) {
2c4104f0
LP		 561 r = -ENOMEM;
562 goto finish;
563 }
1b64d026 564 u->source_mtime = timespec_load(&st.st_mtim);
5f4b19f4
LP		 565
566 if (null_or_empty(&st)) {
ac155bb8 567 u->load_state = UNIT_MASKED;
5f4b19f4
LP		 568 r = 0;
569 goto finish;
570 }
571
1b64d026
LP		 572 s->is_sysv = true;
573
2c4104f0
LP		 574 while (!feof(f)) {
575 char l[LINE_MAX], *t;
576
577 if (!fgets(l, sizeof(l), f)) {
578 if (feof(f))
579 break;
580
581 r = -errno;
66870f90
ZJS		 582 log_error_unit(u->id,
583 "Failed to read configuration file '%s': %s",
584 path, strerror(-r));
2c4104f0
LP		 585 goto finish;
586 }
587
588 line++;
589
590 t = strstrip(l);
37e2941d
MS		 591 if (*t != '#') {
592 /* Try to figure out whether this init script supports
593 * the reload operation. This heuristic looks for
594 * "Usage" lines which include the reload option. */
595 if ( state == USAGE_CONTINUATION ||
596 (state == NORMAL && strcasestr(t, "usage"))) {
597 if (usage_contains_reload(t)) {
598 supports_reload = true;
599 state = NORMAL;
600 } else if (t[strlen(t)-1] == '\\')
601 state = USAGE_CONTINUATION;
602 else
603 state = NORMAL;
604 }
605
2c4104f0 606 continue;
37e2941d 607 }
2c4104f0
LP		 608
609 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
610 state = LSB;
23a177ef 611 s->sysv_has_lsb = true;
2c4104f0
LP		 612 continue;
613 }
614
615 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
616 state = NORMAL;
617 continue;
618 }
619
620 t++;
621 t += strspn(t, WHITESPACE);
622
623 if (state == NORMAL) {
624
625 /* Try to parse Red Hat style chkconfig headers */
626
c2b35af6 627 if (startswith_no_case(t, "chkconfig:")) {
2c4104f0 628 int start_priority;
8309400a 629 char runlevels[16], *k;
2c4104f0
LP		 630
631 state = NORMAL;
632
8309400a
LP		 633 if (sscanf(t+10, "%15s %i %*i",
634 runlevels,
635 &start_priority) != 2) {
2c4104f0 636
66870f90
ZJS		 637 log_warning_unit(u->id,
638 "[%s:%u] Failed to parse chkconfig line. Ignoring.",
639 path, line);
2c4104f0
LP		 640 continue;
641 }
642
fbe9f3a9
LP		 643 /* A start priority gathered from the
644 * symlink farms is preferred over the
645 * data from the LSB header. */
8309400a 646 if (start_priority < 0 || start_priority > 99)
66870f90
ZJS		 647 log_warning_unit(u->id,
648 "[%s:%u] Start priority out of range. Ignoring.",
649 path, line);
ea87ca5a 650 else
8309400a
LP		 651 s->sysv_start_priority = start_priority;
652
653 char_array_0(runlevels);
654 k = delete_chars(runlevels, WHITESPACE "-");
655
656 if (k[0]) {
657 char *d;
658
659 if (!(d = strdup(k))) {
660 r = -ENOMEM;
661 goto finish;
662 }
663
664 free(s->sysv_runlevels);
665 s->sysv_runlevels = d;
2c4104f0
LP		 666 }
667
0b5d26f9 668 } else if (startswith_no_case(t, "description:")) {
2c4104f0
LP		 669
670 size_t k = strlen(t);
671 char *d;
0b5d26f9 672 const char *j;
2c4104f0
LP		 673
674 if (t[k-1] == '\\') {
675 state = DESCRIPTION;
676 t[k-1] = 0;
677 }
678
0b5d26f9
LP		 679 if ((j = strstrip(t+12)) && *j) {
680 if (!(d = strdup(j))) {
681 r = -ENOMEM;
682 goto finish;
683 }
684 } else
685 d = NULL;
2c4104f0 686
0b5d26f9
LP		 687 free(chkconfig_description);
688 chkconfig_description = d;
2c4104f0 689
c2b35af6 690 } else if (startswith_no_case(t, "pidfile:")) {
2c4104f0
LP		 691
692 char *fn;
693
694 state = NORMAL;
695
696 fn = strstrip(t+8);
697 if (!path_is_absolute(fn)) {
66870f90
ZJS		 698 log_warning_unit(u->id,
699 "[%s:%u] PID file not absolute. Ignoring.",
700 path, line);
2c4104f0
LP		 701 continue;
702 }
703
704 if (!(fn = strdup(fn))) {
705 r = -ENOMEM;
706 goto finish;
707 }
708
709 free(s->pid_file);
710 s->pid_file = fn;
711 }
712
713 } else if (state == DESCRIPTION) {
714
715 /* Try to parse Red Hat style description
716 * continuation */
717
718 size_t k = strlen(t);
0b5d26f9 719 char *j;
2c4104f0
LP		 720
721 if (t[k-1] == '\\')
722 t[k-1] = 0;
723 else
724 state = NORMAL;
725
0b5d26f9
LP		 726 if ((j = strstrip(t)) && *j) {
727 char *d = NULL;
728
729 if (chkconfig_description)
b7def684 730 d = strjoin(chkconfig_description, " ", j, NULL);
0b5d26f9
LP		 731 else
732 d = strdup(j);
2c4104f0 733
0b5d26f9
LP		 734 if (!d) {
735 r = -ENOMEM;
736 goto finish;
737 }
738
739 free(chkconfig_description);
740 chkconfig_description = d;
741 }
2c4104f0
LP		 742
743 } else if (state == LSB || state == LSB_DESCRIPTION) {
744
c2b35af6 745 if (startswith_no_case(t, "Provides:")) {
2c4104f0
LP		 746 char *i, *w;
747 size_t z;
748
749 state = LSB;
750
f60f22df 751 FOREACH_WORD_QUOTED(w, z, t+9, i) {
2c4104f0
LP		 752 char *n, *m;
753
754 if (!(n = strndup(w, z))) {
755 r = -ENOMEM;
756 goto finish;
757 }
758
9eb977db 759 r = sysv_translate_facility(n, path_get_file_name(path), &m);
2c4104f0
LP		 760 free(n);
761
762 if (r < 0)
763 goto finish;
764
765 if (r == 0)
766 continue;
767
bd77d0fc 768 if (unit_name_to_type(m) == UNIT_SERVICE)
ce2c2265 769 r = unit_merge_by_name(u, m);
9700edb4
LP		 770 else
771 /* NB: SysV targets
772 * which are provided
773 * by a service are
774 * pulled in by the
775 * services, as an
776 * indication that the
777 * generic service is
778 * now available. This
779 * is strictly
780 * one-way. The
781 * targets do NOT pull
782 * in the SysV
783 * services! */
784 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
bd77d0fc 785
2c4104f0 786 if (r < 0)
66870f90
ZJS		 787 log_error_unit(u->id,
788 "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
789 path, line, m, strerror(-r));
42a097a2
LP		 790
791 free(m);
2c4104f0
LP		 792 }
793
c2b35af6
LP		 794 } else if (startswith_no_case(t, "Required-Start:") ||
795 startswith_no_case(t, "Should-Start:") ||
796 startswith_no_case(t, "X-Start-Before:") ||
797 startswith_no_case(t, "X-Start-After:")) {
2c4104f0
LP		 798 char *i, *w;
799 size_t z;
800
801 state = LSB;
802
f60f22df 803 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
2c4104f0
LP		 804 char *n, *m;
805
806 if (!(n = strndup(w, z))) {
807 r = -ENOMEM;
808 goto finish;
809 }
810
9eb977db 811 r = sysv_translate_facility(n, path_get_file_name(path), &m);
e83c7c0b 812 if (r < 0) {
66870f90
ZJS		 813 log_error_unit(u->id,
814 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
815 path, line, n, strerror(-r));
e83c7c0b
LP		 816 free(n);
817 continue;
818 }
819
820 free(n);
2c4104f0
LP		 821
822 if (r == 0)
823 continue;
824
c2b35af6 825 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
2c4104f0
LP		 826
827 if (r < 0)
66870f90
ZJS		 828 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
829 path, line, m, strerror(-r));
42a097a2
LP		 830
831 free(m);
2c4104f0 832 }
c2b35af6 833 } else if (startswith_no_case(t, "Default-Start:")) {
8309400a
LP		 834 char *k, *d;
835
836 state = LSB;
837
838 k = delete_chars(t+14, WHITESPACE "-");
839
840 if (k[0] != 0) {
841 if (!(d = strdup(k))) {
842 r = -ENOMEM;
843 goto finish;
844 }
845
846 free(s->sysv_runlevels);
847 s->sysv_runlevels = d;
848 }
2c4104f0 849
0b5d26f9
LP		 850 } else if (startswith_no_case(t, "Description:")) {
851 char *d, *j;
ed4c1cc6 852
2c4104f0
LP		 853 state = LSB_DESCRIPTION;
854
0b5d26f9
LP		 855 if ((j = strstrip(t+12)) && *j) {
856 if (!(d = strdup(j))) {
857 r = -ENOMEM;
858 goto finish;
859 }
860 } else
861 d = NULL;
2c4104f0 862
0b5d26f9
LP		 863 free(long_description);
864 long_description = d;
2c4104f0 865
ed4c1cc6 866 } else if (startswith_no_case(t, "Short-Description:")) {
0b5d26f9 867 char *d, *j;
2c4104f0 868
2c4104f0
LP		 869 state = LSB;
870
0b5d26f9
LP		 871 if ((j = strstrip(t+18)) && *j) {
872 if (!(d = strdup(j))) {
873 r = -ENOMEM;
874 goto finish;
875 }
876 } else
877 d = NULL;
2c4104f0 878
0b5d26f9
LP		 879 free(short_description);
880 short_description = d;
2c4104f0
LP		 881
882 } else if (state == LSB_DESCRIPTION) {
883
884 if (startswith(l, "#\t") || startswith(l, "# ")) {
0b5d26f9 885 char *j;
2c4104f0 886
0b5d26f9
LP		 887 if ((j = strstrip(t)) && *j) {
888 char *d = NULL;
889
890 if (long_description)
b7def684 891 d = strjoin(long_description, " ", t, NULL);
0b5d26f9
LP		 892 else
893 d = strdup(j);
894
895 if (!d) {
896 r = -ENOMEM;
897 goto finish;
898 }
899
900 free(long_description);
901 long_description = d;
2c4104f0
LP		 902 }
903
2c4104f0
LP		 904 } else
905 state = LSB;
906 }
907 }
908 }
909
37e2941d 910 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
2c4104f0
LP		 911 goto finish;
912
a40eb732 913 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
0bc824be
LP		 914 /* If there a runlevels configured for this service
915 * but none of the standard ones, then we assume this
916 * is some special kind of service (which might be
917 * needed for early boot) and don't create any links
918 * to it. */
919
1124fe6f 920 UNIT(s)->default_dependencies = false;
09cd1ab1 921
09cd1ab1 922 /* Don't timeout special services during boot (like fsck) */
d568a335
MS		 923 s->timeout_start_usec = 0;
924 s->timeout_stop_usec = 0;
925 } else {
926 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
927 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
928 }
929
80876c20 930 /* Special setting for all SysV services */
1f48cf56 931 s->type = SERVICE_FORKING;
f8788303 932 s->remain_after_exit = !s->pid_file;
1835f23c 933 s->guess_main_pid = false;
525ee6f4 934 s->restart = SERVICE_RESTART_NO;
353e12c2 935 s->exec_context.ignore_sigpipe = false;
4819ff03 936 s->kill_context.kill_mode = KILL_PROCESS;
80876c20 937
0b5d26f9
LP		 938 /* We use the long description only if
939 * no short description is set. */
940
941 if (short_description)
942 description = short_description;
943 else if (chkconfig_description)
944 description = chkconfig_description;
945 else if (long_description)
946 description = long_description;
947 else
948 description = NULL;
949
950 if (description) {
951 char *d;
952
e527618d 953 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
0b5d26f9
LP		 954 r = -ENOMEM;
955 goto finish;
956 }
957
ac155bb8 958 u->description = d;
0b5d26f9
LP		 959 }
960
ea87ca5a
LP		 961 /* The priority that has been set in /etc/rcN.d/ hierarchies
962 * takes precedence over what is stored as default in the LSB
963 * header */
964 if (s->sysv_start_priority_from_rcnd >= 0)
965 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
966
ac155bb8 967 u->load_state = UNIT_LOADED;
23a177ef 968 r = 0;
2c4104f0
LP		 969
970finish:
971
972 if (f)
973 fclose(f);
974
0b5d26f9
LP		 975 free(short_description);
976 free(long_description);
977 free(chkconfig_description);
978
2c4104f0
LP		 979 return r;
980}
981
e537352b 982static int service_load_sysv_name(Service *s, const char *name) {
2c4104f0
LP		 983 char **p;
984
985 assert(s);
986 assert(name);
987
c2756a68 988 /* For SysV services we strip the *.sh suffixes. */
3f95f83c 989 if (endswith(name, ".sh.service"))
d017c6ca
LP		 990 return -ENOENT;
991
1124fe6f 992 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
2c4104f0
LP		 993 char *path;
994 int r;
995
b7def684 996 path = strjoin(*p, "/", name, NULL);
44d91056 997 if (!path)
2c4104f0
LP		 998 return -ENOMEM;
999
1000 assert(endswith(path, ".service"));
1001 path[strlen(path)-8] = 0;
1002
e537352b 1003 r = service_load_sysv_path(s, path);
fbe9f3a9 1004
1124fe6f 1005 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
20771ae3 1006 /* Try *.sh source'able init scripts */
fbe9f3a9
LP		 1007 strcat(path, ".sh");
1008 r = service_load_sysv_path(s, path);
1009 }
2c4104f0
LP		 1010 free(path);
1011
23a177ef 1012 if (r < 0)
2c4104f0 1013 return r;
23a177ef 1014
88516c0c 1015 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef 1016 break;
2c4104f0
LP		 1017 }
1018
1019 return 0;
1020}
1021
e537352b 1022static int service_load_sysv(Service *s) {
2c4104f0
LP		 1023 const char *t;
1024 Iterator i;
1025 int r;
1026
5cb5a6ff
LP		 1027 assert(s);
1028
1029 /* Load service data from SysV init scripts, preferably with
1030 * LSB headers ... */
1031
1124fe6f 1032 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
2c4104f0
LP		 1033 return 0;
1034
1124fe6f 1035 if ((t = UNIT(s)->id))
e537352b 1036 if ((r = service_load_sysv_name(s, t)) < 0)
2c4104f0
LP		 1037 return r;
1038
1124fe6f
MS		 1039 if (UNIT(s)->load_state == UNIT_STUB)
1040 SET_FOREACH(t, UNIT(s)->names, i) {
1041 if (t == UNIT(s)->id)
e537352b
LP		 1042 continue;
1043
e364ad06 1044 if ((r = service_load_sysv_name(s, t)) < 0)
23a177ef
LP		 1045 return r;
1046
1124fe6f 1047 if (UNIT(s)->load_state != UNIT_STUB)
23a177ef
LP		 1048 break;
1049 }
2c4104f0
LP		 1050
1051 return 0;
5cb5a6ff 1052}
07459bb6 1053#endif
5cb5a6ff 1054
9fff8a1f 1055static int fsck_fix_order(Service *s) {
ac155bb8 1056 Unit *other;
9fff8a1f
LP		 1057 int r;
1058
1059 assert(s);
1060
1061 if (s->fsck_passno <= 0)
1062 return 0;
1063
1064 /* For each pair of services where both have an fsck priority
1065 * we order things based on it. */
1066
1124fe6f 1067 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
9fff8a1f
LP		 1068 Service *t;
1069 UnitDependency d;
1070
595ed347 1071 t = SERVICE(other);
9fff8a1f
LP		 1072
1073 if (s == t)
1074 continue;
1075
1124fe6f 1076 if (UNIT(t)->load_state != UNIT_LOADED)
9fff8a1f
LP		 1077 continue;
1078
1079 if (t->fsck_passno <= 0)
1080 continue;
1081
1082 if (t->fsck_passno < s->fsck_passno)
1083 d = UNIT_AFTER;
1084 else if (t->fsck_passno > s->fsck_passno)
1085 d = UNIT_BEFORE;
1086 else
1087 continue;
1088
117dcc57
ZJS		 1089 r = unit_add_dependency(UNIT(s), d, UNIT(t), true);
1090 if (r < 0)
9fff8a1f
LP		 1091 return r;
1092 }
1093
1094 return 0;
1095}
1096
243b1432
LP		 1097static int service_verify(Service *s) {
1098 assert(s);
1099
1124fe6f 1100 if (UNIT(s)->load_state != UNIT_LOADED)
243b1432
LP		 1101 return 0;
1102
1103 if (!s->exec_command[SERVICE_EXEC_START]) {
66870f90
ZJS		 1104 log_error_unit(UNIT(s)->id,
1105 "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
243b1432
LP		 1106 return -EINVAL;
1107 }
1108
34e9ba66
LP		 1109 if (s->type != SERVICE_ONESHOT &&
1110 s->exec_command[SERVICE_EXEC_START]->command_next) {
66870f90
ZJS		 1111 log_error_unit(UNIT(s)->id,
1112 "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
6cf6bbc2
LP		 1113 return -EINVAL;
1114 }
1115
b0693d30
MW		 1116 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1117 log_error_unit(UNIT(s)->id,
1118 "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1119 return -EINVAL;
1120 }
1121
05e343b7 1122 if (s->type == SERVICE_DBUS && !s->bus_name) {
66870f90
ZJS		 1123 log_error_unit(UNIT(s)->id,
1124 "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
4d0e5dbd
LP		 1125 return -EINVAL;
1126 }
1127
7e2668c6 1128 if (s->bus_name && s->type != SERVICE_DBUS)
66870f90
ZJS		 1129 log_warning_unit(UNIT(s)->id,
1130 "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
7e2668c6 1131
4819ff03 1132 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
66870f90
ZJS		 1133 log_error_unit(UNIT(s)->id,
1134 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
05e343b7
LP		 1135 return -EINVAL;
1136 }
1137
243b1432
LP		 1138 return 0;
1139}
1140
a40eb732
LP		 1141static int service_add_default_dependencies(Service *s) {
1142 int r;
1143
1144 assert(s);
1145
1146 /* Add a number of automatic dependencies useful for the
1147 * majority of services. */
1148
1149 /* First, pull in base system */
67445f4e 1150 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
117dcc57
ZJS		 1151 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1152 SPECIAL_BASIC_TARGET, NULL, true);
1153 if (r < 0)
a40eb732
LP		 1154 return r;
1155
67445f4e 1156 } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
117dcc57
ZJS		 1157 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1158 SPECIAL_SOCKETS_TARGET, NULL, true);
1159 if (r < 0)
a40eb732 1160 return r;
e3d84721
LP		 1161
1162 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1163 SPECIAL_TIMERS_TARGET, NULL, true);
1164 if (r < 0)
1165 return r;
1166
1167 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1168 SPECIAL_PATHS_TARGET, NULL, true);
1169 if (r < 0)
1170 return r;
a40eb732
LP		 1171 }
1172
1173 /* Second, activate normal shutdown */
117dcc57
ZJS		 1174 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1175 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1176 return r;
a40eb732
LP		 1177}
1178
4dfc092a
LP		 1179static void service_fix_output(Service *s) {
1180 assert(s);
1181
1182 /* If nothing has been explicitly configured, patch default
1183 * output in. If input is socket/tty we avoid this however,
1184 * since in that case we want output to default to the same
1185 * place as we read input from. */
1186
1187 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1188 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1189 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1190 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
4dfc092a
LP		 1191
1192 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1193 s->exec_context.std_input == EXEC_INPUT_NULL)
1124fe6f 1194 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
4dfc092a
LP		 1195}
1196
e537352b
LP		 1197static int service_load(Unit *u) {
1198 int r;
1199 Service *s = SERVICE(u);
1200
1201 assert(s);
1e2e8133 1202
5cb5a6ff 1203 /* Load a .service file */
c2756a68
LP		 1204 r = unit_load_fragment(u);
1205 if (r < 0)
5cb5a6ff
LP		 1206 return r;
1207
07459bb6 1208#ifdef HAVE_SYSV_COMPAT
bd77d0fc 1209 /* Load a classic init script as a fallback, if we couldn't find anything */
c2756a68
LP		 1210 if (u->load_state == UNIT_STUB) {
1211 r = service_load_sysv(s);
1212 if (r < 0)
23a177ef 1213 return r;
c2756a68 1214 }
07459bb6 1215#endif
d46de8a1 1216
23a177ef 1217 /* Still nothing found? Then let's give up */
ac155bb8 1218 if (u->load_state == UNIT_STUB)
23a177ef 1219 return -ENOENT;
034c6ed7 1220
23a177ef 1221 /* This is a new unit? Then let's add in some extras */
ac155bb8 1222 if (u->load_state == UNIT_LOADED) {
c2756a68
LP		 1223
1224 /* We were able to load something, then let's add in
1225 * the dropin directories. */
1226 r = unit_load_dropin(u);
1227 if (r < 0)
1228 return r;
1229
0b86feac
LP		 1230 if (s->type == _SERVICE_TYPE_INVALID)
1231 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1232
d568a335
MS		 1233 /* Oneshot services have disabled start timeout by default */
1234 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1235 s->timeout_start_usec = 0;
98709151 1236
4e2b0f9b
LP		 1237 service_fix_output(s);
1238
117dcc57
ZJS		 1239 r = unit_add_exec_dependencies(u, &s->exec_context);
1240 if (r < 0)
23a177ef
LP		 1241 return r;
1242
a016b922
LP		 1243 r = unit_add_default_slice(u);
1244 if (r < 0)
1245 return r;
1246
07459bb6 1247#ifdef HAVE_SYSV_COMPAT
117dcc57
ZJS		 1248 r = sysv_fix_order(s);
1249 if (r < 0)
23a177ef 1250 return r;
07459bb6 1251#endif
05e343b7 1252
117dcc57
ZJS		 1253 r = fsck_fix_order(s);
1254 if (r < 0)
9fff8a1f
LP		 1255 return r;
1256
ee0dd802 1257 if (s->bus_name)
05e343b7 1258 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
a40eb732 1259 return r;
c952c6ec
LP		 1260
1261 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1262 s->notify_access = NOTIFY_MAIN;
a40eb732 1263
02c4ef9c
LP		 1264 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1265 s->notify_access = NOTIFY_MAIN;
1266
117dcc57
ZJS		 1267 if (s->type == SERVICE_DBUS || s->bus_name) {
1268 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES,
1269 SPECIAL_DBUS_SOCKET, NULL, true);
1270 if (r < 0)
a40eb732 1271 return r;
117dcc57 1272 }
a40eb732 1273
117dcc57
ZJS		 1274 if (UNIT(s)->default_dependencies) {
1275 r = service_add_default_dependencies(s);
1276 if (r < 0)
a40eb732 1277 return r;
117dcc57 1278 }
e06c73cc 1279
cba6e062 1280 r = unit_exec_context_defaults(u, &s->exec_context);
e06c73cc
LP		 1281 if (r < 0)
1282 return r;
8e274523
LP		 1283 }
1284
243b1432 1285 return service_verify(s);
034c6ed7
LP		 1286}
1287
87f0e418 1288static void service_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 1289
5cb5a6ff 1290 ServiceExecCommand c;
87f0e418 1291 Service *s = SERVICE(u);
47be870b 1292 const char *prefix2;
7fd1b19b 1293 _cleanup_free_ char *p2 = NULL;
5cb5a6ff
LP		 1294
1295 assert(s);
1296
47be870b
LP		 1297 p2 = strappend(prefix, "\t");
1298 prefix2 = p2 ? p2 : prefix;
44d8db9e 1299
5cb5a6ff 1300 fprintf(f,
81a2b7ce 1301 "%sService State: %s\n"
f42806df
LP		 1302 "%sResult: %s\n"
1303 "%sReload Result: %s\n"
81a2b7ce 1304 "%sPermissionsStartOnly: %s\n"
8e274523 1305 "%sRootDirectoryStartOnly: %s\n"
02ee865a 1306 "%sRemainAfterExit: %s\n"
3185a36b 1307 "%sGuessMainPID: %s\n"
c952c6ec 1308 "%sType: %s\n"
2cf3143a 1309 "%sRestart: %s\n"
c952c6ec 1310 "%sNotifyAccess: %s\n",
81a2b7ce 1311 prefix, service_state_to_string(s->state),
f42806df
LP		 1312 prefix, service_result_to_string(s->result),
1313 prefix, service_result_to_string(s->reload_result),
81a2b7ce 1314 prefix, yes_no(s->permissions_start_only),
8e274523 1315 prefix, yes_no(s->root_directory_start_only),
02ee865a 1316 prefix, yes_no(s->remain_after_exit),
3185a36b 1317 prefix, yes_no(s->guess_main_pid),
c952c6ec 1318 prefix, service_type_to_string(s->type),
2cf3143a 1319 prefix, service_restart_to_string(s->restart),
c952c6ec 1320 prefix, notify_access_to_string(s->notify_access));
5cb5a6ff 1321
70123e68
LP		 1322 if (s->control_pid > 0)
1323 fprintf(f,
bb00e604
LP		 1324 "%sControl PID: %lu\n",
1325 prefix, (unsigned long) s->control_pid);
70123e68
LP		 1326
1327 if (s->main_pid > 0)
1328 fprintf(f,
6dfa5494
LP		 1329 "%sMain PID: %lu\n"
1330 "%sMain PID Known: %s\n"
1331 "%sMain PID Alien: %s\n",
1332 prefix, (unsigned long) s->main_pid,
1333 prefix, yes_no(s->main_pid_known),
1334 prefix, yes_no(s->main_pid_alien));
70123e68 1335
034c6ed7
LP		 1336 if (s->pid_file)
1337 fprintf(f,
1338 "%sPIDFile: %s\n",
1339 prefix, s->pid_file);
1340
05e343b7
LP		 1341 if (s->bus_name)
1342 fprintf(f,
1343 "%sBusName: %s\n"
1344 "%sBus Name Good: %s\n",
1345 prefix, s->bus_name,
1346 prefix, yes_no(s->bus_name_good));
1347
4819ff03 1348 kill_context_dump(&s->kill_context, f, prefix);
5cb5a6ff
LP		 1349 exec_context_dump(&s->exec_context, f, prefix);
1350
e537352b 1351 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
5cb5a6ff 1352
44d8db9e
LP		 1353 if (!s->exec_command[c])
1354 continue;
1355
40d50879 1356 fprintf(f, "%s-> %s:\n",
94f04347 1357 prefix, service_exec_command_to_string(c));
44d8db9e
LP		 1358
1359 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 1360 }
44d8db9e 1361
07459bb6 1362#ifdef HAVE_SYSV_COMPAT
1b64d026 1363 if (s->is_sysv)
2c4104f0 1364 fprintf(f,
9fff8a1f
LP		 1365 "%sSysV Init Script has LSB Header: %s\n"
1366 "%sSysVEnabled: %s\n",
9fff8a1f
LP		 1367 prefix, yes_no(s->sysv_has_lsb),
1368 prefix, yes_no(s->sysv_enabled));
2c4104f0
LP		 1369
1370 if (s->sysv_start_priority >= 0)
1371 fprintf(f,
9fff8a1f
LP		 1372 "%sSysVStartPriority: %i\n",
1373 prefix, s->sysv_start_priority);
2c4104f0 1374
8309400a
LP		 1375 if (s->sysv_runlevels)
1376 fprintf(f, "%sSysVRunLevels: %s\n",
1377 prefix, s->sysv_runlevels);
07459bb6 1378#endif
23a177ef 1379
9fff8a1f
LP		 1380 if (s->fsck_passno > 0)
1381 fprintf(f,
1382 "%sFsckPassNo: %i\n",
1383 prefix, s->fsck_passno);
1384
8c47c732
LP		 1385 if (s->status_text)
1386 fprintf(f, "%sStatus Text: %s\n",
1387 prefix, s->status_text);
5cb5a6ff
LP		 1388}
1389
c5419d42 1390static int service_load_pid_file(Service *s, bool may_warn) {
7fd1b19b 1391 _cleanup_free_ char *k = NULL;
034c6ed7 1392 int r;
5925dd3c 1393 pid_t pid;
034c6ed7
LP		 1394
1395 assert(s);
1396
034c6ed7 1397 if (!s->pid_file)
13230d5d 1398 return -ENOENT;
034c6ed7 1399
117dcc57
ZJS		 1400 r = read_one_line_file(s->pid_file, &k);
1401 if (r < 0) {
c5419d42 1402 if (may_warn)
66870f90
ZJS		 1403 log_info_unit(UNIT(s)->id,
1404 "PID file %s not readable (yet?) after %s.",
1405 s->pid_file, service_state_to_string(s->state));
034c6ed7 1406 return r;
5375410b 1407 }
034c6ed7 1408
5925dd3c 1409 r = parse_pid(k, &pid);
bc41f93e
ZJS		 1410 if (r < 0) {
1411 if (may_warn)
1412 log_info_unit(UNIT(s)->id,
1413 "Failed to read PID from file %s: %s",
1414 s->pid_file, strerror(-r));
5925dd3c 1415 return r;
bc41f93e 1416 }
406eaf93 1417
5925dd3c 1418 if (kill(pid, 0) < 0 && errno != EPERM) {
c5419d42 1419 if (may_warn)
66870f90
ZJS		 1420 log_info_unit(UNIT(s)->id,
1421 "PID %lu read from file %s does not exist.",
1422 (unsigned long) pid, s->pid_file);
b8c597d5
LP		 1423 return -ESRCH;
1424 }
1425
db01f8b3
MS		 1426 if (s->main_pid_known) {
1427 if (pid == s->main_pid)
1428 return 0;
1429
66870f90
ZJS		 1430 log_debug_unit(UNIT(s)->id,
1431 "Main PID changing: %lu -> %lu",
1432 (unsigned long) s->main_pid, (unsigned long) pid);
db01f8b3
MS		 1433 service_unwatch_main_pid(s);
1434 s->main_pid_known = false;
3a111838 1435 } else
66870f90
ZJS		 1436 log_debug_unit(UNIT(s)->id,
1437 "Main PID loaded: %lu", (unsigned long) pid);
db01f8b3 1438
117dcc57
ZJS		 1439 r = service_set_main_pid(s, pid);
1440 if (r < 0)
16f6025e
LP		 1441 return r;
1442
117dcc57 1443 r = unit_watch_pid(UNIT(s), pid);
bc41f93e 1444 if (r < 0) {
5925dd3c 1445 /* FIXME: we need to do something here */
bc41f93e
ZJS		 1446 log_warning_unit(UNIT(s)->id,
1447 "Failed to watch PID %lu from service %s",
1448 (unsigned long) pid, UNIT(s)->id);
5925dd3c 1449 return r;
bc41f93e 1450 }
034c6ed7
LP		 1451
1452 return 0;
1453}
1454
4fbf50b3
LP		 1455static int service_search_main_pid(Service *s) {
1456 pid_t pid;
1457 int r;
1458
1459 assert(s);
1460
3185a36b
LP		 1461 /* If we know it anyway, don't ever fallback to unreliable
1462 * heuristics */
4fbf50b3
LP		 1463 if (s->main_pid_known)
1464 return 0;
1465
3185a36b
LP		 1466 if (!s->guess_main_pid)
1467 return 0;
1468
4fbf50b3
LP		 1469 assert(s->main_pid <= 0);
1470
4ad49000 1471 pid = unit_search_main_pid(UNIT(s));
117dcc57 1472 if (pid <= 0)
4fbf50b3
LP		 1473 return -ENOENT;
1474
66870f90
ZJS		 1475 log_debug_unit(UNIT(s)->id,
1476 "Main PID guessed: %lu", (unsigned long) pid);
117dcc57
ZJS		 1477 r = service_set_main_pid(s, pid);
1478 if (r < 0)
4fbf50b3
LP		 1479 return r;
1480
117dcc57
ZJS		 1481 r = unit_watch_pid(UNIT(s), pid);
1482 if (r < 0)
4fbf50b3 1483 /* FIXME: we need to do something here */
a827e373
ZJS		 1484 log_warning_unit(UNIT(s)->id,
1485 "Failed to watch PID %lu from service %s",
1486 (unsigned long) pid, UNIT(s)->id);
4fbf50b3
LP		 1487 return r;
1488
1489 return 0;
1490}
1491
6bda96a0 1492static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
ceee3d82 1493 Iterator i;
57020a3a 1494 Unit *u;
3e33402a
LP		 1495
1496 assert(s);
1497
f976f3f6
LP		 1498 /* Notifies all our sockets when we die */
1499
6cf6bbc2 1500 if (s->socket_fd >= 0)
57020a3a 1501 return;
3e33402a 1502
1124fe6f 1503 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
ac155bb8 1504 if (u->type == UNIT_SOCKET)
6bda96a0 1505 socket_notify_service_dead(SOCKET(u), failed_permanent);
3e33402a 1506
57020a3a 1507 return;
ceee3d82
LP		 1508}
1509
034c6ed7
LP		 1510static void service_set_state(Service *s, ServiceState state) {
1511 ServiceState old_state;
e056b01d 1512 const UnitActiveState *table;
5cb5a6ff
LP		 1513 assert(s);
1514
e056b01d
LP		 1515 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1516
034c6ed7 1517 old_state = s->state;
5cb5a6ff 1518 s->state = state;
034c6ed7 1519
3a111838
MS		 1520 service_unwatch_pid_file(s);
1521
034c6ed7
LP		 1522 if (state != SERVICE_START_PRE &&
1523 state != SERVICE_START &&
1524 state != SERVICE_START_POST &&
1525 state != SERVICE_RELOAD &&
1526 state != SERVICE_STOP &&
1527 state != SERVICE_STOP_SIGTERM &&
1528 state != SERVICE_STOP_SIGKILL &&
1529 state != SERVICE_STOP_POST &&
1530 state != SERVICE_FINAL_SIGTERM &&
1531 state != SERVICE_FINAL_SIGKILL &&
1532 state != SERVICE_AUTO_RESTART)
acbb0225 1533 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1534
7d55e835
LP		 1535 if (state != SERVICE_START &&
1536 state != SERVICE_START_POST &&
034c6ed7
LP		 1537 state != SERVICE_RUNNING &&
1538 state != SERVICE_RELOAD &&
1539 state != SERVICE_STOP &&
1540 state != SERVICE_STOP_SIGTERM &&
867b3b7d 1541 state != SERVICE_STOP_SIGKILL) {
5e94833f 1542 service_unwatch_main_pid(s);
867b3b7d
LP		 1543 s->main_command = NULL;
1544 }
034c6ed7
LP		 1545
1546 if (state != SERVICE_START_PRE &&
1547 state != SERVICE_START &&
1548 state != SERVICE_START_POST &&
1549 state != SERVICE_RELOAD &&
1550 state != SERVICE_STOP &&
1551 state != SERVICE_STOP_SIGTERM &&
1552 state != SERVICE_STOP_SIGKILL &&
1553 state != SERVICE_STOP_POST &&
1554 state != SERVICE_FINAL_SIGTERM &&
e537352b 1555 state != SERVICE_FINAL_SIGKILL) {
5e94833f 1556 service_unwatch_control_pid(s);
034c6ed7 1557 s->control_command = NULL;
a16e1123 1558 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
e537352b 1559 }
034c6ed7 1560
464876c9
LP		 1561 if (state == SERVICE_FAILED)
1562 service_notify_sockets_dead(s, s->result == SERVICE_FAILURE_START_LIMIT);
1563
ceee3d82
LP		 1564 if (state == SERVICE_DEAD ||
1565 state == SERVICE_STOP ||
1566 state == SERVICE_STOP_SIGTERM ||
1567 state == SERVICE_STOP_SIGKILL ||
1568 state == SERVICE_STOP_POST ||
1569 state == SERVICE_FINAL_SIGTERM ||
1570 state == SERVICE_FINAL_SIGKILL ||
ceee3d82 1571 state == SERVICE_AUTO_RESTART)
c2f34808 1572 service_notify_sockets_dead(s, false);
ceee3d82 1573
4f2d528d
LP		 1574 if (state != SERVICE_START_PRE &&
1575 state != SERVICE_START &&
6cf6bbc2
LP		 1576 state != SERVICE_START_POST &&
1577 state != SERVICE_RUNNING &&
1578 state != SERVICE_RELOAD &&
1579 state != SERVICE_STOP &&
1580 state != SERVICE_STOP_SIGTERM &&
1581 state != SERVICE_STOP_SIGKILL &&
1582 state != SERVICE_STOP_POST &&
1583 state != SERVICE_FINAL_SIGTERM &&
1584 state != SERVICE_FINAL_SIGKILL &&
1124fe6f 1585 !(state == SERVICE_DEAD && UNIT(s)->job)) {
4f2d528d 1586 service_close_socket_fd(s);
6cf6bbc2
LP		 1587 service_connection_unref(s);
1588 }
4f2d528d 1589
6d594baa 1590 if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
a6927d7f
MO		 1591 service_stop_watchdog(s);
1592
f6023656
LP		 1593 /* For the inactive states unit_notify() will trim the cgroup,
1594 * but for exit we have to do that ourselves... */
1124fe6f 1595 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
4ad49000 1596 unit_destroy_cgroup(UNIT(s));
f6023656 1597
e537352b 1598 if (old_state != state)
66870f90
ZJS		 1599 log_debug_unit(UNIT(s)->id,
1600 "%s changed %s -> %s", UNIT(s)->id,
1601 service_state_to_string(old_state),
1602 service_state_to_string(state));
acbb0225 1603
e056b01d 1604 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
f42806df 1605 s->reload_result = SERVICE_SUCCESS;
034c6ed7
LP		 1606}
1607
a16e1123
LP		 1608static int service_coldplug(Unit *u) {
1609 Service *s = SERVICE(u);
1610 int r;
1611
1612 assert(s);
1613 assert(s->state == SERVICE_DEAD);
1614
1615 if (s->deserialized_state != s->state) {
1616
1617 if (s->deserialized_state == SERVICE_START_PRE ||
1618 s->deserialized_state == SERVICE_START ||
1619 s->deserialized_state == SERVICE_START_POST ||
1620 s->deserialized_state == SERVICE_RELOAD ||
1621 s->deserialized_state == SERVICE_STOP ||
1622 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1623 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1624 s->deserialized_state == SERVICE_STOP_POST ||
1625 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1626 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
e558336f 1627 s->deserialized_state == SERVICE_AUTO_RESTART) {
6c12b52e 1628
d568a335 1629 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
e558336f
LP		 1630 usec_t k;
1631
d568a335 1632 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
e558336f 1633
36697dc0
LP		 1634 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1635 if (r < 0)
e558336f
LP		 1636 return r;
1637 }
1638 }
a16e1123
LP		 1639
1640 if ((s->deserialized_state == SERVICE_START &&
1641 (s->type == SERVICE_FORKING ||
8c47c732 1642 s->type == SERVICE_DBUS ||
34e9ba66 1643 s->type == SERVICE_ONESHOT ||
8c47c732 1644 s->type == SERVICE_NOTIFY)) ||
a16e1123
LP		 1645 s->deserialized_state == SERVICE_START_POST ||
1646 s->deserialized_state == SERVICE_RUNNING ||
1647 s->deserialized_state == SERVICE_RELOAD ||
1648 s->deserialized_state == SERVICE_STOP ||
1649 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1650 s->deserialized_state == SERVICE_STOP_SIGKILL)
117dcc57
ZJS		 1651 if (s->main_pid > 0) {
1652 r = unit_watch_pid(UNIT(s), s->main_pid);
1653 if (r < 0)
a16e1123 1654 return r;
117dcc57 1655 }
a16e1123
LP		 1656
1657 if (s->deserialized_state == SERVICE_START_PRE ||
1658 s->deserialized_state == SERVICE_START ||
1659 s->deserialized_state == SERVICE_START_POST ||
1660 s->deserialized_state == SERVICE_RELOAD ||
1661 s->deserialized_state == SERVICE_STOP ||
1662 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1663 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1664 s->deserialized_state == SERVICE_STOP_POST ||
1665 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1666 s->deserialized_state == SERVICE_FINAL_SIGKILL)
117dcc57
ZJS		 1667 if (s->control_pid > 0) {
1668 r = unit_watch_pid(UNIT(s), s->control_pid);
1669 if (r < 0)
a16e1123 1670 return r;
117dcc57 1671 }
a16e1123 1672
bb242b7b
MO		 1673 if (s->deserialized_state == SERVICE_START_POST ||
1674 s->deserialized_state == SERVICE_RUNNING)
1675 service_handle_watchdog(s);
1676
a16e1123
LP		 1677 service_set_state(s, s->deserialized_state);
1678 }
a16e1123
LP		 1679 return 0;
1680}
1681
44d8db9e
LP		 1682static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1683 Iterator i;
1684 int r;
1685 int *rfds = NULL;
1686 unsigned rn_fds = 0;
57020a3a 1687 Unit *u;
44d8db9e
LP		 1688
1689 assert(s);
1690 assert(fds);
1691 assert(n_fds);
1692
6cf6bbc2
LP		 1693 if (s->socket_fd >= 0)
1694 return 0;
1695
1124fe6f 1696 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
44d8db9e
LP		 1697 int *cfds;
1698 unsigned cn_fds;
57020a3a
LP		 1699 Socket *sock;
1700
ac155bb8 1701 if (u->type != UNIT_SOCKET)
57020a3a
LP		 1702 continue;
1703
1704 sock = SOCKET(u);
44d8db9e 1705
117dcc57
ZJS		 1706 r = socket_collect_fds(sock, &cfds, &cn_fds);
1707 if (r < 0)
44d8db9e
LP		 1708 goto fail;
1709
1710 if (!cfds)
1711 continue;
1712
1713 if (!rfds) {
1714 rfds = cfds;
1715 rn_fds = cn_fds;
1716 } else {
1717 int *t;
1718
117dcc57
ZJS		 1719 t = new(int, rn_fds+cn_fds);
1720 if (!t) {
44d8db9e
LP		 1721 free(cfds);
1722 r = -ENOMEM;
1723 goto fail;
1724 }
1725
9c1b183c
LP		 1726 memcpy(t, rfds, rn_fds * sizeof(int));
1727 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
44d8db9e
LP		 1728 free(rfds);
1729 free(cfds);
1730
1731 rfds = t;
1732 rn_fds = rn_fds+cn_fds;
1733 }
1734 }
1735
1736 *fds = rfds;
1737 *n_fds = rn_fds;
3e33402a 1738
44d8db9e
LP		 1739 return 0;
1740
1741fail:
1742 free(rfds);
3e33402a 1743
44d8db9e
LP		 1744 return r;
1745}
1746
81a2b7ce
LP		 1747static int service_spawn(
1748 Service *s,
1749 ExecCommand *c,
1750 bool timeout,
1751 bool pass_fds,
1752 bool apply_permissions,
1753 bool apply_chroot,
1e3ad081 1754 bool apply_tty_stdin,
c952c6ec 1755 bool set_notify_socket,
ecedd90f 1756 bool is_control,
81a2b7ce
LP		 1757 pid_t *_pid) {
1758
034c6ed7
LP		 1759 pid_t pid;
1760 int r;
117dcc57 1761 int *fds = NULL;
7fd1b19b 1762 _cleanup_free_ int *fdsbuf = NULL;
2105e76a 1763 unsigned n_fds = 0, n_env = 0;
7fd1b19b 1764 _cleanup_strv_free_ char
117dcc57 1765 **argv = NULL, **final_env = NULL, **our_env = NULL;
4ad49000 1766 const char *path;
034c6ed7
LP		 1767
1768 assert(s);
1769 assert(c);
1770 assert(_pid);
1771
4ad49000
LP		 1772 unit_realize_cgroup(UNIT(s));
1773
6cf6bbc2
LP		 1774 if (pass_fds ||
1775 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1776 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1777 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1778
4f2d528d
LP		 1779 if (s->socket_fd >= 0) {
1780 fds = &s->socket_fd;
1781 n_fds = 1;
6cf6bbc2 1782 } else {
117dcc57
ZJS		 1783 r = service_collect_fds(s, &fdsbuf, &n_fds);
1784 if (r < 0)
6cf6bbc2
LP		 1785 goto fail;
1786
1787 fds = fdsbuf;
1788 }
4f2d528d 1789 }
44d8db9e 1790
d568a335 1791 if (timeout && s->timeout_start_usec) {
117dcc57
ZJS		 1792 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1793 s->timeout_start_usec, &s->timer_watch);
d568a335 1794 if (r < 0)
034c6ed7
LP		 1795 goto fail;
1796 } else
acbb0225 1797 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1798
117dcc57
ZJS		 1799 argv = unit_full_printf_strv(UNIT(s), c->argv);
1800 if (!argv) {
9e2f7c11
LP		 1801 r = -ENOMEM;
1802 goto fail;
1803 }
1804
97ae63e2
LP		 1805 our_env = new0(char*, 5);
1806 if (!our_env) {
2105e76a
LP		 1807 r = -ENOMEM;
1808 goto fail;
1809 }
c952c6ec 1810
2105e76a 1811 if (set_notify_socket)
1124fe6f 1812 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
c952c6ec
LP		 1813 r = -ENOMEM;
1814 goto fail;
1815 }
1816
2105e76a
LP		 1817 if (s->main_pid > 0)
1818 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
c952c6ec
LP		 1819 r = -ENOMEM;
1820 goto fail;
1821 }
2105e76a 1822
6e0bcc98
MO		 1823 if (s->watchdog_usec > 0)
1824 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1825 r = -ENOMEM;
1826 goto fail;
1827 }
1828
4ad49000 1829 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
97ae63e2
LP		 1830 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1831 r = -ENOMEM;
1832 goto fail;
1833 }
1834
1835 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1836 if (!final_env) {
2105e76a
LP		 1837 r = -ENOMEM;
1838 goto fail;
1839 }
c952c6ec 1840
4ad49000
LP		 1841 if (is_control && UNIT(s)->cgroup_path) {
1842 path = strappenda(UNIT(s)->cgroup_path, "/control");
1843 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1844 } else
1845 path = UNIT(s)->cgroup_path;
1846
9e2f7c11
LP		 1847 r = exec_spawn(c,
1848 argv,
1849 &s->exec_context,
1850 fds, n_fds,
2105e76a 1851 final_env,
9e2f7c11
LP		 1852 apply_permissions,
1853 apply_chroot,
1e3ad081 1854 apply_tty_stdin,
1124fe6f 1855 UNIT(s)->manager->confirm_spawn,
4ad49000
LP		 1856 UNIT(s)->cgroup_mask,
1857 path,
62bca2c6 1858 UNIT(s)->id,
f2b68789 1859 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
9e2f7c11 1860 &pid);
9e2f7c11 1861 if (r < 0)
034c6ed7
LP		 1862 goto fail;
1863
117dcc57
ZJS		 1864 r = unit_watch_pid(UNIT(s), pid);
1865 if (r < 0)
034c6ed7
LP		 1866 /* FIXME: we need to do something here */
1867 goto fail;
1868
1869 *_pid = pid;
1870
5cb5a6ff 1871 return 0;
034c6ed7
LP		 1872
1873fail:
1874 if (timeout)
acbb0225 1875 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7
LP		 1876
1877 return r;
1878}
1879
80876c20
LP		 1880static int main_pid_good(Service *s) {
1881 assert(s);
1882
1883 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1884 * don't know */
1885
1886 /* If we know the pid file, then lets just check if it is
1887 * still valid */
6dfa5494
LP		 1888 if (s->main_pid_known) {
1889
1890 /* If it's an alien child let's check if it is still
1891 * alive ... */
62220cf7 1892 if (s->main_pid_alien && s->main_pid > 0)
6dfa5494
LP		 1893 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1894
1895 /* .. otherwise assume we'll get a SIGCHLD for it,
1896 * which we really should wait for to collect exit
1897 * status and code */
80876c20 1898 return s->main_pid > 0;
6dfa5494 1899 }
80876c20
LP		 1900
1901 /* We don't know the pid */
1902 return -EAGAIN;
1903}
1904
44a6b1b6 1905_pure_ static int control_pid_good(Service *s) {
80876c20
LP		 1906 assert(s);
1907
1908 return s->control_pid > 0;
1909}
1910
1911static int cgroup_good(Service *s) {
1912 int r;
1913
1914 assert(s);
1915
4ad49000
LP		 1916 if (!UNIT(s)->cgroup_path)
1917 return 0;
1918
1919 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
117dcc57 1920 if (r < 0)
80876c20
LP		 1921 return r;
1922
1923 return !r;
1924}
1925
f42806df 1926static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
034c6ed7
LP		 1927 int r;
1928 assert(s);
1929
f42806df
LP		 1930 if (f != SERVICE_SUCCESS)
1931 s->result = f;
034c6ed7 1932
0c7f15b3
MS		 1933 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1934
034c6ed7 1935 if (allow_restart &&
47342320 1936 !s->forbid_restart &&
034c6ed7 1937 (s->restart == SERVICE_RESTART_ALWAYS ||
f42806df
LP		 1938 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1939 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1940 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
96342de6
LN		 1941 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1942 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1943 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1944 (s->result != SERVICE_FAILURE_SIGNAL ||
1945 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1946 ) {
034c6ed7 1947
36697dc0 1948 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
f42806df 1949 if (r < 0)
034c6ed7
LP		 1950 goto fail;
1951
1952 service_set_state(s, SERVICE_AUTO_RESTART);
0c7f15b3 1953 }
034c6ed7 1954
47342320
LP		 1955 s->forbid_restart = false;
1956
c17ec25e
MS		 1957 /* we want fresh tmpdirs in case service is started again immediately */
1958 exec_context_tmp_dirs_done(&s->exec_context);
1959
9285c9ff
LN		 1960 /* Try to delete the pid file. At this point it will be
1961 * out-of-date, and some software might be confused by it, so
1962 * let's remove it. */
1963 if (s->pid_file)
1964 unlink_noerrno(s->pid_file);
1965
034c6ed7
LP		 1966 return;
1967
1968fail:
66870f90
ZJS		 1969 log_warning_unit(UNIT(s)->id,
1970 "%s failed to run install restart timer: %s",
1971 UNIT(s)->id, strerror(-r));
f42806df 1972 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1973}
1974
f42806df 1975static void service_enter_stop_post(Service *s, ServiceResult f) {
034c6ed7
LP		 1976 int r;
1977 assert(s);
1978
f42806df
LP		 1979 if (f != SERVICE_SUCCESS)
1980 s->result = f;
034c6ed7 1981
5e94833f
LP		 1982 service_unwatch_control_pid(s);
1983
117dcc57
ZJS		 1984 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1985 if (s->control_command) {
867b3b7d
LP		 1986 s->control_command_id = SERVICE_EXEC_STOP_POST;
1987
ecedd90f
LP		 1988 r = service_spawn(s,
1989 s->control_command,
1990 true,
1991 false,
1992 !s->permissions_start_only,
1993 !s->root_directory_start_only,
1994 true,
1995 false,
1996 true,
1997 &s->control_pid);
1998 if (r < 0)
034c6ed7
LP		 1999 goto fail;
2000
d6ea93e3 2001
80876c20
LP		 2002 service_set_state(s, SERVICE_STOP_POST);
2003 } else
c961869a 2004 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 2005
2006 return;
2007
2008fail:
66870f90
ZJS		 2009 log_warning_unit(UNIT(s)->id,
2010 "%s failed to run 'stop-post' task: %s",
2011 UNIT(s)->id, strerror(-r));
f42806df 2012 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2013}
2014
f42806df 2015static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
034c6ed7 2016 int r;
034c6ed7
LP		 2017
2018 assert(s);
2019
f42806df
LP		 2020 if (f != SERVICE_SUCCESS)
2021 s->result = f;
034c6ed7 2022
cd2086fe
LP		 2023 r = unit_kill_context(
2024 UNIT(s),
2025 &s->kill_context,
2026 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
2027 s->main_pid,
2028 s->control_pid,
2029 s->main_pid_alien);
2030 if (r < 0)
2031 goto fail;
034c6ed7 2032
cd2086fe 2033 if (r > 0) {
d568a335 2034 if (s->timeout_stop_usec > 0) {
117dcc57
ZJS		 2035 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2036 s->timeout_stop_usec, &s->timer_watch);
d568a335 2037 if (r < 0)
e558336f 2038 goto fail;
d568a335 2039 }
d6ea93e3 2040
80876c20
LP		 2041 service_set_state(s, state);
2042 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2043 service_enter_stop_post(s, SERVICE_SUCCESS);
80876c20 2044 else
f42806df 2045 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 2046
2047 return;
2048
2049fail:
66870f90
ZJS		 2050 log_warning_unit(UNIT(s)->id,
2051 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
034c6ed7 2052
80876c20 2053 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2054 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
034c6ed7 2055 else
f42806df 2056 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2057}
2058
f42806df 2059static void service_enter_stop(Service *s, ServiceResult f) {
034c6ed7 2060 int r;
5925dd3c 2061
034c6ed7
LP		 2062 assert(s);
2063
f42806df
LP		 2064 if (f != SERVICE_SUCCESS)
2065 s->result = f;
034c6ed7 2066
5e94833f
LP		 2067 service_unwatch_control_pid(s);
2068
117dcc57
ZJS		 2069 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2070 if (s->control_command) {
867b3b7d
LP		 2071 s->control_command_id = SERVICE_EXEC_STOP;
2072
ecedd90f
LP		 2073 r = service_spawn(s,
2074 s->control_command,
2075 true,
2076 false,
2077 !s->permissions_start_only,
2078 !s->root_directory_start_only,
2079 false,
2080 false,
2081 true,
2082 &s->control_pid);
2083 if (r < 0)
034c6ed7
LP		 2084 goto fail;
2085
80876c20
LP		 2086 service_set_state(s, SERVICE_STOP);
2087 } else
f42806df 2088 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 2089
2090 return;
2091
2092fail:
66870f90
ZJS		 2093 log_warning_unit(UNIT(s)->id,
2094 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2095 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2096}
2097
f42806df 2098static void service_enter_running(Service *s, ServiceResult f) {
4eab639f 2099 int main_pid_ok, cgroup_ok;
80876c20
LP		 2100 assert(s);
2101
f42806df
LP		 2102 if (f != SERVICE_SUCCESS)
2103 s->result = f;
80876c20 2104
4eab639f
LP		 2105 main_pid_ok = main_pid_good(s);
2106 cgroup_ok = cgroup_good(s);
2107
2108 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
05e343b7 2109 (s->bus_name_good || s->type != SERVICE_DBUS))
80876c20 2110 service_set_state(s, SERVICE_RUNNING);
02ee865a 2111 else if (s->remain_after_exit)
80876c20
LP		 2112 service_set_state(s, SERVICE_EXITED);
2113 else
f42806df 2114 service_enter_stop(s, SERVICE_SUCCESS);
80876c20
LP		 2115}
2116
034c6ed7
LP		 2117static void service_enter_start_post(Service *s) {
2118 int r;
2119 assert(s);
2120
5e94833f
LP		 2121 service_unwatch_control_pid(s);
2122
bb242b7b
MO		 2123 if (s->watchdog_usec > 0)
2124 service_reset_watchdog(s);
2125
117dcc57
ZJS		 2126 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2127 if (s->control_command) {
867b3b7d
LP		 2128 s->control_command_id = SERVICE_EXEC_START_POST;
2129
ecedd90f
LP		 2130 r = service_spawn(s,
2131 s->control_command,
2132 true,
2133 false,
2134 !s->permissions_start_only,
2135 !s->root_directory_start_only,
2136 false,
2137 false,
2138 true,
2139 &s->control_pid);
2140 if (r < 0)
034c6ed7
LP		 2141 goto fail;
2142
80876c20
LP		 2143 service_set_state(s, SERVICE_START_POST);
2144 } else
f42806df 2145 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2146
2147 return;
2148
2149fail:
66870f90
ZJS		 2150 log_warning_unit(UNIT(s)->id,
2151 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2152 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2153}
2154
4ad49000
LP		 2155static void service_kill_control_processes(Service *s) {
2156 char *p;
2157
2158 if (!UNIT(s)->cgroup_path)
2159 return;
2160
2161 p = strappenda(UNIT(s)->cgroup_path, "/control");
4ad49000
LP		 2162 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2163}
2164
034c6ed7 2165static void service_enter_start(Service *s) {
4ad49000 2166 ExecCommand *c;
034c6ed7
LP		 2167 pid_t pid;
2168 int r;
2169
2170 assert(s);
2171
2172 assert(s->exec_command[SERVICE_EXEC_START]);
34e9ba66 2173 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
034c6ed7 2174
41efeaec
LP		 2175 service_unwatch_control_pid(s);
2176 service_unwatch_main_pid(s);
80876c20 2177
8f53a7b8
LP		 2178 /* We want to ensure that nobody leaks processes from
2179 * START_PRE here, so let's go on a killing spree, People
2180 * should not spawn long running processes from START_PRE. */
4ad49000 2181 service_kill_control_processes(s);
8f53a7b8 2182
867b3b7d
LP		 2183 if (s->type == SERVICE_FORKING) {
2184 s->control_command_id = SERVICE_EXEC_START;
2185 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2186
2187 s->main_command = NULL;
2188 } else {
2189 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2190 s->control_command = NULL;
2191
2192 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2193 }
34e9ba66 2194
ecedd90f
LP		 2195 r = service_spawn(s,
2196 c,
117dcc57
ZJS		 2197 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2198 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
ecedd90f
LP		 2199 true,
2200 true,
2201 true,
2202 true,
2203 s->notify_access != NOTIFY_NONE,
2204 false,
2205 &pid);
2206 if (r < 0)
034c6ed7
LP		 2207 goto fail;
2208
f2b68789 2209 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
034c6ed7
LP		 2210 /* For simple services we immediately start
2211 * the START_POST binaries. */
2212
5925dd3c 2213 service_set_main_pid(s, pid);
034c6ed7
LP		 2214 service_enter_start_post(s);
2215
2216 } else if (s->type == SERVICE_FORKING) {
2217
2218 /* For forking services we wait until the start
2219 * process exited. */
2220
e55224ca 2221 s->control_pid = pid;
80876c20
LP		 2222 service_set_state(s, SERVICE_START);
2223
34e9ba66 2224 } else if (s->type == SERVICE_ONESHOT ||
8c47c732
LP		 2225 s->type == SERVICE_DBUS ||
2226 s->type == SERVICE_NOTIFY) {
7d55e835 2227
34e9ba66 2228 /* For oneshot services we wait until the start
7d55e835
LP		 2229 * process exited, too, but it is our main process. */
2230
05e343b7 2231 /* For D-Bus services we know the main pid right away,
8c47c732
LP		 2232 * but wait for the bus name to appear on the
2233 * bus. Notify services are similar. */
05e343b7 2234
5925dd3c 2235 service_set_main_pid(s, pid);
80876c20 2236 service_set_state(s, SERVICE_START);
034c6ed7
LP		 2237 } else
2238 assert_not_reached("Unknown service type");
2239
2240 return;
2241
2242fail:
66870f90
ZJS		 2243 log_warning_unit(UNIT(s)->id,
2244 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2245 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2246}
2247
2248static void service_enter_start_pre(Service *s) {
2249 int r;
2250
2251 assert(s);
2252
5e94833f
LP		 2253 service_unwatch_control_pid(s);
2254
117dcc57
ZJS		 2255 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2256 if (s->control_command) {
8f53a7b8
LP		 2257 /* Before we start anything, let's clear up what might
2258 * be left from previous runs. */
4ad49000 2259 service_kill_control_processes(s);
8f53a7b8 2260
867b3b7d
LP		 2261 s->control_command_id = SERVICE_EXEC_START_PRE;
2262
ecedd90f
LP		 2263 r = service_spawn(s,
2264 s->control_command,
2265 true,
2266 false,
2267 !s->permissions_start_only,
2268 !s->root_directory_start_only,
2269 true,
2270 false,
2271 true,
2272 &s->control_pid);
2273 if (r < 0)
034c6ed7
LP		 2274 goto fail;
2275
80876c20
LP		 2276 service_set_state(s, SERVICE_START_PRE);
2277 } else
034c6ed7
LP		 2278 service_enter_start(s);
2279
2280 return;
2281
2282fail:
66870f90
ZJS		 2283 log_warning_unit(UNIT(s)->id,
2284 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2285 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2286}
2287
2288static void service_enter_restart(Service *s) {
2289 int r;
398ef8ba
LP		 2290 DBusError error;
2291
034c6ed7 2292 assert(s);
398ef8ba 2293 dbus_error_init(&error);
034c6ed7 2294
a8bb2e65
LP		 2295 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2296 /* Don't restart things if we are going down anyway */
66870f90
ZJS		 2297 log_info_unit(UNIT(s)->id,
2298 "Stop job pending for unit, delaying automatic restart.");
2edfa366 2299
36697dc0 2300 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
a8bb2e65 2301 if (r < 0)
2edfa366 2302 goto fail;
feae8adb
DW		 2303
2304 return;
2edfa366
LP		 2305 }
2306
48bb5876
DW		 2307 /* Any units that are bound to this service must also be
2308 * restarted. We use JOB_RESTART (instead of the more obvious
2309 * JOB_START) here so that those dependency jobs will be added
2310 * as well. */
2311 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2312 if (r < 0)
034c6ed7
LP		 2313 goto fail;
2314
a8bb2e65
LP		 2315 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2316 * it will be canceled as part of the service_stop() call that
2317 * is executed as part of JOB_RESTART. */
2318
66870f90
ZJS		 2319 log_debug_unit(UNIT(s)->id,
2320 "%s scheduled restart job.", UNIT(s)->id);
034c6ed7
LP		 2321 return;
2322
2323fail:
66870f90
ZJS		 2324 log_warning_unit(UNIT(s)->id,
2325 "%s failed to schedule restart job: %s",
2326 UNIT(s)->id, bus_error(&error, -r));
f42806df 2327 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
398ef8ba
LP		 2328
2329 dbus_error_free(&error);
034c6ed7
LP		 2330}
2331
2332static void service_enter_reload(Service *s) {
2333 int r;
2334
2335 assert(s);
2336
5e94833f
LP		 2337 service_unwatch_control_pid(s);
2338
117dcc57
ZJS		 2339 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2340 if (s->control_command) {
867b3b7d
LP		 2341 s->control_command_id = SERVICE_EXEC_RELOAD;
2342
ecedd90f
LP		 2343 r = service_spawn(s,
2344 s->control_command,
2345 true,
2346 false,
2347 !s->permissions_start_only,
2348 !s->root_directory_start_only,
2349 false,
2350 false,
2351 true,
2352 &s->control_pid);
2353 if (r < 0)
034c6ed7
LP		 2354 goto fail;
2355
80876c20
LP		 2356 service_set_state(s, SERVICE_RELOAD);
2357 } else
f42806df 2358 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2359
2360 return;
2361
2362fail:
66870f90
ZJS		 2363 log_warning_unit(UNIT(s)->id,
2364 "%s failed to run 'reload' task: %s",
2365 UNIT(s)->id, strerror(-r));
f42806df
LP		 2366 s->reload_result = SERVICE_FAILURE_RESOURCES;
2367 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2368}
2369
f42806df 2370static void service_run_next_control(Service *s) {
034c6ed7
LP		 2371 int r;
2372
2373 assert(s);
2374 assert(s->control_command);
2375 assert(s->control_command->command_next);
2376
34e9ba66 2377 assert(s->control_command_id != SERVICE_EXEC_START);
034c6ed7 2378
34e9ba66 2379 s->control_command = s->control_command->command_next;
5e94833f
LP		 2380 service_unwatch_control_pid(s);
2381
ecedd90f
LP		 2382 r = service_spawn(s,
2383 s->control_command,
2384 true,
2385 false,
2386 !s->permissions_start_only,
2387 !s->root_directory_start_only,
2388 s->control_command_id == SERVICE_EXEC_START_PRE ||
2389 s->control_command_id == SERVICE_EXEC_STOP_POST,
2390 false,
2391 true,
2392 &s->control_pid);
2393 if (r < 0)
034c6ed7
LP		 2394 goto fail;
2395
2396 return;
2397
2398fail:
66870f90
ZJS		 2399 log_warning_unit(UNIT(s)->id,
2400 "%s failed to run next control task: %s",
2401 UNIT(s)->id, strerror(-r));
034c6ed7 2402
80876c20 2403 if (s->state == SERVICE_START_PRE)
f42806df 2404 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
80876c20 2405 else if (s->state == SERVICE_STOP)
f42806df 2406 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7 2407 else if (s->state == SERVICE_STOP_POST)
f42806df 2408 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
e2f3b44c 2409 else if (s->state == SERVICE_RELOAD) {
f42806df
LP		 2410 s->reload_result = SERVICE_FAILURE_RESOURCES;
2411 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c 2412 } else
f42806df 2413 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
5cb5a6ff
LP		 2414}
2415
f42806df 2416static void service_run_next_main(Service *s) {
34e9ba66
LP		 2417 pid_t pid;
2418 int r;
2419
2420 assert(s);
867b3b7d
LP		 2421 assert(s->main_command);
2422 assert(s->main_command->command_next);
2423 assert(s->type == SERVICE_ONESHOT);
34e9ba66 2424
867b3b7d 2425 s->main_command = s->main_command->command_next;
34e9ba66
LP		 2426 service_unwatch_main_pid(s);
2427
ecedd90f
LP		 2428 r = service_spawn(s,
2429 s->main_command,
98709151 2430 true,
ecedd90f
LP		 2431 true,
2432 true,
2433 true,
2434 true,
2435 s->notify_access != NOTIFY_NONE,
2436 false,
2437 &pid);
2438 if (r < 0)
34e9ba66
LP		 2439 goto fail;
2440
2441 service_set_main_pid(s, pid);
2442
2443 return;
2444
2445fail:
66870f90
ZJS		 2446 log_warning_unit(UNIT(s)->id,
2447 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
f42806df 2448 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
34e9ba66
LP		 2449}
2450
4b939747
MO		 2451static int service_start_limit_test(Service *s) {
2452 assert(s);
2453
2454 if (ratelimit_test(&s->start_limit))
2455 return 0;
2456
2457 switch (s->start_limit_action) {
2458
2459 case SERVICE_START_LIMIT_NONE:
66870f90
ZJS		 2460 log_warning_unit(UNIT(s)->id,
2461 "%s start request repeated too quickly, refusing to start.",
2462 UNIT(s)->id);
4b939747
MO		 2463 break;
2464
2465 case SERVICE_START_LIMIT_REBOOT: {
2466 DBusError error;
2467 int r;
2468
2469 dbus_error_init(&error);
2470
66870f90
ZJS		 2471 log_warning_unit(UNIT(s)->id,
2472 "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
4b939747 2473
117dcc57
ZJS		 2474 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2475 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2476 true, &error, NULL);
4b939747 2477 if (r < 0) {
66870f90
ZJS		 2478 log_error_unit(UNIT(s)->id,
2479 "Failed to reboot: %s.", bus_error(&error, r));
4b939747
MO		 2480 dbus_error_free(&error);
2481 }
2482
2483 break;
2484 }
2485
2486 case SERVICE_START_LIMIT_REBOOT_FORCE:
66870f90
ZJS		 2487 log_warning_unit(UNIT(s)->id,
2488 "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
4b939747
MO		 2489 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2490 break;
2491
2492 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
66870f90
ZJS		 2493 log_warning_unit(UNIT(s)->id,
2494 "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
0049f05a 2495 sync();
4b939747
MO		 2496 reboot(RB_AUTOBOOT);
2497 break;
2498
2499 default:
66870f90
ZJS		 2500 log_error_unit(UNIT(s)->id,
2501 "start limit action=%i", s->start_limit_action);
4b939747
MO		 2502 assert_not_reached("Unknown StartLimitAction.");
2503 }
2504
2505 return -ECANCELED;
2506}
2507
87f0e418
LP		 2508static int service_start(Unit *u) {
2509 Service *s = SERVICE(u);
4b939747 2510 int r;
5cb5a6ff
LP		 2511
2512 assert(s);
2513
034c6ed7
LP		 2514 /* We cannot fulfill this request right now, try again later
2515 * please! */
2516 if (s->state == SERVICE_STOP ||
2517 s->state == SERVICE_STOP_SIGTERM ||
2518 s->state == SERVICE_STOP_SIGKILL ||
2519 s->state == SERVICE_STOP_POST ||
2520 s->state == SERVICE_FINAL_SIGTERM ||
2521 s->state == SERVICE_FINAL_SIGKILL)
5cb5a6ff
LP		 2522 return -EAGAIN;
2523
034c6ed7
LP		 2524 /* Already on it! */
2525 if (s->state == SERVICE_START_PRE ||
2526 s->state == SERVICE_START ||
2527 s->state == SERVICE_START_POST)
2528 return 0;
2529
2e9d6c12 2530 /* A service that will be restarted must be stopped first to
7f2cddae 2531 * trigger BindsTo and/or OnFailure dependencies. If a user
2e9d6c12 2532 * does not want to wait for the holdoff time to elapse, the
d4943dc7
LP		 2533 * service should be manually restarted, not started. We
2534 * simply return EAGAIN here, so that any start jobs stay
2535 * queued, and assume that the auto restart timer will
2536 * eventually trigger the restart. */
2537 if (s->state == SERVICE_AUTO_RESTART)
a8bb2e65 2538 return -EAGAIN;
2e9d6c12
DW		 2539
2540 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
5cb5a6ff 2541
1e2e8133 2542 /* Make sure we don't enter a busy loop of some kind. */
4b939747 2543 r = service_start_limit_test(s);
c2f34808 2544 if (r < 0) {
8d1b002a 2545 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
4b939747 2546 return r;
c2f34808 2547 }
1e2e8133 2548
f42806df
LP		 2549 s->result = SERVICE_SUCCESS;
2550 s->reload_result = SERVICE_SUCCESS;
034c6ed7 2551 s->main_pid_known = false;
6dfa5494 2552 s->main_pid_alien = false;
47342320 2553 s->forbid_restart = false;
034c6ed7
LP		 2554
2555 service_enter_start_pre(s);
2556 return 0;
5cb5a6ff
LP		 2557}
2558
87f0e418
LP		 2559static int service_stop(Unit *u) {
2560 Service *s = SERVICE(u);
5cb5a6ff
LP		 2561
2562 assert(s);
2563
f0c7b229 2564 /* Don't create restart jobs from here. */
47342320 2565 s->forbid_restart = true;
034c6ed7 2566
e537352b
LP		 2567 /* Already on it */
2568 if (s->state == SERVICE_STOP ||
2569 s->state == SERVICE_STOP_SIGTERM ||
2570 s->state == SERVICE_STOP_SIGKILL ||
2571 s->state == SERVICE_STOP_POST ||
2572 s->state == SERVICE_FINAL_SIGTERM ||
2573 s->state == SERVICE_FINAL_SIGKILL)
2574 return 0;
2575
f0c7b229 2576 /* A restart will be scheduled or is in progress. */
034c6ed7 2577 if (s->state == SERVICE_AUTO_RESTART) {
0c7f15b3 2578 service_set_state(s, SERVICE_DEAD);
034c6ed7
LP		 2579 return 0;
2580 }
2581
3f6c78dc
LP		 2582 /* If there's already something running we go directly into
2583 * kill mode. */
2584 if (s->state == SERVICE_START_PRE ||
2585 s->state == SERVICE_START ||
2586 s->state == SERVICE_START_POST ||
2587 s->state == SERVICE_RELOAD) {
f42806df 2588 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
3f6c78dc
LP		 2589 return 0;
2590 }
5cb5a6ff 2591
3f6c78dc
LP		 2592 assert(s->state == SERVICE_RUNNING ||
2593 s->state == SERVICE_EXITED);
3a762661 2594
f42806df 2595 service_enter_stop(s, SERVICE_SUCCESS);
5cb5a6ff
LP		 2596 return 0;
2597}
2598
87f0e418
LP		 2599static int service_reload(Unit *u) {
2600 Service *s = SERVICE(u);
034c6ed7
LP		 2601
2602 assert(s);
2603
80876c20 2604 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
034c6ed7
LP		 2605
2606 service_enter_reload(s);
5cb5a6ff
LP		 2607 return 0;
2608}
2609
44a6b1b6 2610_pure_ static bool service_can_reload(Unit *u) {
87f0e418 2611 Service *s = SERVICE(u);
034c6ed7
LP		 2612
2613 assert(s);
2614
2615 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2616}
2617
a16e1123
LP		 2618static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2619 Service *s = SERVICE(u);
2620
2621 assert(u);
2622 assert(f);
2623 assert(fds);
2624
2625 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
f42806df
LP		 2626 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2627 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
a16e1123
LP		 2628
2629 if (s->control_pid > 0)
117dcc57
ZJS		 2630 unit_serialize_item_format(u, f, "control-pid", "%lu",
2631 (unsigned long) s->control_pid);
a16e1123 2632
5925dd3c
LP		 2633 if (s->main_pid_known && s->main_pid > 0)
2634 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
a16e1123
LP		 2635
2636 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2637
3a2776bc
LP		 2638 if (s->status_text)
2639 unit_serialize_item(u, f, "status-text", s->status_text);
2640
cfc4eb4c
LP		 2641 /* FIXME: There's a minor uncleanliness here: if there are
2642 * multiple commands attached here, we will start from the
2643 * first one again */
a16e1123 2644 if (s->control_command_id >= 0)
117dcc57
ZJS		 2645 unit_serialize_item(u, f, "control-command",
2646 service_exec_command_to_string(s->control_command_id));
a16e1123
LP		 2647
2648 if (s->socket_fd >= 0) {
2649 int copy;
2650
2651 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2652 return copy;
2653
2654 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2655 }
2656
ecdbca40 2657 if (s->main_exec_status.pid > 0) {
117dcc57
ZJS		 2658 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2659 (unsigned long) s->main_exec_status.pid);
2660 dual_timestamp_serialize(f, "main-exec-status-start",
2661 &s->main_exec_status.start_timestamp);
2662 dual_timestamp_serialize(f, "main-exec-status-exit",
2663 &s->main_exec_status.exit_timestamp);
ecdbca40 2664
799fd0fd 2665 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
117dcc57
ZJS		 2666 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2667 s->main_exec_status.code);
2668 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2669 s->main_exec_status.status);
ecdbca40
LP		 2670 }
2671 }
a6927d7f 2672 if (dual_timestamp_is_set(&s->watchdog_timestamp))
117dcc57
ZJS		 2673 dual_timestamp_serialize(f, "watchdog-timestamp",
2674 &s->watchdog_timestamp);
ecdbca40 2675
c17ec25e
MS		 2676 if (s->exec_context.tmp_dir)
2677 unit_serialize_item(u, f, "tmp-dir", s->exec_context.tmp_dir);
2678
2679 if (s->exec_context.var_tmp_dir)
2680 unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2681
a16e1123
LP		 2682 return 0;
2683}
2684
2685static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2686 Service *s = SERVICE(u);
a16e1123
LP		 2687
2688 assert(u);
2689 assert(key);
2690 assert(value);
2691 assert(fds);
2692
2693 if (streq(key, "state")) {
2694 ServiceState state;
2695
117dcc57
ZJS		 2696 state = service_state_from_string(value);
2697 if (state < 0)
66870f90 2698 log_debug_unit(u->id, "Failed to parse state value %s", value);
a16e1123
LP		 2699 else
2700 s->deserialized_state = state;
f42806df
LP		 2701 } else if (streq(key, "result")) {
2702 ServiceResult f;
2703
2704 f = service_result_from_string(value);
2705 if (f < 0)
66870f90 2706 log_debug_unit(u->id, "Failed to parse result value %s", value);
f42806df
LP		 2707 else if (f != SERVICE_SUCCESS)
2708 s->result = f;
2709
2710 } else if (streq(key, "reload-result")) {
2711 ServiceResult f;
2712
2713 f = service_result_from_string(value);
2714 if (f < 0)
66870f90 2715 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
f42806df
LP		 2716 else if (f != SERVICE_SUCCESS)
2717 s->reload_result = f;
a16e1123 2718
a16e1123 2719 } else if (streq(key, "control-pid")) {
5925dd3c 2720 pid_t pid;
a16e1123 2721
e364ad06 2722 if (parse_pid(value, &pid) < 0)
66870f90 2723 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
a16e1123 2724 else
e55224ca 2725 s->control_pid = pid;
a16e1123 2726 } else if (streq(key, "main-pid")) {
5925dd3c 2727 pid_t pid;
a16e1123 2728
e364ad06 2729 if (parse_pid(value, &pid) < 0)
66870f90 2730 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
a16e1123 2731 else
5925dd3c 2732 service_set_main_pid(s, (pid_t) pid);
a16e1123
LP		 2733 } else if (streq(key, "main-pid-known")) {
2734 int b;
2735
117dcc57
ZJS		 2736 b = parse_boolean(value);
2737 if (b < 0)
66870f90 2738 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
a16e1123
LP		 2739 else
2740 s->main_pid_known = b;
3a2776bc
LP		 2741 } else if (streq(key, "status-text")) {
2742 char *t;
2743
117dcc57
ZJS		 2744 t = strdup(value);
2745 if (!t)
2746 log_oom();
2747 else {
3a2776bc
LP		 2748 free(s->status_text);
2749 s->status_text = t;
2750 }
2751
a16e1123
LP		 2752 } else if (streq(key, "control-command")) {
2753 ServiceExecCommand id;
2754
117dcc57
ZJS		 2755 id = service_exec_command_from_string(value);
2756 if (id < 0)
66870f90 2757 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
a16e1123
LP		 2758 else {
2759 s->control_command_id = id;
2760 s->control_command = s->exec_command[id];
2761 }
2762 } else if (streq(key, "socket-fd")) {
2763 int fd;
2764
2765 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
66870f90 2766 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
a16e1123
LP		 2767 else {
2768
2769 if (s->socket_fd >= 0)
2770 close_nointr_nofail(s->socket_fd);
2771 s->socket_fd = fdset_remove(fds, fd);
2772 }
ecdbca40
LP		 2773 } else if (streq(key, "main-exec-status-pid")) {
2774 pid_t pid;
2775
e364ad06 2776 if (parse_pid(value, &pid) < 0)
66870f90 2777 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
ecdbca40
LP		 2778 else
2779 s->main_exec_status.pid = pid;
2780 } else if (streq(key, "main-exec-status-code")) {
2781 int i;
2782
e364ad06 2783 if (safe_atoi(value, &i) < 0)
66870f90 2784 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
ecdbca40
LP		 2785 else
2786 s->main_exec_status.code = i;
2787 } else if (streq(key, "main-exec-status-status")) {
2788 int i;
2789
e364ad06 2790 if (safe_atoi(value, &i) < 0)
66870f90 2791 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
ecdbca40
LP		 2792 else
2793 s->main_exec_status.status = i;
799fd0fd
LP		 2794 } else if (streq(key, "main-exec-status-start"))
2795 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2796 else if (streq(key, "main-exec-status-exit"))
2797 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
a6927d7f
MO		 2798 else if (streq(key, "watchdog-timestamp"))
2799 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
c17ec25e
MS		 2800 else if (streq(key, "tmp-dir")) {
2801 char *t;
2802
2803 t = strdup(value);
2804 if (!t)
2805 return log_oom();
2806
2807 s->exec_context.tmp_dir = t;
2808 } else if (streq(key, "var-tmp-dir")) {
2809 char *t;
2810
2811 t = strdup(value);
2812 if (!t)
2813 return log_oom();
2814
2815 s->exec_context.var_tmp_dir = t;
2816 } else
66870f90 2817 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
a16e1123
LP		 2818
2819 return 0;
2820}
2821
44a6b1b6 2822_pure_ static UnitActiveState service_active_state(Unit *u) {
e056b01d
LP		 2823 const UnitActiveState *table;
2824
87f0e418 2825 assert(u);
5cb5a6ff 2826
e056b01d
LP		 2827 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2828
2829 return table[SERVICE(u)->state];
034c6ed7
LP		 2830}
2831
10a94420
LP		 2832static const char *service_sub_state_to_string(Unit *u) {
2833 assert(u);
2834
2835 return service_state_to_string(SERVICE(u)->state);
2836}
2837
701cc384
LP		 2838static bool service_check_gc(Unit *u) {
2839 Service *s = SERVICE(u);
2840
2841 assert(s);
2842
6d55002a
LP		 2843 /* Never clean up services that still have a process around,
2844 * even if the service is formally dead. */
2845 if (cgroup_good(s) > 0 ||
2846 main_pid_good(s) > 0 ||
2847 control_pid_good(s) > 0)
2848 return true;
2849
2850#ifdef HAVE_SYSV_COMPAT
1b64d026 2851 if (s->is_sysv)
6d55002a 2852 return true;
07459bb6 2853#endif
701cc384 2854
6d55002a
LP		 2855 return false;
2856}
2857
44a6b1b6 2858_pure_ static bool service_check_snapshot(Unit *u) {
701cc384
LP		 2859 Service *s = SERVICE(u);
2860
2861 assert(s);
2862
2863 return !s->got_socket_fd;
2864}
2865
3a111838
MS		 2866static int service_retry_pid_file(Service *s) {
2867 int r;
2868
2869 assert(s->pid_file);
2870 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2871
2872 r = service_load_pid_file(s, false);
2873 if (r < 0)
2874 return r;
2875
2876 service_unwatch_pid_file(s);
2877
f42806df 2878 service_enter_running(s, SERVICE_SUCCESS);
3a111838
MS		 2879 return 0;
2880}
2881
2882static int service_watch_pid_file(Service *s) {
2883 int r;
2884
66870f90
ZJS		 2885 log_debug_unit(UNIT(s)->id,
2886 "Setting watch for %s's PID file %s",
2887 UNIT(s)->id, s->pid_file_pathspec->path);
57020a3a 2888 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
3a111838
MS		 2889 if (r < 0)
2890 goto fail;
2891
2892 /* the pidfile might have appeared just before we set the watch */
bc41f93e
ZJS		 2893 log_debug_unit(UNIT(s)->id,
2894 "Trying to read %s's PID file %s in case it changed",
2895 UNIT(s)->id, s->pid_file_pathspec->path);
3a111838
MS		 2896 service_retry_pid_file(s);
2897
2898 return 0;
2899fail:
66870f90
ZJS		 2900 log_error_unit(UNIT(s)->id,
2901 "Failed to set a watch for %s's PID file %s: %s",
2902 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
3a111838
MS		 2903 service_unwatch_pid_file(s);
2904 return r;
2905}
2906
2907static int service_demand_pid_file(Service *s) {
2908 PathSpec *ps;
2909
2910 assert(s->pid_file);
2911 assert(!s->pid_file_pathspec);
2912
2913 ps = new0(PathSpec, 1);
2914 if (!ps)
2915 return -ENOMEM;
2916
2917 ps->path = strdup(s->pid_file);
2918 if (!ps->path) {
2919 free(ps);
2920 return -ENOMEM;
2921 }
2922
2923 path_kill_slashes(ps->path);
2924
2925 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2926 * keep their PID file open all the time. */
2927 ps->type = PATH_MODIFIED;
2928 ps->inotify_fd = -1;
2929
2930 s->pid_file_pathspec = ps;
2931
2932 return service_watch_pid_file(s);
2933}
2934
2935static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2936 Service *s = SERVICE(u);
2937
2938 assert(s);
2939 assert(fd >= 0);
2940 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2941 assert(s->pid_file_pathspec);
57020a3a 2942 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3a111838 2943
66870f90 2944 log_debug_unit(u->id, "inotify event for %s", u->id);
3a111838 2945
57020a3a 2946 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
3a111838
MS		 2947 goto fail;
2948
2949 if (service_retry_pid_file(s) == 0)
2950 return;
2951
2952 if (service_watch_pid_file(s) < 0)
2953 goto fail;
2954
2955 return;
2956fail:
2957 service_unwatch_pid_file(s);
f42806df 2958 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 2959}
2960
87f0e418
LP		 2961static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2962 Service *s = SERVICE(u);
f42806df 2963 ServiceResult f;
5cb5a6ff
LP		 2964
2965 assert(s);
034c6ed7
LP		 2966 assert(pid >= 0);
2967
96342de6
LN		 2968 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2969 is_clean_exit_lsb(code, status, &s->success_status))
f42806df
LP		 2970 f = SERVICE_SUCCESS;
2971 else if (code == CLD_EXITED)
2972 f = SERVICE_FAILURE_EXIT_CODE;
2973 else if (code == CLD_KILLED)
2974 f = SERVICE_FAILURE_SIGNAL;
2975 else if (code == CLD_DUMPED)
2976 f = SERVICE_FAILURE_CORE_DUMP;
d06dacd0 2977 else
cfc4eb4c 2978 assert_not_reached("Unknown code");
034c6ed7
LP		 2979
2980 if (s->main_pid == pid) {
db01f8b3
MS		 2981 /* Forking services may occasionally move to a new PID.
2982 * As long as they update the PID file before exiting the old
2983 * PID, they're fine. */
5375410b 2984 if (service_load_pid_file(s, false) == 0)
db01f8b3 2985 return;
034c6ed7 2986
034c6ed7 2987 s->main_pid = 0;
6ea832a2 2988 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
034c6ed7 2989
867b3b7d 2990 if (s->main_command) {
fbeefb45
LP		 2991 /* If this is not a forking service than the
2992 * main process got started and hence we copy
2993 * the exit status so that it is recorded both
2994 * as main and as control process exit
2995 * status */
2996
867b3b7d 2997 s->main_command->exec_status = s->main_exec_status;
b708e7ce 2998
867b3b7d 2999 if (s->main_command->ignore)
f42806df 3000 f = SERVICE_SUCCESS;
fbeefb45
LP		 3001 } else if (s->exec_command[SERVICE_EXEC_START]) {
3002
3003 /* If this is a forked process, then we should
3004 * ignore the return value if this was
3005 * configured for the starter process */
3006
3007 if (s->exec_command[SERVICE_EXEC_START]->ignore)
3008 f = SERVICE_SUCCESS;
034c6ed7
LP		 3009 }
3010
bbc9006e
MT		 3011 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
3012 u->id,
23635a85
ZJS		 3013 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
3014 u->id, sigchld_code_to_string(code), status,
3015 strna(code == CLD_EXITED
3016 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3017 : signal_to_string(status)),
23635a85
ZJS		 3018 "EXIT_CODE=%s", sigchld_code_to_string(code),
3019 "EXIT_STATUS=%i", status,
3020 NULL);
f42806df
LP		 3021
3022 if (f != SERVICE_SUCCESS)
3023 s->result = f;
034c6ed7 3024
867b3b7d
LP		 3025 if (s->main_command &&
3026 s->main_command->command_next &&
f42806df 3027 f == SERVICE_SUCCESS) {
034c6ed7 3028
34e9ba66
LP		 3029 /* There is another command to *
3030 * execute, so let's do that. */
034c6ed7 3031
66870f90
ZJS		 3032 log_debug_unit(u->id,
3033 "%s running next main command for state %s",
3034 u->id, service_state_to_string(s->state));
f42806df 3035 service_run_next_main(s);
034c6ed7 3036
34e9ba66
LP		 3037 } else {
3038
3039 /* The service exited, so the service is officially
3040 * gone. */
867b3b7d 3041 s->main_command = NULL;
34e9ba66
LP		 3042
3043 switch (s->state) {
3044
3045 case SERVICE_START_POST:
3046 case SERVICE_RELOAD:
3047 case SERVICE_STOP:
3048 /* Need to wait until the operation is
3049 * done */
c4653a4d 3050 break;
7d55e835 3051
34e9ba66
LP		 3052 case SERVICE_START:
3053 if (s->type == SERVICE_ONESHOT) {
3054 /* This was our main goal, so let's go on */
f42806df 3055 if (f == SERVICE_SUCCESS)
34e9ba66
LP		 3056 service_enter_start_post(s);
3057 else
f42806df 3058 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
34e9ba66 3059 break;
34e9ba66 3060 }
034c6ed7 3061
bfba3256
LP		 3062 /* Fall through */
3063
34e9ba66 3064 case SERVICE_RUNNING:
f42806df 3065 service_enter_running(s, f);
34e9ba66 3066 break;
034c6ed7 3067
34e9ba66
LP		 3068 case SERVICE_STOP_SIGTERM:
3069 case SERVICE_STOP_SIGKILL:
5cb5a6ff 3070
34e9ba66 3071 if (!control_pid_good(s))
f42806df 3072 service_enter_stop_post(s, f);
5cb5a6ff 3073
34e9ba66
LP		 3074 /* If there is still a control process, wait for that first */
3075 break;
3076
3077 default:
3078 assert_not_reached("Uh, main process died at wrong time.");
3079 }
034c6ed7 3080 }
5cb5a6ff 3081
034c6ed7 3082 } else if (s->control_pid == pid) {
34e9ba66
LP		 3083 s->control_pid = 0;
3084
b708e7ce 3085 if (s->control_command) {
117dcc57
ZJS		 3086 exec_status_exit(&s->control_command->exec_status,
3087 &s->exec_context, pid, code, status);
a16e1123 3088
b708e7ce 3089 if (s->control_command->ignore)
f42806df 3090 f = SERVICE_SUCCESS;
b708e7ce
LP		 3091 }
3092
66870f90
ZJS		 3093 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3094 "%s: control process exited, code=%s status=%i",
3095 u->id, sigchld_code_to_string(code), status);
f42806df
LP		 3096
3097 if (f != SERVICE_SUCCESS)
3098 s->result = f;
034c6ed7 3099
88f3e0c9
LP		 3100 /* Immediately get rid of the cgroup, so that the
3101 * kernel doesn't delay the cgroup empty messages for
3102 * the service cgroup any longer than necessary */
4ad49000 3103 service_kill_control_processes(s);
88f3e0c9 3104
34e9ba66
LP		 3105 if (s->control_command &&
3106 s->control_command->command_next &&
f42806df 3107 f == SERVICE_SUCCESS) {
034c6ed7
LP		 3108
3109 /* There is another command to *
3110 * execute, so let's do that. */
3111
66870f90
ZJS		 3112 log_debug_unit(u->id,
3113 "%s running next control command for state %s",
3114 u->id, service_state_to_string(s->state));
f42806df 3115 service_run_next_control(s);
034c6ed7 3116
80876c20 3117 } else {
034c6ed7
LP		 3118 /* No further commands for this step, so let's
3119 * figure out what to do next */
3120
a16e1123
LP		 3121 s->control_command = NULL;
3122 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3123
66870f90
ZJS		 3124 log_debug_unit(u->id,
3125 "%s got final SIGCHLD for state %s",
3126 u->id, service_state_to_string(s->state));
bd982a8b 3127
034c6ed7
LP		 3128 switch (s->state) {
3129
3130 case SERVICE_START_PRE:
f42806df 3131 if (f == SERVICE_SUCCESS)
034c6ed7
LP		 3132 service_enter_start(s);
3133 else
f42806df 3134 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
034c6ed7
LP		 3135 break;
3136
3137 case SERVICE_START:
bfba3256
LP		 3138 if (s->type != SERVICE_FORKING)
3139 /* Maybe spurious event due to a reload that changed the type? */
3140 break;
034c6ed7 3141
f42806df
LP		 3142 if (f != SERVICE_SUCCESS) {
3143 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3a111838
MS		 3144 break;
3145 }
034c6ed7 3146
3a111838 3147 if (s->pid_file) {
f42806df
LP		 3148 bool has_start_post;
3149 int r;
3150
3a111838
MS		 3151 /* Let's try to load the pid file here if we can.
3152 * The PID file might actually be created by a START_POST
3153 * script. In that case don't worry if the loading fails. */
f42806df
LP		 3154
3155 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3156 r = service_load_pid_file(s, !has_start_post);
3a111838
MS		 3157 if (!has_start_post && r < 0) {
3158 r = service_demand_pid_file(s);
3159 if (r < 0 || !cgroup_good(s))
f42806df 3160 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3161 break;
3162 }
034c6ed7 3163 } else
3a111838 3164 service_search_main_pid(s);
034c6ed7 3165
3a111838 3166 service_enter_start_post(s);
034c6ed7
LP		 3167 break;
3168
3169 case SERVICE_START_POST:
f42806df
LP		 3170 if (f != SERVICE_SUCCESS) {
3171 service_enter_stop(s, f);
2096e009 3172 break;
034c6ed7
LP		 3173 }
3174
2096e009 3175 if (s->pid_file) {
f42806df
LP		 3176 int r;
3177
3178 r = service_load_pid_file(s, true);
2096e009
MS		 3179 if (r < 0) {
3180 r = service_demand_pid_file(s);
3181 if (r < 0 || !cgroup_good(s))
f42806df 3182 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2096e009
MS		 3183 break;
3184 }
3185 } else
3186 service_search_main_pid(s);
3187
f42806df 3188 service_enter_running(s, SERVICE_SUCCESS);
3185a36b 3189 break;
034c6ed7
LP		 3190
3191 case SERVICE_RELOAD:
f42806df 3192 if (f == SERVICE_SUCCESS) {
5375410b 3193 service_load_pid_file(s, true);
3185a36b
LP		 3194 service_search_main_pid(s);
3195 }
3196
f42806df
LP		 3197 s->reload_result = f;
3198 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 3199 break;
3200
3201 case SERVICE_STOP:
f42806df 3202 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
034c6ed7
LP		 3203 break;
3204
3205 case SERVICE_STOP_SIGTERM:
3206 case SERVICE_STOP_SIGKILL:
3207 if (main_pid_good(s) <= 0)
f42806df 3208 service_enter_stop_post(s, f);
034c6ed7
LP		 3209
3210 /* If there is still a service
3211 * process around, wait until
3212 * that one quit, too */
3213 break;
3214
3215 case SERVICE_STOP_POST:
3216 case SERVICE_FINAL_SIGTERM:
3217 case SERVICE_FINAL_SIGKILL:
f42806df 3218 service_enter_dead(s, f, true);
034c6ed7
LP		 3219 break;
3220
3221 default:
3222 assert_not_reached("Uh, control process died at wrong time.");
3223 }
3224 }
8c47c732 3225 }
c4e2ceae
LP		 3226
3227 /* Notify clients about changed exit status */
3228 unit_add_to_dbus_queue(u);
034c6ed7
LP		 3229}
3230
acbb0225 3231static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
87f0e418 3232 Service *s = SERVICE(u);
034c6ed7
LP		 3233
3234 assert(s);
3235 assert(elapsed == 1);
3236
bb242b7b
MO		 3237 if (w == &s->watchdog_watch) {
3238 service_handle_watchdog(s);
3239 return;
3240 }
3241
acbb0225 3242 assert(w == &s->timer_watch);
034c6ed7
LP		 3243
3244 switch (s->state) {
3245
3246 case SERVICE_START_PRE:
3247 case SERVICE_START:
66870f90
ZJS		 3248 log_warning_unit(u->id,
3249 "%s operation timed out. Terminating.", u->id);
f42806df 3250 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
80876c20
LP		 3251 break;
3252
034c6ed7 3253 case SERVICE_START_POST:
66870f90
ZJS		 3254 log_warning_unit(u->id,
3255 "%s operation timed out. Stopping.", u->id);
f42806df 3256 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3257 break;
3258
e2f3b44c 3259 case SERVICE_RELOAD:
66870f90
ZJS		 3260 log_warning_unit(u->id,
3261 "%s operation timed out. Stopping.", u->id);
f42806df
LP		 3262 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3263 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c
LP		 3264 break;
3265
034c6ed7 3266 case SERVICE_STOP:
66870f90
ZJS		 3267 log_warning_unit(u->id,
3268 "%s stopping timed out. Terminating.", u->id);
f42806df 3269 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3270 break;
3271
3272 case SERVICE_STOP_SIGTERM:
4819ff03 3273 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3274 log_warning_unit(u->id,
3275 "%s stopping timed out. Killing.", u->id);
f42806df 3276 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3277 } else {
66870f90
ZJS		 3278 log_warning_unit(u->id,
3279 "%s stopping timed out. Skipping SIGKILL.", u->id);
f42806df 3280 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
ba035df2
LP		 3281 }
3282
034c6ed7
LP		 3283 break;
3284
3285 case SERVICE_STOP_SIGKILL:
35b8ca3a 3286 /* Uh, we sent a SIGKILL and it is still not gone?
034c6ed7
LP		 3287 * Must be something we cannot kill, so let's just be
3288 * weirded out and continue */
3289
66870f90
ZJS		 3290 log_warning_unit(u->id,
3291 "%s still around after SIGKILL. Ignoring.", u->id);
f42806df 3292 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3293 break;
3294
3295 case SERVICE_STOP_POST:
66870f90
ZJS		 3296 log_warning_unit(u->id,
3297 "%s stopping timed out (2). Terminating.", u->id);
f42806df 3298 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3299 break;
3300
3301 case SERVICE_FINAL_SIGTERM:
4819ff03 3302 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3303 log_warning_unit(u->id,
3304 "%s stopping timed out (2). Killing.", u->id);
f42806df 3305 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3306 } else {
66870f90
ZJS		 3307 log_warning_unit(u->id,
3308 "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3309 u->id);
f42806df 3310 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
ba035df2
LP		 3311 }
3312
034c6ed7
LP		 3313 break;
3314
3315 case SERVICE_FINAL_SIGKILL:
66870f90
ZJS		 3316 log_warning_unit(u->id,
3317 "%s still around after SIGKILL (2). Entering failed mode.", u->id);
f42806df 3318 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
034c6ed7
LP		 3319 break;
3320
3321 case SERVICE_AUTO_RESTART:
66870f90
ZJS		 3322 log_info_unit(u->id,
3323 "%s holdoff time over, scheduling restart.", u->id);
034c6ed7
LP		 3324 service_enter_restart(s);
3325 break;
3326
3327 default:
3328 assert_not_reached("Timeout at wrong time.");
3329 }
5cb5a6ff
LP		 3330}
3331
4ad49000 3332static void service_notify_cgroup_empty_event(Unit *u) {
8e274523
LP		 3333 Service *s = SERVICE(u);
3334
3335 assert(u);
3336
6c12b52e 3337 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
8e274523
LP		 3338
3339 switch (s->state) {
3340
3341 /* Waiting for SIGCHLD is usually more interesting,
3342 * because it includes return codes/signals. Which is
3343 * why we ignore the cgroup events for most cases,
3344 * except when we don't know pid which to expect the
3345 * SIGCHLD for. */
3346
3a111838
MS		 3347 case SERVICE_START:
3348 case SERVICE_START_POST:
3349 /* If we were hoping for the daemon to write its PID file,
3350 * we can give up now. */
3351 if (s->pid_file_pathspec) {
66870f90
ZJS		 3352 log_warning_unit(u->id,
3353 "%s never wrote its PID file. Failing.", UNIT(s)->id);
3a111838
MS		 3354 service_unwatch_pid_file(s);
3355 if (s->state == SERVICE_START)
f42806df 3356 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838 3357 else
f42806df 3358 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3359 }
3360 break;
3361
8e274523 3362 case SERVICE_RUNNING:
f42806df
LP		 3363 /* service_enter_running() will figure out what to do */
3364 service_enter_running(s, SERVICE_SUCCESS);
8e274523
LP		 3365 break;
3366
28708d8a
LP		 3367 case SERVICE_STOP_SIGTERM:
3368 case SERVICE_STOP_SIGKILL:
6dfa5494 3369
28708d8a 3370 if (main_pid_good(s) <= 0 && !control_pid_good(s))
f42806df 3371 service_enter_stop_post(s, SERVICE_SUCCESS);
28708d8a
LP		 3372
3373 break;
3374
7f97f0fe
LP		 3375 case SERVICE_FINAL_SIGTERM:
3376 case SERVICE_FINAL_SIGKILL:
3377 if (main_pid_good(s) <= 0 && !control_pid_good(s))
e201a038 3378 service_enter_dead(s, SERVICE_SUCCESS, true);
7f97f0fe
LP		 3379
3380 break;
3381
8e274523
LP		 3382 default:
3383 ;
3384 }
3385}
3386
c952c6ec 3387static void service_notify_message(Unit *u, pid_t pid, char **tags) {
8c47c732
LP		 3388 Service *s = SERVICE(u);
3389 const char *e;
3390
3391 assert(u);
3392
c952c6ec 3393 if (s->notify_access == NOTIFY_NONE) {
66870f90
ZJS		 3394 log_warning_unit(u->id,
3395 "%s: Got notification message from PID %lu, but reception is disabled.",
3396 u->id, (unsigned long) pid);
c952c6ec
LP		 3397 return;
3398 }
3399
3400 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
66870f90
ZJS		 3401 log_warning_unit(u->id,
3402 "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3403 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
c952c6ec
LP		 3404 return;
3405 }
3406
66870f90
ZJS		 3407 log_debug_unit(u->id,
3408 "%s: Got message", u->id);
8c47c732
LP		 3409
3410 /* Interpret MAINPID= */
3411 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3412 (s->state == SERVICE_START ||
3413 s->state == SERVICE_START_POST ||
3414 s->state == SERVICE_RUNNING ||
3415 s->state == SERVICE_RELOAD)) {
8c47c732 3416
5925dd3c 3417 if (parse_pid(e + 8, &pid) < 0)
66870f90
ZJS		 3418 log_warning_unit(u->id,
3419 "Failed to parse notification message %s", e);
8c47c732 3420 else {
66870f90
ZJS		 3421 log_debug_unit(u->id,
3422 "%s: got %s", u->id, e);
5925dd3c 3423 service_set_main_pid(s, pid);
8c47c732
LP		 3424 }
3425 }
3426
3427 /* Interpret READY= */
3428 if (s->type == SERVICE_NOTIFY &&
3429 s->state == SERVICE_START &&
3430 strv_find(tags, "READY=1")) {
66870f90
ZJS		 3431 log_debug_unit(u->id,
3432 "%s: got READY=1", u->id);
8c47c732
LP		 3433
3434 service_enter_start_post(s);
3435 }
3436
3437 /* Interpret STATUS= */
7f110ff9
LP		 3438 e = strv_find_prefix(tags, "STATUS=");
3439 if (e) {
8c47c732
LP		 3440 char *t;
3441
3a2776bc 3442 if (e[7]) {
7f110ff9
LP		 3443
3444 if (!utf8_is_valid(e+7)) {
66870f90
ZJS		 3445 log_warning_unit(u->id,
3446 "Status message in notification is not UTF-8 clean.");
7f110ff9
LP		 3447 return;
3448 }
3449
3450 t = strdup(e+7);
3451 if (!t) {
66870f90
ZJS		 3452 log_error_unit(u->id,
3453 "Failed to allocate string.");
3a2776bc
LP		 3454 return;
3455 }
3456
66870f90
ZJS		 3457 log_debug_unit(u->id,
3458 "%s: got %s", u->id, e);
8c47c732 3459
3a2776bc
LP		 3460 free(s->status_text);
3461 s->status_text = t;
3462 } else {
3463 free(s->status_text);
3464 s->status_text = NULL;
3465 }
8c47c732 3466
8c47c732 3467 }
a6927d7f 3468 if (strv_find(tags, "WATCHDOG=1")) {
66870f90
ZJS		 3469 log_debug_unit(u->id,
3470 "%s: got WATCHDOG=1", u->id);
90527fbb
MO		 3471 if (dual_timestamp_is_set(&s->watchdog_timestamp))
3472 service_reset_watchdog(s);
a6927d7f 3473 }
c4e2ceae
LP		 3474
3475 /* Notify clients about changed status or main pid */
3476 unit_add_to_dbus_queue(u);
8c47c732
LP		 3477}
3478
07459bb6 3479#ifdef HAVE_SYSV_COMPAT
de3910a3 3480
2c4104f0 3481static int service_enumerate(Manager *m) {
2c4104f0
LP		 3482 char **p;
3483 unsigned i;
7fd1b19b
HH		 3484 _cleanup_closedir_ DIR *d = NULL;
3485 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
b92bea5d 3486 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
7fd1b19b 3487 _cleanup_set_free_ Set *shutdown_services = NULL;
c68364b7
LP		 3488 Unit *service;
3489 Iterator j;
2c4104f0
LP		 3490 int r;
3491
3492 assert(m);
3493
67445f4e 3494 if (m->running_as != SYSTEMD_SYSTEM)
b1bc08e5
LP		 3495 return 0;
3496
84e3543e 3497 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
09cd1ab1 3498 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
2c4104f0
LP		 3499 struct dirent *de;
3500
3501 free(path);
b7def684 3502 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
70132bd0 3503 if (!path) {
2c4104f0
LP		 3504 r = -ENOMEM;
3505 goto finish;
3506 }
3507
3508 if (d)
3509 closedir(d);
3510
117dcc57
ZJS		 3511 d = opendir(path);
3512 if (!d) {
2c4104f0 3513 if (errno != ENOENT)
117dcc57 3514 log_warning("opendir(%s) failed: %s", path, strerror(errno));
2c4104f0
LP		 3515
3516 continue;
3517 }
3518
3519 while ((de = readdir(d))) {
db06e3b6 3520 int a, b;
2c4104f0
LP		 3521
3522 if (ignore_file(de->d_name))
3523 continue;
3524
3525 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3526 continue;
3527
3528 if (strlen(de->d_name) < 4)
3529 continue;
3530
db06e3b6
LP		 3531 a = undecchar(de->d_name[1]);
3532 b = undecchar(de->d_name[2]);
3533
3534 if (a < 0 || b < 0)
3535 continue;
3536
2c4104f0 3537 free(fpath);
b7def684 3538 fpath = strjoin(path, "/", de->d_name, NULL);
8ea913b2 3539 if (!fpath) {
2c4104f0
LP		 3540 r = -ENOMEM;
3541 goto finish;
3542 }
3543
3544 if (access(fpath, X_OK) < 0) {
3545
3546 if (errno != ENOENT)
3547 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3548
3549 continue;
3550 }
3551
3552 free(name);
117dcc57
ZJS		 3553 name = sysv_translate_name(de->d_name + 3);
3554 if (!name) {
3555 r = log_oom();
2c4104f0
LP		 3556 goto finish;
3557 }
3558
66870f90
ZJS		 3559 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3560 if (r < 0) {
fbe9f3a9
LP		 3561 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3562 continue;
3563 }
2c4104f0 3564
c68364b7
LP		 3565 if (de->d_name[0] == 'S') {
3566
3cdebc21 3567 if (rcnd_table[i].type == RUNLEVEL_UP) {
ea87ca5a
LP		 3568 SERVICE(service)->sysv_start_priority_from_rcnd =
3569 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
db06e3b6 3570
c68364b7 3571 SERVICE(service)->sysv_enabled = true;
f73d93a4 3572 }
db06e3b6 3573
117dcc57
ZJS		 3574 r = set_ensure_allocated(&runlevel_services[i],
3575 trivial_hash_func, trivial_compare_func);
3576 if (r < 0)
c68364b7 3577 goto finish;
2c4104f0 3578
117dcc57
ZJS		 3579 r = set_put(runlevel_services[i], service);
3580 if (r < 0)
2c4104f0 3581 goto finish;
23a177ef 3582
fc5df99e 3583 } else if (de->d_name[0] == 'K' &&
3cdebc21 3584 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
6542952f 3585
117dcc57
ZJS		 3586 r = set_ensure_allocated(&shutdown_services,
3587 trivial_hash_func, trivial_compare_func);
3588 if (r < 0)
c68364b7
LP		 3589 goto finish;
3590
117dcc57
ZJS		 3591 r = set_put(shutdown_services, service);
3592 if (r < 0)
2c4104f0
LP		 3593 goto finish;
3594 }
3595 }
3596 }
3597
c68364b7
LP		 3598 /* Now we loaded all stubs and are aware of the lowest
3599 start-up priority for all services, not let's actually load
3600 the services, this will also tell us which services are
3601 actually native now */
3602 manager_dispatch_load_queue(m);
3603
3604 /* If this is a native service, rely on native ways to pull in
3605 * a service, don't pull it in via sysv rcN.d links. */
3606 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3607 SET_FOREACH(service, runlevel_services[i], j) {
3608 service = unit_follow_merge(service);
3609
ac155bb8 3610 if (service->fragment_path)
c68364b7
LP		 3611 continue;
3612
117dcc57
ZJS		 3613 r = unit_add_two_dependencies_by_name_inverse(
3614 service, UNIT_AFTER, UNIT_WANTS,
3615 rcnd_table[i].target, NULL, true);
3616 if (r < 0)
c68364b7
LP		 3617 goto finish;
3618 }
3619
3620 /* We honour K links only for halt/reboot. For the normal
3621 * runlevels we assume the stop jobs will be implicitly added
35b8ca3a 3622 * by the core logic. Also, we don't really distinguish here
c68364b7 3623 * between the runlevels 0 and 6 and just add them to the
3cdebc21 3624 * special shutdown target. */
c68364b7
LP		 3625 SET_FOREACH(service, shutdown_services, j) {
3626 service = unit_follow_merge(service);
3627
ac155bb8 3628 if (service->fragment_path)
c68364b7
LP		 3629 continue;
3630
117dcc57
ZJS		 3631 r = unit_add_two_dependencies_by_name(
3632 service, UNIT_BEFORE, UNIT_CONFLICTS,
3633 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3634 if (r < 0)
c68364b7
LP		 3635 goto finish;
3636 }
3637
2c4104f0
LP		 3638 r = 0;
3639
3640finish:
fbe9f3a9 3641
c68364b7
LP		 3642 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3643 set_free(runlevel_services[i]);
2c4104f0
LP		 3644
3645 return r;
3646}
07459bb6 3647#endif
2c4104f0 3648
05e343b7
LP		 3649static void service_bus_name_owner_change(
3650 Unit *u,
3651 const char *name,
3652 const char *old_owner,
3653 const char *new_owner) {
3654
3655 Service *s = SERVICE(u);
3656
3657 assert(s);
3658 assert(name);
3659
3660 assert(streq(s->bus_name, name));
3661 assert(old_owner || new_owner);
3662
3663 if (old_owner && new_owner)
66870f90
ZJS		 3664 log_debug_unit(u->id,
3665 "%s's D-Bus name %s changed owner from %s to %s",
3666 u->id, name, old_owner, new_owner);
05e343b7 3667 else if (old_owner)
66870f90
ZJS		 3668 log_debug_unit(u->id,
3669 "%s's D-Bus name %s no longer registered by %s",
3670 u->id, name, old_owner);
05e343b7 3671 else
66870f90
ZJS		 3672 log_debug_unit(u->id,
3673 "%s's D-Bus name %s now registered by %s",
3674 u->id, name, new_owner);
05e343b7
LP		 3675
3676 s->bus_name_good = !!new_owner;
3677
3678 if (s->type == SERVICE_DBUS) {
3679
3680 /* service_enter_running() will figure out what to
3681 * do */
3682 if (s->state == SERVICE_RUNNING)
f42806df 3683 service_enter_running(s, SERVICE_SUCCESS);
05e343b7
LP		 3684 else if (s->state == SERVICE_START && new_owner)
3685 service_enter_start_post(s);
3686
3687 } else if (new_owner &&
3688 s->main_pid <= 0 &&
3689 (s->state == SERVICE_START ||
3690 s->state == SERVICE_START_POST ||
3691 s->state == SERVICE_RUNNING ||
3692 s->state == SERVICE_RELOAD)) {
3693
3694 /* Try to acquire PID from bus service */
66870f90
ZJS		 3695 log_debug_unit(u->id,
3696 "Trying to acquire PID from D-Bus name...");
05e343b7 3697
ac155bb8 3698 bus_query_pid(u->manager, name);
05e343b7
LP		 3699 }
3700}
3701
3702static void service_bus_query_pid_done(
3703 Unit *u,
3704 const char *name,
3705 pid_t pid) {
3706
3707 Service *s = SERVICE(u);
3708
3709 assert(s);
3710 assert(name);
3711
66870f90
ZJS		 3712 log_debug_unit(u->id,
3713 "%s's D-Bus name %s is now owned by process %u",
3714 u->id, name, (unsigned) pid);
05e343b7
LP		 3715
3716 if (s->main_pid <= 0 &&
3717 (s->state == SERVICE_START ||
3718 s->state == SERVICE_START_POST ||
3719 s->state == SERVICE_RUNNING ||
3720 s->state == SERVICE_RELOAD))
5925dd3c 3721 service_set_main_pid(s, pid);
05e343b7
LP		 3722}
3723
6cf6bbc2 3724int service_set_socket_fd(Service *s, int fd, Socket *sock) {
57020a3a 3725
4f2d528d
LP		 3726 assert(s);
3727 assert(fd >= 0);
3728
3729 /* This is called by the socket code when instantiating a new
3730 * service for a stream socket and the socket needs to be
3731 * configured. */
3732
1124fe6f 3733 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 3734 return -EINVAL;
3735
3736 if (s->socket_fd >= 0)
3737 return -EBUSY;
3738
3739 if (s->state != SERVICE_DEAD)
3740 return -EAGAIN;
3741
3742 s->socket_fd = fd;
701cc384 3743 s->got_socket_fd = true;
6cf6bbc2 3744
57020a3a
LP		 3745 unit_ref_set(&s->accept_socket, UNIT(sock));
3746
3747 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
4f2d528d
LP		 3748}
3749
fdf20a31 3750static void service_reset_failed(Unit *u) {
5632e374
LP		 3751 Service *s = SERVICE(u);
3752
3753 assert(s);
3754
fdf20a31 3755 if (s->state == SERVICE_FAILED)
5632e374
LP		 3756 service_set_state(s, SERVICE_DEAD);
3757
f42806df
LP		 3758 s->result = SERVICE_SUCCESS;
3759 s->reload_result = SERVICE_SUCCESS;
451b34cc
LP		 3760
3761 RATELIMIT_RESET(s->start_limit);
5632e374
LP		 3762}
3763
c74f17d9 3764static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
8a0867d6 3765 Service *s = SERVICE(u);
41efeaec 3766
814cc562 3767 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
8a0867d6
LP		 3768}
3769
94f04347
LP		 3770static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3771 [SERVICE_DEAD] = "dead",
3772 [SERVICE_START_PRE] = "start-pre",
3773 [SERVICE_START] = "start",
3774 [SERVICE_START_POST] = "start-post",
3775 [SERVICE_RUNNING] = "running",
80876c20 3776 [SERVICE_EXITED] = "exited",
94f04347
LP		 3777 [SERVICE_RELOAD] = "reload",
3778 [SERVICE_STOP] = "stop",
3779 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3780 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3781 [SERVICE_STOP_POST] = "stop-post",
3782 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3783 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 3784 [SERVICE_FAILED] = "failed",
94f04347
LP		 3785 [SERVICE_AUTO_RESTART] = "auto-restart",
3786};
3787
3788DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3789
3790static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
525ee6f4
LP		 3791 [SERVICE_RESTART_NO] = "no",
3792 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
50caaedb
LP		 3793 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3794 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3795 [SERVICE_RESTART_ALWAYS] = "always"
94f04347
LP		 3796};
3797
3798DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3799
3800static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
94f04347 3801 [SERVICE_SIMPLE] = "simple",
0d624a78 3802 [SERVICE_FORKING] = "forking",
34e9ba66 3803 [SERVICE_ONESHOT] = "oneshot",
8c47c732 3804 [SERVICE_DBUS] = "dbus",
f2b68789
LP		 3805 [SERVICE_NOTIFY] = "notify",
3806 [SERVICE_IDLE] = "idle"
94f04347
LP		 3807};
3808
3809DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3810
e537352b 3811static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
94f04347
LP		 3812 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3813 [SERVICE_EXEC_START] = "ExecStart",
3814 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3815 [SERVICE_EXEC_RELOAD] = "ExecReload",
3816 [SERVICE_EXEC_STOP] = "ExecStop",
3817 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3818};
3819
3820DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3821
c952c6ec
LP		 3822static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3823 [NOTIFY_NONE] = "none",
3824 [NOTIFY_MAIN] = "main",
3825 [NOTIFY_ALL] = "all"
3826};
3827
3828DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3829
f42806df
LP		 3830static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3831 [SERVICE_SUCCESS] = "success",
3832 [SERVICE_FAILURE_RESOURCES] = "resources",
3833 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3834 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3835 [SERVICE_FAILURE_SIGNAL] = "signal",
bb242b7b 3836 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
8d1b002a
LP		 3837 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3838 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
f42806df
LP		 3839};
3840
3841DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3842
4b939747
MO		 3843static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3844 [SERVICE_START_LIMIT_NONE] = "none",
3845 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3846 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3847 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3848};
3849DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3850
87f0e418 3851const UnitVTable service_vtable = {
7d17cfbc 3852 .object_size = sizeof(Service),
3ef63c31 3853
f975e971
LP		 3854 .sections =
3855 "Unit\0"
3856 "Service\0"
3857 "Install\0",
5cb5a6ff 3858
4ad49000 3859 .private_section = "Service",
71645aca 3860 .exec_context_offset = offsetof(Service, exec_context),
4ad49000 3861 .cgroup_context_offset = offsetof(Service, cgroup_context),
71645aca 3862
034c6ed7
LP		 3863 .init = service_init,
3864 .done = service_done,
a16e1123
LP		 3865 .load = service_load,
3866
3867 .coldplug = service_coldplug,
034c6ed7 3868
5cb5a6ff
LP		 3869 .dump = service_dump,
3870
3871 .start = service_start,
3872 .stop = service_stop,
3873 .reload = service_reload,
3874
034c6ed7
LP		 3875 .can_reload = service_can_reload,
3876
8a0867d6
LP		 3877 .kill = service_kill,
3878
a16e1123
LP		 3879 .serialize = service_serialize,
3880 .deserialize_item = service_deserialize_item,
3881
5cb5a6ff 3882 .active_state = service_active_state,
10a94420 3883 .sub_state_to_string = service_sub_state_to_string,
5cb5a6ff 3884
701cc384
LP		 3885 .check_gc = service_check_gc,
3886 .check_snapshot = service_check_snapshot,
3887
034c6ed7
LP		 3888 .sigchld_event = service_sigchld_event,
3889 .timer_event = service_timer_event,
3a111838 3890 .fd_event = service_fd_event,
2c4104f0 3891
fdf20a31 3892 .reset_failed = service_reset_failed,
5632e374 3893
4ad49000 3894 .notify_cgroup_empty = service_notify_cgroup_empty_event,
8c47c732 3895 .notify_message = service_notify_message,
8e274523 3896
05e343b7
LP		 3897 .bus_name_owner_change = service_bus_name_owner_change,
3898 .bus_query_pid_done = service_bus_query_pid_done,
3899
c4e2ceae 3900 .bus_interface = "org.freedesktop.systemd1.Service",
4139c1b2 3901 .bus_message_handler = bus_service_message_handler,
c4e2ceae 3902 .bus_invalidating_properties = bus_service_invalidating_properties,
74c964d3
LP		 3903 .bus_set_property = bus_service_set_property,
3904 .bus_commit_properties = bus_service_commit_properties,
4139c1b2 3905
c2756a68
LP		 3906 .can_transient = true,
3907
07459bb6 3908#ifdef HAVE_SYSV_COMPAT
c6918296 3909 .enumerate = service_enumerate,
07459bb6 3910#endif
c6918296
MS		 3911 .status_message_formats = {
3912 .starting_stopping = {
3913 [0] = "Starting %s...",
3914 [1] = "Stopping %s...",
3915 },
3916 .finished_start_job = {
3917 [JOB_DONE] = "Started %s.",
3918 [JOB_FAILED] = "Failed to start %s.",
3919 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3920 [JOB_TIMEOUT] = "Timed out starting %s.",
3921 },
3922 .finished_stop_job = {
3923 [JOB_DONE] = "Stopped %s.",
3924 [JOB_FAILED] = "Stopped (with error) %s.",
3925 [JOB_TIMEOUT] = "Timed out stopping %s.",
3926 },
3927 },
5cb5a6ff 3928};
Unnamed repository; edit this file 'description' to name the repository.