]> 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
update TODO
[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
034c6ed7
LP		 1492static void service_set_state(Service *s, ServiceState state) {
1493 ServiceState old_state;
e056b01d 1494 const UnitActiveState *table;
5cb5a6ff
LP		 1495 assert(s);
1496
e056b01d
LP		 1497 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1498
034c6ed7 1499 old_state = s->state;
5cb5a6ff 1500 s->state = state;
034c6ed7 1501
3a111838
MS		 1502 service_unwatch_pid_file(s);
1503
034c6ed7
LP		 1504 if (state != SERVICE_START_PRE &&
1505 state != SERVICE_START &&
1506 state != SERVICE_START_POST &&
1507 state != SERVICE_RELOAD &&
1508 state != SERVICE_STOP &&
1509 state != SERVICE_STOP_SIGTERM &&
1510 state != SERVICE_STOP_SIGKILL &&
1511 state != SERVICE_STOP_POST &&
1512 state != SERVICE_FINAL_SIGTERM &&
1513 state != SERVICE_FINAL_SIGKILL &&
1514 state != SERVICE_AUTO_RESTART)
acbb0225 1515 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1516
7d55e835
LP		 1517 if (state != SERVICE_START &&
1518 state != SERVICE_START_POST &&
034c6ed7
LP		 1519 state != SERVICE_RUNNING &&
1520 state != SERVICE_RELOAD &&
1521 state != SERVICE_STOP &&
1522 state != SERVICE_STOP_SIGTERM &&
867b3b7d 1523 state != SERVICE_STOP_SIGKILL) {
5e94833f 1524 service_unwatch_main_pid(s);
867b3b7d
LP		 1525 s->main_command = NULL;
1526 }
034c6ed7
LP		 1527
1528 if (state != SERVICE_START_PRE &&
1529 state != SERVICE_START &&
1530 state != SERVICE_START_POST &&
1531 state != SERVICE_RELOAD &&
1532 state != SERVICE_STOP &&
1533 state != SERVICE_STOP_SIGTERM &&
1534 state != SERVICE_STOP_SIGKILL &&
1535 state != SERVICE_STOP_POST &&
1536 state != SERVICE_FINAL_SIGTERM &&
e537352b 1537 state != SERVICE_FINAL_SIGKILL) {
5e94833f 1538 service_unwatch_control_pid(s);
034c6ed7 1539 s->control_command = NULL;
a16e1123 1540 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
e537352b 1541 }
034c6ed7 1542
4f2d528d
LP		 1543 if (state != SERVICE_START_PRE &&
1544 state != SERVICE_START &&
6cf6bbc2
LP		 1545 state != SERVICE_START_POST &&
1546 state != SERVICE_RUNNING &&
1547 state != SERVICE_RELOAD &&
1548 state != SERVICE_STOP &&
1549 state != SERVICE_STOP_SIGTERM &&
1550 state != SERVICE_STOP_SIGKILL &&
1551 state != SERVICE_STOP_POST &&
1552 state != SERVICE_FINAL_SIGTERM &&
1553 state != SERVICE_FINAL_SIGKILL &&
1124fe6f 1554 !(state == SERVICE_DEAD && UNIT(s)->job)) {
4f2d528d 1555 service_close_socket_fd(s);
6cf6bbc2
LP		 1556 service_connection_unref(s);
1557 }
4f2d528d 1558
6d594baa 1559 if (state == SERVICE_STOP || state == SERVICE_STOP_SIGTERM)
a6927d7f
MO		 1560 service_stop_watchdog(s);
1561
f6023656
LP		 1562 /* For the inactive states unit_notify() will trim the cgroup,
1563 * but for exit we have to do that ourselves... */
1124fe6f 1564 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
4ad49000 1565 unit_destroy_cgroup(UNIT(s));
f6023656 1566
e537352b 1567 if (old_state != state)
66870f90
ZJS		 1568 log_debug_unit(UNIT(s)->id,
1569 "%s changed %s -> %s", UNIT(s)->id,
1570 service_state_to_string(old_state),
1571 service_state_to_string(state));
acbb0225 1572
e056b01d 1573 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
f42806df 1574 s->reload_result = SERVICE_SUCCESS;
034c6ed7
LP		 1575}
1576
a16e1123
LP		 1577static int service_coldplug(Unit *u) {
1578 Service *s = SERVICE(u);
1579 int r;
1580
1581 assert(s);
1582 assert(s->state == SERVICE_DEAD);
1583
1584 if (s->deserialized_state != s->state) {
1585
1586 if (s->deserialized_state == SERVICE_START_PRE ||
1587 s->deserialized_state == SERVICE_START ||
1588 s->deserialized_state == SERVICE_START_POST ||
1589 s->deserialized_state == SERVICE_RELOAD ||
1590 s->deserialized_state == SERVICE_STOP ||
1591 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1592 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1593 s->deserialized_state == SERVICE_STOP_POST ||
1594 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1595 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
e558336f 1596 s->deserialized_state == SERVICE_AUTO_RESTART) {
6c12b52e 1597
d568a335 1598 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
e558336f
LP		 1599 usec_t k;
1600
d568a335 1601 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
e558336f 1602
36697dc0
LP		 1603 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, k, &s->timer_watch);
1604 if (r < 0)
e558336f
LP		 1605 return r;
1606 }
1607 }
a16e1123
LP		 1608
1609 if ((s->deserialized_state == SERVICE_START &&
1610 (s->type == SERVICE_FORKING ||
8c47c732 1611 s->type == SERVICE_DBUS ||
34e9ba66 1612 s->type == SERVICE_ONESHOT ||
8c47c732 1613 s->type == SERVICE_NOTIFY)) ||
a16e1123
LP		 1614 s->deserialized_state == SERVICE_START_POST ||
1615 s->deserialized_state == SERVICE_RUNNING ||
1616 s->deserialized_state == SERVICE_RELOAD ||
1617 s->deserialized_state == SERVICE_STOP ||
1618 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1619 s->deserialized_state == SERVICE_STOP_SIGKILL)
117dcc57
ZJS		 1620 if (s->main_pid > 0) {
1621 r = unit_watch_pid(UNIT(s), s->main_pid);
1622 if (r < 0)
a16e1123 1623 return r;
117dcc57 1624 }
a16e1123
LP		 1625
1626 if (s->deserialized_state == SERVICE_START_PRE ||
1627 s->deserialized_state == SERVICE_START ||
1628 s->deserialized_state == SERVICE_START_POST ||
1629 s->deserialized_state == SERVICE_RELOAD ||
1630 s->deserialized_state == SERVICE_STOP ||
1631 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1632 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1633 s->deserialized_state == SERVICE_STOP_POST ||
1634 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1635 s->deserialized_state == SERVICE_FINAL_SIGKILL)
117dcc57
ZJS		 1636 if (s->control_pid > 0) {
1637 r = unit_watch_pid(UNIT(s), s->control_pid);
1638 if (r < 0)
a16e1123 1639 return r;
117dcc57 1640 }
a16e1123 1641
bb242b7b
MO		 1642 if (s->deserialized_state == SERVICE_START_POST ||
1643 s->deserialized_state == SERVICE_RUNNING)
1644 service_handle_watchdog(s);
1645
a16e1123
LP		 1646 service_set_state(s, s->deserialized_state);
1647 }
a16e1123
LP		 1648 return 0;
1649}
1650
44d8db9e
LP		 1651static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1652 Iterator i;
1653 int r;
1654 int *rfds = NULL;
1655 unsigned rn_fds = 0;
57020a3a 1656 Unit *u;
44d8db9e
LP		 1657
1658 assert(s);
1659 assert(fds);
1660 assert(n_fds);
1661
6cf6bbc2
LP		 1662 if (s->socket_fd >= 0)
1663 return 0;
1664
1124fe6f 1665 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
44d8db9e
LP		 1666 int *cfds;
1667 unsigned cn_fds;
57020a3a
LP		 1668 Socket *sock;
1669
ac155bb8 1670 if (u->type != UNIT_SOCKET)
57020a3a
LP		 1671 continue;
1672
1673 sock = SOCKET(u);
44d8db9e 1674
117dcc57
ZJS		 1675 r = socket_collect_fds(sock, &cfds, &cn_fds);
1676 if (r < 0)
44d8db9e
LP		 1677 goto fail;
1678
1679 if (!cfds)
1680 continue;
1681
1682 if (!rfds) {
1683 rfds = cfds;
1684 rn_fds = cn_fds;
1685 } else {
1686 int *t;
1687
117dcc57
ZJS		 1688 t = new(int, rn_fds+cn_fds);
1689 if (!t) {
44d8db9e
LP		 1690 free(cfds);
1691 r = -ENOMEM;
1692 goto fail;
1693 }
1694
9c1b183c
LP		 1695 memcpy(t, rfds, rn_fds * sizeof(int));
1696 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
44d8db9e
LP		 1697 free(rfds);
1698 free(cfds);
1699
1700 rfds = t;
1701 rn_fds = rn_fds+cn_fds;
1702 }
1703 }
1704
1705 *fds = rfds;
1706 *n_fds = rn_fds;
3e33402a 1707
44d8db9e
LP		 1708 return 0;
1709
1710fail:
1711 free(rfds);
3e33402a 1712
44d8db9e
LP		 1713 return r;
1714}
1715
81a2b7ce
LP		 1716static int service_spawn(
1717 Service *s,
1718 ExecCommand *c,
1719 bool timeout,
1720 bool pass_fds,
1721 bool apply_permissions,
1722 bool apply_chroot,
1e3ad081 1723 bool apply_tty_stdin,
c952c6ec 1724 bool set_notify_socket,
ecedd90f 1725 bool is_control,
81a2b7ce
LP		 1726 pid_t *_pid) {
1727
034c6ed7
LP		 1728 pid_t pid;
1729 int r;
117dcc57 1730 int *fds = NULL;
7fd1b19b 1731 _cleanup_free_ int *fdsbuf = NULL;
2105e76a 1732 unsigned n_fds = 0, n_env = 0;
7fd1b19b 1733 _cleanup_strv_free_ char
117dcc57 1734 **argv = NULL, **final_env = NULL, **our_env = NULL;
4ad49000 1735 const char *path;
034c6ed7
LP		 1736
1737 assert(s);
1738 assert(c);
1739 assert(_pid);
1740
4ad49000
LP		 1741 unit_realize_cgroup(UNIT(s));
1742
6cf6bbc2
LP		 1743 if (pass_fds ||
1744 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1745 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1746 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1747
4f2d528d
LP		 1748 if (s->socket_fd >= 0) {
1749 fds = &s->socket_fd;
1750 n_fds = 1;
6cf6bbc2 1751 } else {
117dcc57
ZJS		 1752 r = service_collect_fds(s, &fdsbuf, &n_fds);
1753 if (r < 0)
6cf6bbc2
LP		 1754 goto fail;
1755
1756 fds = fdsbuf;
1757 }
4f2d528d 1758 }
44d8db9e 1759
d568a335 1760 if (timeout && s->timeout_start_usec) {
117dcc57
ZJS		 1761 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
1762 s->timeout_start_usec, &s->timer_watch);
d568a335 1763 if (r < 0)
034c6ed7
LP		 1764 goto fail;
1765 } else
acbb0225 1766 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7 1767
117dcc57
ZJS		 1768 argv = unit_full_printf_strv(UNIT(s), c->argv);
1769 if (!argv) {
9e2f7c11
LP		 1770 r = -ENOMEM;
1771 goto fail;
1772 }
1773
97ae63e2
LP		 1774 our_env = new0(char*, 5);
1775 if (!our_env) {
2105e76a
LP		 1776 r = -ENOMEM;
1777 goto fail;
1778 }
c952c6ec 1779
2105e76a 1780 if (set_notify_socket)
1124fe6f 1781 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
c952c6ec
LP		 1782 r = -ENOMEM;
1783 goto fail;
1784 }
1785
2105e76a
LP		 1786 if (s->main_pid > 0)
1787 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
c952c6ec
LP		 1788 r = -ENOMEM;
1789 goto fail;
1790 }
2105e76a 1791
6e0bcc98
MO		 1792 if (s->watchdog_usec > 0)
1793 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1794 r = -ENOMEM;
1795 goto fail;
1796 }
1797
4ad49000 1798 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
97ae63e2
LP		 1799 if (asprintf(our_env + n_env++, "MANAGERPID=%lu", (unsigned long) getpid()) < 0) {
1800 r = -ENOMEM;
1801 goto fail;
1802 }
1803
1804 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1805 if (!final_env) {
2105e76a
LP		 1806 r = -ENOMEM;
1807 goto fail;
1808 }
c952c6ec 1809
4ad49000
LP		 1810 if (is_control && UNIT(s)->cgroup_path) {
1811 path = strappenda(UNIT(s)->cgroup_path, "/control");
1812 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1813 } else
1814 path = UNIT(s)->cgroup_path;
1815
9e2f7c11
LP		 1816 r = exec_spawn(c,
1817 argv,
1818 &s->exec_context,
1819 fds, n_fds,
2105e76a 1820 final_env,
9e2f7c11
LP		 1821 apply_permissions,
1822 apply_chroot,
1e3ad081 1823 apply_tty_stdin,
1124fe6f 1824 UNIT(s)->manager->confirm_spawn,
4ad49000
LP		 1825 UNIT(s)->cgroup_mask,
1826 path,
62bca2c6 1827 UNIT(s)->id,
f2b68789 1828 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
9e2f7c11 1829 &pid);
9e2f7c11 1830 if (r < 0)
034c6ed7
LP		 1831 goto fail;
1832
117dcc57
ZJS		 1833 r = unit_watch_pid(UNIT(s), pid);
1834 if (r < 0)
034c6ed7
LP		 1835 /* FIXME: we need to do something here */
1836 goto fail;
1837
1838 *_pid = pid;
1839
5cb5a6ff 1840 return 0;
034c6ed7
LP		 1841
1842fail:
1843 if (timeout)
acbb0225 1844 unit_unwatch_timer(UNIT(s), &s->timer_watch);
034c6ed7
LP		 1845
1846 return r;
1847}
1848
80876c20
LP		 1849static int main_pid_good(Service *s) {
1850 assert(s);
1851
1852 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1853 * don't know */
1854
1855 /* If we know the pid file, then lets just check if it is
1856 * still valid */
6dfa5494
LP		 1857 if (s->main_pid_known) {
1858
1859 /* If it's an alien child let's check if it is still
1860 * alive ... */
62220cf7 1861 if (s->main_pid_alien && s->main_pid > 0)
6dfa5494
LP		 1862 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1863
1864 /* .. otherwise assume we'll get a SIGCHLD for it,
1865 * which we really should wait for to collect exit
1866 * status and code */
80876c20 1867 return s->main_pid > 0;
6dfa5494 1868 }
80876c20
LP		 1869
1870 /* We don't know the pid */
1871 return -EAGAIN;
1872}
1873
44a6b1b6 1874_pure_ static int control_pid_good(Service *s) {
80876c20
LP		 1875 assert(s);
1876
1877 return s->control_pid > 0;
1878}
1879
1880static int cgroup_good(Service *s) {
1881 int r;
1882
1883 assert(s);
1884
4ad49000
LP		 1885 if (!UNIT(s)->cgroup_path)
1886 return 0;
1887
1888 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
117dcc57 1889 if (r < 0)
80876c20
LP		 1890 return r;
1891
1892 return !r;
1893}
1894
f42806df 1895static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
034c6ed7
LP		 1896 int r;
1897 assert(s);
1898
f42806df
LP		 1899 if (f != SERVICE_SUCCESS)
1900 s->result = f;
034c6ed7 1901
0c7f15b3
MS		 1902 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1903
034c6ed7 1904 if (allow_restart &&
47342320 1905 !s->forbid_restart &&
034c6ed7 1906 (s->restart == SERVICE_RESTART_ALWAYS ||
f42806df
LP		 1907 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1908 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
dc99a976 1909 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
f42806df 1910 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
96342de6
LN		 1911 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1912 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1913 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1914 (s->result != SERVICE_FAILURE_SIGNAL ||
1915 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1916 ) {
034c6ed7 1917
36697dc0 1918 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
f42806df 1919 if (r < 0)
034c6ed7
LP		 1920 goto fail;
1921
1922 service_set_state(s, SERVICE_AUTO_RESTART);
0c7f15b3 1923 }
034c6ed7 1924
47342320
LP		 1925 s->forbid_restart = false;
1926
c17ec25e
MS		 1927 /* we want fresh tmpdirs in case service is started again immediately */
1928 exec_context_tmp_dirs_done(&s->exec_context);
1929
9285c9ff
LN		 1930 /* Try to delete the pid file. At this point it will be
1931 * out-of-date, and some software might be confused by it, so
1932 * let's remove it. */
1933 if (s->pid_file)
1934 unlink_noerrno(s->pid_file);
1935
034c6ed7
LP		 1936 return;
1937
1938fail:
66870f90
ZJS		 1939 log_warning_unit(UNIT(s)->id,
1940 "%s failed to run install restart timer: %s",
1941 UNIT(s)->id, strerror(-r));
f42806df 1942 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
034c6ed7
LP		 1943}
1944
f42806df 1945static void service_enter_stop_post(Service *s, ServiceResult f) {
034c6ed7
LP		 1946 int r;
1947 assert(s);
1948
f42806df
LP		 1949 if (f != SERVICE_SUCCESS)
1950 s->result = f;
034c6ed7 1951
5e94833f
LP		 1952 service_unwatch_control_pid(s);
1953
117dcc57
ZJS		 1954 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1955 if (s->control_command) {
867b3b7d
LP		 1956 s->control_command_id = SERVICE_EXEC_STOP_POST;
1957
ecedd90f
LP		 1958 r = service_spawn(s,
1959 s->control_command,
1960 true,
1961 false,
1962 !s->permissions_start_only,
1963 !s->root_directory_start_only,
1964 true,
1965 false,
1966 true,
1967 &s->control_pid);
1968 if (r < 0)
034c6ed7
LP		 1969 goto fail;
1970
d6ea93e3 1971
80876c20
LP		 1972 service_set_state(s, SERVICE_STOP_POST);
1973 } else
c961869a 1974 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 1975
1976 return;
1977
1978fail:
66870f90
ZJS		 1979 log_warning_unit(UNIT(s)->id,
1980 "%s failed to run 'stop-post' task: %s",
1981 UNIT(s)->id, strerror(-r));
f42806df 1982 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 1983}
1984
f42806df 1985static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
034c6ed7 1986 int r;
034c6ed7
LP		 1987
1988 assert(s);
1989
f42806df
LP		 1990 if (f != SERVICE_SUCCESS)
1991 s->result = f;
034c6ed7 1992
cd2086fe
LP		 1993 r = unit_kill_context(
1994 UNIT(s),
1995 &s->kill_context,
1996 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1997 s->main_pid,
1998 s->control_pid,
1999 s->main_pid_alien);
2000 if (r < 0)
2001 goto fail;
034c6ed7 2002
cd2086fe 2003 if (r > 0) {
d568a335 2004 if (s->timeout_stop_usec > 0) {
117dcc57
ZJS		 2005 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true,
2006 s->timeout_stop_usec, &s->timer_watch);
d568a335 2007 if (r < 0)
e558336f 2008 goto fail;
d568a335 2009 }
d6ea93e3 2010
80876c20
LP		 2011 service_set_state(s, state);
2012 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2013 service_enter_stop_post(s, SERVICE_SUCCESS);
80876c20 2014 else
f42806df 2015 service_enter_dead(s, SERVICE_SUCCESS, true);
034c6ed7
LP		 2016
2017 return;
2018
2019fail:
66870f90
ZJS		 2020 log_warning_unit(UNIT(s)->id,
2021 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
034c6ed7 2022
80876c20 2023 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
f42806df 2024 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
034c6ed7 2025 else
f42806df 2026 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2027}
2028
f42806df 2029static void service_enter_stop(Service *s, ServiceResult f) {
034c6ed7 2030 int r;
5925dd3c 2031
034c6ed7
LP		 2032 assert(s);
2033
f42806df
LP		 2034 if (f != SERVICE_SUCCESS)
2035 s->result = f;
034c6ed7 2036
5e94833f
LP		 2037 service_unwatch_control_pid(s);
2038
117dcc57
ZJS		 2039 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2040 if (s->control_command) {
867b3b7d
LP		 2041 s->control_command_id = SERVICE_EXEC_STOP;
2042
ecedd90f
LP		 2043 r = service_spawn(s,
2044 s->control_command,
2045 true,
2046 false,
2047 !s->permissions_start_only,
2048 !s->root_directory_start_only,
2049 false,
2050 false,
2051 true,
2052 &s->control_pid);
2053 if (r < 0)
034c6ed7
LP		 2054 goto fail;
2055
80876c20
LP		 2056 service_set_state(s, SERVICE_STOP);
2057 } else
f42806df 2058 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
034c6ed7
LP		 2059
2060 return;
2061
2062fail:
66870f90
ZJS		 2063 log_warning_unit(UNIT(s)->id,
2064 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2065 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2066}
2067
f42806df 2068static void service_enter_running(Service *s, ServiceResult f) {
4eab639f 2069 int main_pid_ok, cgroup_ok;
80876c20
LP		 2070 assert(s);
2071
f42806df
LP		 2072 if (f != SERVICE_SUCCESS)
2073 s->result = f;
80876c20 2074
4eab639f
LP		 2075 main_pid_ok = main_pid_good(s);
2076 cgroup_ok = cgroup_good(s);
2077
2078 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
05e343b7 2079 (s->bus_name_good || s->type != SERVICE_DBUS))
80876c20 2080 service_set_state(s, SERVICE_RUNNING);
02ee865a 2081 else if (s->remain_after_exit)
80876c20
LP		 2082 service_set_state(s, SERVICE_EXITED);
2083 else
f42806df 2084 service_enter_stop(s, SERVICE_SUCCESS);
80876c20
LP		 2085}
2086
034c6ed7
LP		 2087static void service_enter_start_post(Service *s) {
2088 int r;
2089 assert(s);
2090
5e94833f
LP		 2091 service_unwatch_control_pid(s);
2092
bb242b7b
MO		 2093 if (s->watchdog_usec > 0)
2094 service_reset_watchdog(s);
2095
117dcc57
ZJS		 2096 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2097 if (s->control_command) {
867b3b7d
LP		 2098 s->control_command_id = SERVICE_EXEC_START_POST;
2099
ecedd90f
LP		 2100 r = service_spawn(s,
2101 s->control_command,
2102 true,
2103 false,
2104 !s->permissions_start_only,
2105 !s->root_directory_start_only,
2106 false,
2107 false,
2108 true,
2109 &s->control_pid);
2110 if (r < 0)
034c6ed7
LP		 2111 goto fail;
2112
80876c20
LP		 2113 service_set_state(s, SERVICE_START_POST);
2114 } else
f42806df 2115 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2116
2117 return;
2118
2119fail:
66870f90
ZJS		 2120 log_warning_unit(UNIT(s)->id,
2121 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2122 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2123}
2124
4ad49000
LP		 2125static void service_kill_control_processes(Service *s) {
2126 char *p;
2127
2128 if (!UNIT(s)->cgroup_path)
2129 return;
2130
2131 p = strappenda(UNIT(s)->cgroup_path, "/control");
4ad49000
LP		 2132 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2133}
2134
034c6ed7 2135static void service_enter_start(Service *s) {
4ad49000 2136 ExecCommand *c;
034c6ed7
LP		 2137 pid_t pid;
2138 int r;
2139
2140 assert(s);
2141
2142 assert(s->exec_command[SERVICE_EXEC_START]);
34e9ba66 2143 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
034c6ed7 2144
41efeaec
LP		 2145 service_unwatch_control_pid(s);
2146 service_unwatch_main_pid(s);
80876c20 2147
8f53a7b8
LP		 2148 /* We want to ensure that nobody leaks processes from
2149 * START_PRE here, so let's go on a killing spree, People
2150 * should not spawn long running processes from START_PRE. */
4ad49000 2151 service_kill_control_processes(s);
8f53a7b8 2152
867b3b7d
LP		 2153 if (s->type == SERVICE_FORKING) {
2154 s->control_command_id = SERVICE_EXEC_START;
2155 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2156
2157 s->main_command = NULL;
2158 } else {
2159 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2160 s->control_command = NULL;
2161
2162 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2163 }
34e9ba66 2164
ecedd90f
LP		 2165 r = service_spawn(s,
2166 c,
117dcc57
ZJS		 2167 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2168 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
ecedd90f
LP		 2169 true,
2170 true,
2171 true,
2172 true,
2173 s->notify_access != NOTIFY_NONE,
2174 false,
2175 &pid);
2176 if (r < 0)
034c6ed7
LP		 2177 goto fail;
2178
f2b68789 2179 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
034c6ed7
LP		 2180 /* For simple services we immediately start
2181 * the START_POST binaries. */
2182
5925dd3c 2183 service_set_main_pid(s, pid);
034c6ed7
LP		 2184 service_enter_start_post(s);
2185
2186 } else if (s->type == SERVICE_FORKING) {
2187
2188 /* For forking services we wait until the start
2189 * process exited. */
2190
e55224ca 2191 s->control_pid = pid;
80876c20
LP		 2192 service_set_state(s, SERVICE_START);
2193
34e9ba66 2194 } else if (s->type == SERVICE_ONESHOT ||
8c47c732
LP		 2195 s->type == SERVICE_DBUS ||
2196 s->type == SERVICE_NOTIFY) {
7d55e835 2197
34e9ba66 2198 /* For oneshot services we wait until the start
7d55e835
LP		 2199 * process exited, too, but it is our main process. */
2200
05e343b7 2201 /* For D-Bus services we know the main pid right away,
8c47c732
LP		 2202 * but wait for the bus name to appear on the
2203 * bus. Notify services are similar. */
05e343b7 2204
5925dd3c 2205 service_set_main_pid(s, pid);
80876c20 2206 service_set_state(s, SERVICE_START);
034c6ed7
LP		 2207 } else
2208 assert_not_reached("Unknown service type");
2209
2210 return;
2211
2212fail:
66870f90
ZJS		 2213 log_warning_unit(UNIT(s)->id,
2214 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2215 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7
LP		 2216}
2217
2218static void service_enter_start_pre(Service *s) {
2219 int r;
2220
2221 assert(s);
2222
5e94833f
LP		 2223 service_unwatch_control_pid(s);
2224
117dcc57
ZJS		 2225 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2226 if (s->control_command) {
8f53a7b8
LP		 2227 /* Before we start anything, let's clear up what might
2228 * be left from previous runs. */
4ad49000 2229 service_kill_control_processes(s);
8f53a7b8 2230
867b3b7d
LP		 2231 s->control_command_id = SERVICE_EXEC_START_PRE;
2232
ecedd90f
LP		 2233 r = service_spawn(s,
2234 s->control_command,
2235 true,
2236 false,
2237 !s->permissions_start_only,
2238 !s->root_directory_start_only,
2239 true,
2240 false,
2241 true,
2242 &s->control_pid);
2243 if (r < 0)
034c6ed7
LP		 2244 goto fail;
2245
80876c20
LP		 2246 service_set_state(s, SERVICE_START_PRE);
2247 } else
034c6ed7
LP		 2248 service_enter_start(s);
2249
2250 return;
2251
2252fail:
66870f90
ZJS		 2253 log_warning_unit(UNIT(s)->id,
2254 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
f42806df 2255 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
034c6ed7
LP		 2256}
2257
2258static void service_enter_restart(Service *s) {
2259 int r;
398ef8ba
LP		 2260 DBusError error;
2261
034c6ed7 2262 assert(s);
398ef8ba 2263 dbus_error_init(&error);
034c6ed7 2264
a8bb2e65
LP		 2265 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2266 /* Don't restart things if we are going down anyway */
66870f90
ZJS		 2267 log_info_unit(UNIT(s)->id,
2268 "Stop job pending for unit, delaying automatic restart.");
2edfa366 2269
36697dc0 2270 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->restart_usec, &s->timer_watch);
a8bb2e65 2271 if (r < 0)
2edfa366 2272 goto fail;
feae8adb
DW		 2273
2274 return;
2edfa366
LP		 2275 }
2276
48bb5876
DW		 2277 /* Any units that are bound to this service must also be
2278 * restarted. We use JOB_RESTART (instead of the more obvious
2279 * JOB_START) here so that those dependency jobs will be added
2280 * as well. */
2281 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2282 if (r < 0)
034c6ed7
LP		 2283 goto fail;
2284
a8bb2e65
LP		 2285 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2286 * it will be canceled as part of the service_stop() call that
2287 * is executed as part of JOB_RESTART. */
2288
66870f90
ZJS		 2289 log_debug_unit(UNIT(s)->id,
2290 "%s scheduled restart job.", UNIT(s)->id);
034c6ed7
LP		 2291 return;
2292
2293fail:
66870f90
ZJS		 2294 log_warning_unit(UNIT(s)->id,
2295 "%s failed to schedule restart job: %s",
2296 UNIT(s)->id, bus_error(&error, -r));
f42806df 2297 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
398ef8ba
LP		 2298
2299 dbus_error_free(&error);
034c6ed7
LP		 2300}
2301
2302static void service_enter_reload(Service *s) {
2303 int r;
2304
2305 assert(s);
2306
5e94833f
LP		 2307 service_unwatch_control_pid(s);
2308
117dcc57
ZJS		 2309 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2310 if (s->control_command) {
867b3b7d
LP		 2311 s->control_command_id = SERVICE_EXEC_RELOAD;
2312
ecedd90f
LP		 2313 r = service_spawn(s,
2314 s->control_command,
2315 true,
2316 false,
2317 !s->permissions_start_only,
2318 !s->root_directory_start_only,
2319 false,
2320 false,
2321 true,
2322 &s->control_pid);
2323 if (r < 0)
034c6ed7
LP		 2324 goto fail;
2325
80876c20
LP		 2326 service_set_state(s, SERVICE_RELOAD);
2327 } else
f42806df 2328 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2329
2330 return;
2331
2332fail:
66870f90
ZJS		 2333 log_warning_unit(UNIT(s)->id,
2334 "%s failed to run 'reload' task: %s",
2335 UNIT(s)->id, strerror(-r));
f42806df
LP		 2336 s->reload_result = SERVICE_FAILURE_RESOURCES;
2337 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 2338}
2339
f42806df 2340static void service_run_next_control(Service *s) {
034c6ed7
LP		 2341 int r;
2342
2343 assert(s);
2344 assert(s->control_command);
2345 assert(s->control_command->command_next);
2346
34e9ba66 2347 assert(s->control_command_id != SERVICE_EXEC_START);
034c6ed7 2348
34e9ba66 2349 s->control_command = s->control_command->command_next;
5e94833f
LP		 2350 service_unwatch_control_pid(s);
2351
ecedd90f
LP		 2352 r = service_spawn(s,
2353 s->control_command,
2354 true,
2355 false,
2356 !s->permissions_start_only,
2357 !s->root_directory_start_only,
2358 s->control_command_id == SERVICE_EXEC_START_PRE ||
2359 s->control_command_id == SERVICE_EXEC_STOP_POST,
2360 false,
2361 true,
2362 &s->control_pid);
2363 if (r < 0)
034c6ed7
LP		 2364 goto fail;
2365
2366 return;
2367
2368fail:
66870f90
ZJS		 2369 log_warning_unit(UNIT(s)->id,
2370 "%s failed to run next control task: %s",
2371 UNIT(s)->id, strerror(-r));
034c6ed7 2372
80876c20 2373 if (s->state == SERVICE_START_PRE)
f42806df 2374 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
80876c20 2375 else if (s->state == SERVICE_STOP)
f42806df 2376 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
034c6ed7 2377 else if (s->state == SERVICE_STOP_POST)
f42806df 2378 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
e2f3b44c 2379 else if (s->state == SERVICE_RELOAD) {
f42806df
LP		 2380 s->reload_result = SERVICE_FAILURE_RESOURCES;
2381 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c 2382 } else
f42806df 2383 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
5cb5a6ff
LP		 2384}
2385
f42806df 2386static void service_run_next_main(Service *s) {
34e9ba66
LP		 2387 pid_t pid;
2388 int r;
2389
2390 assert(s);
867b3b7d
LP		 2391 assert(s->main_command);
2392 assert(s->main_command->command_next);
2393 assert(s->type == SERVICE_ONESHOT);
34e9ba66 2394
867b3b7d 2395 s->main_command = s->main_command->command_next;
34e9ba66
LP		 2396 service_unwatch_main_pid(s);
2397
ecedd90f
LP		 2398 r = service_spawn(s,
2399 s->main_command,
98709151 2400 true,
ecedd90f
LP		 2401 true,
2402 true,
2403 true,
2404 true,
2405 s->notify_access != NOTIFY_NONE,
2406 false,
2407 &pid);
2408 if (r < 0)
34e9ba66
LP		 2409 goto fail;
2410
2411 service_set_main_pid(s, pid);
2412
2413 return;
2414
2415fail:
66870f90
ZJS		 2416 log_warning_unit(UNIT(s)->id,
2417 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
f42806df 2418 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
34e9ba66
LP		 2419}
2420
4b939747
MO		 2421static int service_start_limit_test(Service *s) {
2422 assert(s);
2423
2424 if (ratelimit_test(&s->start_limit))
2425 return 0;
2426
2427 switch (s->start_limit_action) {
2428
2429 case SERVICE_START_LIMIT_NONE:
66870f90
ZJS		 2430 log_warning_unit(UNIT(s)->id,
2431 "%s start request repeated too quickly, refusing to start.",
2432 UNIT(s)->id);
4b939747
MO		 2433 break;
2434
2435 case SERVICE_START_LIMIT_REBOOT: {
2436 DBusError error;
2437 int r;
2438
2439 dbus_error_init(&error);
2440
66870f90
ZJS		 2441 log_warning_unit(UNIT(s)->id,
2442 "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
4b939747 2443
117dcc57
ZJS		 2444 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2445 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2446 true, &error, NULL);
4b939747 2447 if (r < 0) {
66870f90
ZJS		 2448 log_error_unit(UNIT(s)->id,
2449 "Failed to reboot: %s.", bus_error(&error, r));
4b939747
MO		 2450 dbus_error_free(&error);
2451 }
2452
2453 break;
2454 }
2455
2456 case SERVICE_START_LIMIT_REBOOT_FORCE:
66870f90
ZJS		 2457 log_warning_unit(UNIT(s)->id,
2458 "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
4b939747
MO		 2459 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2460 break;
2461
2462 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
66870f90
ZJS		 2463 log_warning_unit(UNIT(s)->id,
2464 "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
0049f05a 2465 sync();
4b939747
MO		 2466 reboot(RB_AUTOBOOT);
2467 break;
2468
2469 default:
66870f90
ZJS		 2470 log_error_unit(UNIT(s)->id,
2471 "start limit action=%i", s->start_limit_action);
4b939747
MO		 2472 assert_not_reached("Unknown StartLimitAction.");
2473 }
2474
2475 return -ECANCELED;
2476}
2477
87f0e418
LP		 2478static int service_start(Unit *u) {
2479 Service *s = SERVICE(u);
4b939747 2480 int r;
5cb5a6ff
LP		 2481
2482 assert(s);
2483
034c6ed7
LP		 2484 /* We cannot fulfill this request right now, try again later
2485 * please! */
2486 if (s->state == SERVICE_STOP ||
2487 s->state == SERVICE_STOP_SIGTERM ||
2488 s->state == SERVICE_STOP_SIGKILL ||
2489 s->state == SERVICE_STOP_POST ||
2490 s->state == SERVICE_FINAL_SIGTERM ||
2491 s->state == SERVICE_FINAL_SIGKILL)
5cb5a6ff
LP		 2492 return -EAGAIN;
2493
034c6ed7
LP		 2494 /* Already on it! */
2495 if (s->state == SERVICE_START_PRE ||
2496 s->state == SERVICE_START ||
2497 s->state == SERVICE_START_POST)
2498 return 0;
2499
2e9d6c12 2500 /* A service that will be restarted must be stopped first to
7f2cddae 2501 * trigger BindsTo and/or OnFailure dependencies. If a user
2e9d6c12 2502 * does not want to wait for the holdoff time to elapse, the
d4943dc7
LP		 2503 * service should be manually restarted, not started. We
2504 * simply return EAGAIN here, so that any start jobs stay
2505 * queued, and assume that the auto restart timer will
2506 * eventually trigger the restart. */
2507 if (s->state == SERVICE_AUTO_RESTART)
a8bb2e65 2508 return -EAGAIN;
2e9d6c12
DW		 2509
2510 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
5cb5a6ff 2511
1e2e8133 2512 /* Make sure we don't enter a busy loop of some kind. */
4b939747 2513 r = service_start_limit_test(s);
c2f34808 2514 if (r < 0) {
8d1b002a 2515 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
4b939747 2516 return r;
c2f34808 2517 }
1e2e8133 2518
f42806df
LP		 2519 s->result = SERVICE_SUCCESS;
2520 s->reload_result = SERVICE_SUCCESS;
034c6ed7 2521 s->main_pid_known = false;
6dfa5494 2522 s->main_pid_alien = false;
47342320 2523 s->forbid_restart = false;
034c6ed7
LP		 2524
2525 service_enter_start_pre(s);
2526 return 0;
5cb5a6ff
LP		 2527}
2528
87f0e418
LP		 2529static int service_stop(Unit *u) {
2530 Service *s = SERVICE(u);
5cb5a6ff
LP		 2531
2532 assert(s);
2533
f0c7b229 2534 /* Don't create restart jobs from here. */
47342320 2535 s->forbid_restart = true;
034c6ed7 2536
e537352b
LP		 2537 /* Already on it */
2538 if (s->state == SERVICE_STOP ||
2539 s->state == SERVICE_STOP_SIGTERM ||
2540 s->state == SERVICE_STOP_SIGKILL ||
2541 s->state == SERVICE_STOP_POST ||
2542 s->state == SERVICE_FINAL_SIGTERM ||
2543 s->state == SERVICE_FINAL_SIGKILL)
2544 return 0;
2545
f0c7b229 2546 /* A restart will be scheduled or is in progress. */
034c6ed7 2547 if (s->state == SERVICE_AUTO_RESTART) {
0c7f15b3 2548 service_set_state(s, SERVICE_DEAD);
034c6ed7
LP		 2549 return 0;
2550 }
2551
3f6c78dc
LP		 2552 /* If there's already something running we go directly into
2553 * kill mode. */
2554 if (s->state == SERVICE_START_PRE ||
2555 s->state == SERVICE_START ||
2556 s->state == SERVICE_START_POST ||
2557 s->state == SERVICE_RELOAD) {
f42806df 2558 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
3f6c78dc
LP		 2559 return 0;
2560 }
5cb5a6ff 2561
3f6c78dc
LP		 2562 assert(s->state == SERVICE_RUNNING ||
2563 s->state == SERVICE_EXITED);
3a762661 2564
f42806df 2565 service_enter_stop(s, SERVICE_SUCCESS);
5cb5a6ff
LP		 2566 return 0;
2567}
2568
87f0e418
LP		 2569static int service_reload(Unit *u) {
2570 Service *s = SERVICE(u);
034c6ed7
LP		 2571
2572 assert(s);
2573
80876c20 2574 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
034c6ed7
LP		 2575
2576 service_enter_reload(s);
5cb5a6ff
LP		 2577 return 0;
2578}
2579
44a6b1b6 2580_pure_ static bool service_can_reload(Unit *u) {
87f0e418 2581 Service *s = SERVICE(u);
034c6ed7
LP		 2582
2583 assert(s);
2584
2585 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2586}
2587
a16e1123
LP		 2588static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2589 Service *s = SERVICE(u);
2590
2591 assert(u);
2592 assert(f);
2593 assert(fds);
2594
2595 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
f42806df
LP		 2596 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2597 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
a16e1123
LP		 2598
2599 if (s->control_pid > 0)
117dcc57
ZJS		 2600 unit_serialize_item_format(u, f, "control-pid", "%lu",
2601 (unsigned long) s->control_pid);
a16e1123 2602
5925dd3c
LP		 2603 if (s->main_pid_known && s->main_pid > 0)
2604 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
a16e1123
LP		 2605
2606 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2607
3a2776bc
LP		 2608 if (s->status_text)
2609 unit_serialize_item(u, f, "status-text", s->status_text);
2610
cfc4eb4c
LP		 2611 /* FIXME: There's a minor uncleanliness here: if there are
2612 * multiple commands attached here, we will start from the
2613 * first one again */
a16e1123 2614 if (s->control_command_id >= 0)
117dcc57
ZJS		 2615 unit_serialize_item(u, f, "control-command",
2616 service_exec_command_to_string(s->control_command_id));
a16e1123
LP		 2617
2618 if (s->socket_fd >= 0) {
2619 int copy;
2620
2621 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2622 return copy;
2623
2624 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2625 }
2626
ecdbca40 2627 if (s->main_exec_status.pid > 0) {
117dcc57
ZJS		 2628 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu",
2629 (unsigned long) s->main_exec_status.pid);
2630 dual_timestamp_serialize(f, "main-exec-status-start",
2631 &s->main_exec_status.start_timestamp);
2632 dual_timestamp_serialize(f, "main-exec-status-exit",
2633 &s->main_exec_status.exit_timestamp);
ecdbca40 2634
799fd0fd 2635 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
117dcc57
ZJS		 2636 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2637 s->main_exec_status.code);
2638 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2639 s->main_exec_status.status);
ecdbca40
LP		 2640 }
2641 }
a6927d7f 2642 if (dual_timestamp_is_set(&s->watchdog_timestamp))
117dcc57
ZJS		 2643 dual_timestamp_serialize(f, "watchdog-timestamp",
2644 &s->watchdog_timestamp);
ecdbca40 2645
c17ec25e
MS		 2646 if (s->exec_context.tmp_dir)
2647 unit_serialize_item(u, f, "tmp-dir", s->exec_context.tmp_dir);
2648
2649 if (s->exec_context.var_tmp_dir)
2650 unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2651
a16e1123
LP		 2652 return 0;
2653}
2654
2655static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2656 Service *s = SERVICE(u);
a16e1123
LP		 2657
2658 assert(u);
2659 assert(key);
2660 assert(value);
2661 assert(fds);
2662
2663 if (streq(key, "state")) {
2664 ServiceState state;
2665
117dcc57
ZJS		 2666 state = service_state_from_string(value);
2667 if (state < 0)
66870f90 2668 log_debug_unit(u->id, "Failed to parse state value %s", value);
a16e1123
LP		 2669 else
2670 s->deserialized_state = state;
f42806df
LP		 2671 } else if (streq(key, "result")) {
2672 ServiceResult f;
2673
2674 f = service_result_from_string(value);
2675 if (f < 0)
66870f90 2676 log_debug_unit(u->id, "Failed to parse result value %s", value);
f42806df
LP		 2677 else if (f != SERVICE_SUCCESS)
2678 s->result = f;
2679
2680 } else if (streq(key, "reload-result")) {
2681 ServiceResult f;
2682
2683 f = service_result_from_string(value);
2684 if (f < 0)
66870f90 2685 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
f42806df
LP		 2686 else if (f != SERVICE_SUCCESS)
2687 s->reload_result = f;
a16e1123 2688
a16e1123 2689 } else if (streq(key, "control-pid")) {
5925dd3c 2690 pid_t pid;
a16e1123 2691
e364ad06 2692 if (parse_pid(value, &pid) < 0)
66870f90 2693 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
a16e1123 2694 else
e55224ca 2695 s->control_pid = pid;
a16e1123 2696 } else if (streq(key, "main-pid")) {
5925dd3c 2697 pid_t pid;
a16e1123 2698
e364ad06 2699 if (parse_pid(value, &pid) < 0)
66870f90 2700 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
a16e1123 2701 else
5925dd3c 2702 service_set_main_pid(s, (pid_t) pid);
a16e1123
LP		 2703 } else if (streq(key, "main-pid-known")) {
2704 int b;
2705
117dcc57
ZJS		 2706 b = parse_boolean(value);
2707 if (b < 0)
66870f90 2708 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
a16e1123
LP		 2709 else
2710 s->main_pid_known = b;
3a2776bc
LP		 2711 } else if (streq(key, "status-text")) {
2712 char *t;
2713
117dcc57
ZJS		 2714 t = strdup(value);
2715 if (!t)
2716 log_oom();
2717 else {
3a2776bc
LP		 2718 free(s->status_text);
2719 s->status_text = t;
2720 }
2721
a16e1123
LP		 2722 } else if (streq(key, "control-command")) {
2723 ServiceExecCommand id;
2724
117dcc57
ZJS		 2725 id = service_exec_command_from_string(value);
2726 if (id < 0)
66870f90 2727 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
a16e1123
LP		 2728 else {
2729 s->control_command_id = id;
2730 s->control_command = s->exec_command[id];
2731 }
2732 } else if (streq(key, "socket-fd")) {
2733 int fd;
2734
2735 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
66870f90 2736 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
a16e1123
LP		 2737 else {
2738
2739 if (s->socket_fd >= 0)
2740 close_nointr_nofail(s->socket_fd);
2741 s->socket_fd = fdset_remove(fds, fd);
2742 }
ecdbca40
LP		 2743 } else if (streq(key, "main-exec-status-pid")) {
2744 pid_t pid;
2745
e364ad06 2746 if (parse_pid(value, &pid) < 0)
66870f90 2747 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
ecdbca40
LP		 2748 else
2749 s->main_exec_status.pid = pid;
2750 } else if (streq(key, "main-exec-status-code")) {
2751 int i;
2752
e364ad06 2753 if (safe_atoi(value, &i) < 0)
66870f90 2754 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
ecdbca40
LP		 2755 else
2756 s->main_exec_status.code = i;
2757 } else if (streq(key, "main-exec-status-status")) {
2758 int i;
2759
e364ad06 2760 if (safe_atoi(value, &i) < 0)
66870f90 2761 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
ecdbca40
LP		 2762 else
2763 s->main_exec_status.status = i;
799fd0fd
LP		 2764 } else if (streq(key, "main-exec-status-start"))
2765 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2766 else if (streq(key, "main-exec-status-exit"))
2767 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
a6927d7f
MO		 2768 else if (streq(key, "watchdog-timestamp"))
2769 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
c17ec25e
MS		 2770 else if (streq(key, "tmp-dir")) {
2771 char *t;
2772
2773 t = strdup(value);
2774 if (!t)
2775 return log_oom();
2776
2777 s->exec_context.tmp_dir = t;
2778 } else if (streq(key, "var-tmp-dir")) {
2779 char *t;
2780
2781 t = strdup(value);
2782 if (!t)
2783 return log_oom();
2784
2785 s->exec_context.var_tmp_dir = t;
2786 } else
66870f90 2787 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
a16e1123
LP		 2788
2789 return 0;
2790}
2791
44a6b1b6 2792_pure_ static UnitActiveState service_active_state(Unit *u) {
e056b01d
LP		 2793 const UnitActiveState *table;
2794
87f0e418 2795 assert(u);
5cb5a6ff 2796
e056b01d
LP		 2797 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2798
2799 return table[SERVICE(u)->state];
034c6ed7
LP		 2800}
2801
10a94420
LP		 2802static const char *service_sub_state_to_string(Unit *u) {
2803 assert(u);
2804
2805 return service_state_to_string(SERVICE(u)->state);
2806}
2807
701cc384
LP		 2808static bool service_check_gc(Unit *u) {
2809 Service *s = SERVICE(u);
2810
2811 assert(s);
2812
6d55002a
LP		 2813 /* Never clean up services that still have a process around,
2814 * even if the service is formally dead. */
2815 if (cgroup_good(s) > 0 ||
2816 main_pid_good(s) > 0 ||
2817 control_pid_good(s) > 0)
2818 return true;
2819
2820#ifdef HAVE_SYSV_COMPAT
1b64d026 2821 if (s->is_sysv)
6d55002a 2822 return true;
07459bb6 2823#endif
701cc384 2824
6d55002a
LP		 2825 return false;
2826}
2827
44a6b1b6 2828_pure_ static bool service_check_snapshot(Unit *u) {
701cc384
LP		 2829 Service *s = SERVICE(u);
2830
2831 assert(s);
2832
2833 return !s->got_socket_fd;
2834}
2835
3a111838
MS		 2836static int service_retry_pid_file(Service *s) {
2837 int r;
2838
2839 assert(s->pid_file);
2840 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2841
2842 r = service_load_pid_file(s, false);
2843 if (r < 0)
2844 return r;
2845
2846 service_unwatch_pid_file(s);
2847
f42806df 2848 service_enter_running(s, SERVICE_SUCCESS);
3a111838
MS		 2849 return 0;
2850}
2851
2852static int service_watch_pid_file(Service *s) {
2853 int r;
2854
66870f90
ZJS		 2855 log_debug_unit(UNIT(s)->id,
2856 "Setting watch for %s's PID file %s",
2857 UNIT(s)->id, s->pid_file_pathspec->path);
57020a3a 2858 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
3a111838
MS		 2859 if (r < 0)
2860 goto fail;
2861
2862 /* the pidfile might have appeared just before we set the watch */
bc41f93e
ZJS		 2863 log_debug_unit(UNIT(s)->id,
2864 "Trying to read %s's PID file %s in case it changed",
2865 UNIT(s)->id, s->pid_file_pathspec->path);
3a111838
MS		 2866 service_retry_pid_file(s);
2867
2868 return 0;
2869fail:
66870f90
ZJS		 2870 log_error_unit(UNIT(s)->id,
2871 "Failed to set a watch for %s's PID file %s: %s",
2872 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
3a111838
MS		 2873 service_unwatch_pid_file(s);
2874 return r;
2875}
2876
2877static int service_demand_pid_file(Service *s) {
2878 PathSpec *ps;
2879
2880 assert(s->pid_file);
2881 assert(!s->pid_file_pathspec);
2882
2883 ps = new0(PathSpec, 1);
2884 if (!ps)
2885 return -ENOMEM;
2886
2887 ps->path = strdup(s->pid_file);
2888 if (!ps->path) {
2889 free(ps);
2890 return -ENOMEM;
2891 }
2892
2893 path_kill_slashes(ps->path);
2894
2895 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2896 * keep their PID file open all the time. */
2897 ps->type = PATH_MODIFIED;
2898 ps->inotify_fd = -1;
2899
2900 s->pid_file_pathspec = ps;
2901
2902 return service_watch_pid_file(s);
2903}
2904
2905static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2906 Service *s = SERVICE(u);
2907
2908 assert(s);
2909 assert(fd >= 0);
2910 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2911 assert(s->pid_file_pathspec);
57020a3a 2912 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3a111838 2913
66870f90 2914 log_debug_unit(u->id, "inotify event for %s", u->id);
3a111838 2915
57020a3a 2916 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
3a111838
MS		 2917 goto fail;
2918
2919 if (service_retry_pid_file(s) == 0)
2920 return;
2921
2922 if (service_watch_pid_file(s) < 0)
2923 goto fail;
2924
2925 return;
2926fail:
2927 service_unwatch_pid_file(s);
f42806df 2928 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 2929}
2930
87f0e418
LP		 2931static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2932 Service *s = SERVICE(u);
f42806df 2933 ServiceResult f;
5cb5a6ff
LP		 2934
2935 assert(s);
034c6ed7
LP		 2936 assert(pid >= 0);
2937
96342de6
LN		 2938 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2939 is_clean_exit_lsb(code, status, &s->success_status))
f42806df
LP		 2940 f = SERVICE_SUCCESS;
2941 else if (code == CLD_EXITED)
2942 f = SERVICE_FAILURE_EXIT_CODE;
2943 else if (code == CLD_KILLED)
2944 f = SERVICE_FAILURE_SIGNAL;
2945 else if (code == CLD_DUMPED)
2946 f = SERVICE_FAILURE_CORE_DUMP;
d06dacd0 2947 else
cfc4eb4c 2948 assert_not_reached("Unknown code");
034c6ed7
LP		 2949
2950 if (s->main_pid == pid) {
db01f8b3
MS		 2951 /* Forking services may occasionally move to a new PID.
2952 * As long as they update the PID file before exiting the old
2953 * PID, they're fine. */
5375410b 2954 if (service_load_pid_file(s, false) == 0)
db01f8b3 2955 return;
034c6ed7 2956
034c6ed7 2957 s->main_pid = 0;
6ea832a2 2958 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
034c6ed7 2959
867b3b7d 2960 if (s->main_command) {
fbeefb45
LP		 2961 /* If this is not a forking service than the
2962 * main process got started and hence we copy
2963 * the exit status so that it is recorded both
2964 * as main and as control process exit
2965 * status */
2966
867b3b7d 2967 s->main_command->exec_status = s->main_exec_status;
b708e7ce 2968
867b3b7d 2969 if (s->main_command->ignore)
f42806df 2970 f = SERVICE_SUCCESS;
fbeefb45
LP		 2971 } else if (s->exec_command[SERVICE_EXEC_START]) {
2972
2973 /* If this is a forked process, then we should
2974 * ignore the return value if this was
2975 * configured for the starter process */
2976
2977 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2978 f = SERVICE_SUCCESS;
034c6ed7
LP		 2979 }
2980
bbc9006e
MT		 2981 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2982 u->id,
23635a85
ZJS		 2983 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2984 u->id, sigchld_code_to_string(code), status,
2985 strna(code == CLD_EXITED
2986 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2987 : signal_to_string(status)),
23635a85
ZJS		 2988 "EXIT_CODE=%s", sigchld_code_to_string(code),
2989 "EXIT_STATUS=%i", status,
2990 NULL);
f42806df
LP		 2991
2992 if (f != SERVICE_SUCCESS)
2993 s->result = f;
034c6ed7 2994
867b3b7d
LP		 2995 if (s->main_command &&
2996 s->main_command->command_next &&
f42806df 2997 f == SERVICE_SUCCESS) {
034c6ed7 2998
34e9ba66
LP		 2999 /* There is another command to *
3000 * execute, so let's do that. */
034c6ed7 3001
66870f90
ZJS		 3002 log_debug_unit(u->id,
3003 "%s running next main command for state %s",
3004 u->id, service_state_to_string(s->state));
f42806df 3005 service_run_next_main(s);
034c6ed7 3006
34e9ba66
LP		 3007 } else {
3008
3009 /* The service exited, so the service is officially
3010 * gone. */
867b3b7d 3011 s->main_command = NULL;
34e9ba66
LP		 3012
3013 switch (s->state) {
3014
3015 case SERVICE_START_POST:
3016 case SERVICE_RELOAD:
3017 case SERVICE_STOP:
3018 /* Need to wait until the operation is
3019 * done */
c4653a4d 3020 break;
7d55e835 3021
34e9ba66
LP		 3022 case SERVICE_START:
3023 if (s->type == SERVICE_ONESHOT) {
3024 /* This was our main goal, so let's go on */
f42806df 3025 if (f == SERVICE_SUCCESS)
34e9ba66
LP		 3026 service_enter_start_post(s);
3027 else
f42806df 3028 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
34e9ba66 3029 break;
34e9ba66 3030 }
034c6ed7 3031
bfba3256
LP		 3032 /* Fall through */
3033
34e9ba66 3034 case SERVICE_RUNNING:
f42806df 3035 service_enter_running(s, f);
34e9ba66 3036 break;
034c6ed7 3037
34e9ba66
LP		 3038 case SERVICE_STOP_SIGTERM:
3039 case SERVICE_STOP_SIGKILL:
5cb5a6ff 3040
34e9ba66 3041 if (!control_pid_good(s))
f42806df 3042 service_enter_stop_post(s, f);
5cb5a6ff 3043
34e9ba66
LP		 3044 /* If there is still a control process, wait for that first */
3045 break;
3046
3047 default:
3048 assert_not_reached("Uh, main process died at wrong time.");
3049 }
034c6ed7 3050 }
5cb5a6ff 3051
034c6ed7 3052 } else if (s->control_pid == pid) {
34e9ba66
LP		 3053 s->control_pid = 0;
3054
b708e7ce 3055 if (s->control_command) {
117dcc57
ZJS		 3056 exec_status_exit(&s->control_command->exec_status,
3057 &s->exec_context, pid, code, status);
a16e1123 3058
b708e7ce 3059 if (s->control_command->ignore)
f42806df 3060 f = SERVICE_SUCCESS;
b708e7ce
LP		 3061 }
3062
66870f90
ZJS		 3063 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3064 "%s: control process exited, code=%s status=%i",
3065 u->id, sigchld_code_to_string(code), status);
f42806df
LP		 3066
3067 if (f != SERVICE_SUCCESS)
3068 s->result = f;
034c6ed7 3069
88f3e0c9
LP		 3070 /* Immediately get rid of the cgroup, so that the
3071 * kernel doesn't delay the cgroup empty messages for
3072 * the service cgroup any longer than necessary */
4ad49000 3073 service_kill_control_processes(s);
88f3e0c9 3074
34e9ba66
LP		 3075 if (s->control_command &&
3076 s->control_command->command_next &&
f42806df 3077 f == SERVICE_SUCCESS) {
034c6ed7
LP		 3078
3079 /* There is another command to *
3080 * execute, so let's do that. */
3081
66870f90
ZJS		 3082 log_debug_unit(u->id,
3083 "%s running next control command for state %s",
3084 u->id, service_state_to_string(s->state));
f42806df 3085 service_run_next_control(s);
034c6ed7 3086
80876c20 3087 } else {
034c6ed7
LP		 3088 /* No further commands for this step, so let's
3089 * figure out what to do next */
3090
a16e1123
LP		 3091 s->control_command = NULL;
3092 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3093
66870f90
ZJS		 3094 log_debug_unit(u->id,
3095 "%s got final SIGCHLD for state %s",
3096 u->id, service_state_to_string(s->state));
bd982a8b 3097
034c6ed7
LP		 3098 switch (s->state) {
3099
3100 case SERVICE_START_PRE:
f42806df 3101 if (f == SERVICE_SUCCESS)
034c6ed7
LP		 3102 service_enter_start(s);
3103 else
f42806df 3104 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
034c6ed7
LP		 3105 break;
3106
3107 case SERVICE_START:
bfba3256
LP		 3108 if (s->type != SERVICE_FORKING)
3109 /* Maybe spurious event due to a reload that changed the type? */
3110 break;
034c6ed7 3111
f42806df
LP		 3112 if (f != SERVICE_SUCCESS) {
3113 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3a111838
MS		 3114 break;
3115 }
034c6ed7 3116
3a111838 3117 if (s->pid_file) {
f42806df
LP		 3118 bool has_start_post;
3119 int r;
3120
3a111838
MS		 3121 /* Let's try to load the pid file here if we can.
3122 * The PID file might actually be created by a START_POST
3123 * script. In that case don't worry if the loading fails. */
f42806df
LP		 3124
3125 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3126 r = service_load_pid_file(s, !has_start_post);
3a111838
MS		 3127 if (!has_start_post && r < 0) {
3128 r = service_demand_pid_file(s);
3129 if (r < 0 || !cgroup_good(s))
f42806df 3130 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3131 break;
3132 }
034c6ed7 3133 } else
3a111838 3134 service_search_main_pid(s);
034c6ed7 3135
3a111838 3136 service_enter_start_post(s);
034c6ed7
LP		 3137 break;
3138
3139 case SERVICE_START_POST:
f42806df
LP		 3140 if (f != SERVICE_SUCCESS) {
3141 service_enter_stop(s, f);
2096e009 3142 break;
034c6ed7
LP		 3143 }
3144
2096e009 3145 if (s->pid_file) {
f42806df
LP		 3146 int r;
3147
3148 r = service_load_pid_file(s, true);
2096e009
MS		 3149 if (r < 0) {
3150 r = service_demand_pid_file(s);
3151 if (r < 0 || !cgroup_good(s))
f42806df 3152 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2096e009
MS		 3153 break;
3154 }
3155 } else
3156 service_search_main_pid(s);
3157
f42806df 3158 service_enter_running(s, SERVICE_SUCCESS);
3185a36b 3159 break;
034c6ed7
LP		 3160
3161 case SERVICE_RELOAD:
f42806df 3162 if (f == SERVICE_SUCCESS) {
5375410b 3163 service_load_pid_file(s, true);
3185a36b
LP		 3164 service_search_main_pid(s);
3165 }
3166
f42806df
LP		 3167 s->reload_result = f;
3168 service_enter_running(s, SERVICE_SUCCESS);
034c6ed7
LP		 3169 break;
3170
3171 case SERVICE_STOP:
f42806df 3172 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
034c6ed7
LP		 3173 break;
3174
3175 case SERVICE_STOP_SIGTERM:
3176 case SERVICE_STOP_SIGKILL:
3177 if (main_pid_good(s) <= 0)
f42806df 3178 service_enter_stop_post(s, f);
034c6ed7
LP		 3179
3180 /* If there is still a service
3181 * process around, wait until
3182 * that one quit, too */
3183 break;
3184
3185 case SERVICE_STOP_POST:
3186 case SERVICE_FINAL_SIGTERM:
3187 case SERVICE_FINAL_SIGKILL:
f42806df 3188 service_enter_dead(s, f, true);
034c6ed7
LP		 3189 break;
3190
3191 default:
3192 assert_not_reached("Uh, control process died at wrong time.");
3193 }
3194 }
8c47c732 3195 }
c4e2ceae
LP		 3196
3197 /* Notify clients about changed exit status */
3198 unit_add_to_dbus_queue(u);
034c6ed7
LP		 3199}
3200
acbb0225 3201static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
87f0e418 3202 Service *s = SERVICE(u);
034c6ed7
LP		 3203
3204 assert(s);
3205 assert(elapsed == 1);
3206
bb242b7b
MO		 3207 if (w == &s->watchdog_watch) {
3208 service_handle_watchdog(s);
3209 return;
3210 }
3211
acbb0225 3212 assert(w == &s->timer_watch);
034c6ed7
LP		 3213
3214 switch (s->state) {
3215
3216 case SERVICE_START_PRE:
3217 case SERVICE_START:
66870f90
ZJS		 3218 log_warning_unit(u->id,
3219 "%s operation timed out. Terminating.", u->id);
f42806df 3220 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
80876c20
LP		 3221 break;
3222
034c6ed7 3223 case SERVICE_START_POST:
66870f90
ZJS		 3224 log_warning_unit(u->id,
3225 "%s operation timed out. Stopping.", u->id);
f42806df 3226 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3227 break;
3228
e2f3b44c 3229 case SERVICE_RELOAD:
66870f90
ZJS		 3230 log_warning_unit(u->id,
3231 "%s operation timed out. Stopping.", u->id);
f42806df
LP		 3232 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3233 service_enter_running(s, SERVICE_SUCCESS);
e2f3b44c
LP		 3234 break;
3235
034c6ed7 3236 case SERVICE_STOP:
66870f90
ZJS		 3237 log_warning_unit(u->id,
3238 "%s stopping timed out. Terminating.", u->id);
f42806df 3239 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3240 break;
3241
3242 case SERVICE_STOP_SIGTERM:
4819ff03 3243 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3244 log_warning_unit(u->id,
3245 "%s stopping timed out. Killing.", u->id);
f42806df 3246 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3247 } else {
66870f90
ZJS		 3248 log_warning_unit(u->id,
3249 "%s stopping timed out. Skipping SIGKILL.", u->id);
f42806df 3250 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
ba035df2
LP		 3251 }
3252
034c6ed7
LP		 3253 break;
3254
3255 case SERVICE_STOP_SIGKILL:
35b8ca3a 3256 /* Uh, we sent a SIGKILL and it is still not gone?
034c6ed7
LP		 3257 * Must be something we cannot kill, so let's just be
3258 * weirded out and continue */
3259
66870f90
ZJS		 3260 log_warning_unit(u->id,
3261 "%s still around after SIGKILL. Ignoring.", u->id);
f42806df 3262 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3263 break;
3264
3265 case SERVICE_STOP_POST:
66870f90
ZJS		 3266 log_warning_unit(u->id,
3267 "%s stopping timed out (2). Terminating.", u->id);
f42806df 3268 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
034c6ed7
LP		 3269 break;
3270
3271 case SERVICE_FINAL_SIGTERM:
4819ff03 3272 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 3273 log_warning_unit(u->id,
3274 "%s stopping timed out (2). Killing.", u->id);
f42806df 3275 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
ba035df2 3276 } else {
66870f90
ZJS		 3277 log_warning_unit(u->id,
3278 "%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.",
3279 u->id);
f42806df 3280 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
ba035df2
LP		 3281 }
3282
034c6ed7
LP		 3283 break;
3284
3285 case SERVICE_FINAL_SIGKILL:
66870f90
ZJS		 3286 log_warning_unit(u->id,
3287 "%s still around after SIGKILL (2). Entering failed mode.", u->id);
f42806df 3288 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
034c6ed7
LP		 3289 break;
3290
3291 case SERVICE_AUTO_RESTART:
66870f90
ZJS		 3292 log_info_unit(u->id,
3293 "%s holdoff time over, scheduling restart.", u->id);
034c6ed7
LP		 3294 service_enter_restart(s);
3295 break;
3296
3297 default:
3298 assert_not_reached("Timeout at wrong time.");
3299 }
5cb5a6ff
LP		 3300}
3301
4ad49000 3302static void service_notify_cgroup_empty_event(Unit *u) {
8e274523
LP		 3303 Service *s = SERVICE(u);
3304
3305 assert(u);
3306
6c12b52e 3307 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
8e274523
LP		 3308
3309 switch (s->state) {
3310
3311 /* Waiting for SIGCHLD is usually more interesting,
3312 * because it includes return codes/signals. Which is
3313 * why we ignore the cgroup events for most cases,
3314 * except when we don't know pid which to expect the
3315 * SIGCHLD for. */
3316
3a111838
MS		 3317 case SERVICE_START:
3318 case SERVICE_START_POST:
3319 /* If we were hoping for the daemon to write its PID file,
3320 * we can give up now. */
3321 if (s->pid_file_pathspec) {
66870f90
ZJS		 3322 log_warning_unit(u->id,
3323 "%s never wrote its PID file. Failing.", UNIT(s)->id);
3a111838
MS		 3324 service_unwatch_pid_file(s);
3325 if (s->state == SERVICE_START)
f42806df 3326 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3a111838 3327 else
f42806df 3328 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3a111838
MS		 3329 }
3330 break;
3331
8e274523 3332 case SERVICE_RUNNING:
f42806df
LP		 3333 /* service_enter_running() will figure out what to do */
3334 service_enter_running(s, SERVICE_SUCCESS);
8e274523
LP		 3335 break;
3336
28708d8a
LP		 3337 case SERVICE_STOP_SIGTERM:
3338 case SERVICE_STOP_SIGKILL:
6dfa5494 3339
28708d8a 3340 if (main_pid_good(s) <= 0 && !control_pid_good(s))
f42806df 3341 service_enter_stop_post(s, SERVICE_SUCCESS);
28708d8a
LP		 3342
3343 break;
3344
7f97f0fe
LP		 3345 case SERVICE_FINAL_SIGTERM:
3346 case SERVICE_FINAL_SIGKILL:
3347 if (main_pid_good(s) <= 0 && !control_pid_good(s))
e201a038 3348 service_enter_dead(s, SERVICE_SUCCESS, true);
7f97f0fe
LP		 3349
3350 break;
3351
8e274523
LP		 3352 default:
3353 ;
3354 }
3355}
3356
c952c6ec 3357static void service_notify_message(Unit *u, pid_t pid, char **tags) {
8c47c732
LP		 3358 Service *s = SERVICE(u);
3359 const char *e;
3360
3361 assert(u);
3362
c952c6ec 3363 if (s->notify_access == NOTIFY_NONE) {
66870f90
ZJS		 3364 log_warning_unit(u->id,
3365 "%s: Got notification message from PID %lu, but reception is disabled.",
3366 u->id, (unsigned long) pid);
c952c6ec
LP		 3367 return;
3368 }
3369
3370 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
66870f90
ZJS		 3371 log_warning_unit(u->id,
3372 "%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3373 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
c952c6ec
LP		 3374 return;
3375 }
3376
66870f90
ZJS		 3377 log_debug_unit(u->id,
3378 "%s: Got message", u->id);
8c47c732
LP		 3379
3380 /* Interpret MAINPID= */
3381 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3382 (s->state == SERVICE_START ||
3383 s->state == SERVICE_START_POST ||
3384 s->state == SERVICE_RUNNING ||
3385 s->state == SERVICE_RELOAD)) {
8c47c732 3386
5925dd3c 3387 if (parse_pid(e + 8, &pid) < 0)
66870f90
ZJS		 3388 log_warning_unit(u->id,
3389 "Failed to parse notification message %s", e);
8c47c732 3390 else {
66870f90
ZJS		 3391 log_debug_unit(u->id,
3392 "%s: got %s", u->id, e);
5925dd3c 3393 service_set_main_pid(s, pid);
8c47c732
LP		 3394 }
3395 }
3396
3397 /* Interpret READY= */
3398 if (s->type == SERVICE_NOTIFY &&
3399 s->state == SERVICE_START &&
3400 strv_find(tags, "READY=1")) {
66870f90
ZJS		 3401 log_debug_unit(u->id,
3402 "%s: got READY=1", u->id);
8c47c732
LP		 3403
3404 service_enter_start_post(s);
3405 }
3406
3407 /* Interpret STATUS= */
7f110ff9
LP		 3408 e = strv_find_prefix(tags, "STATUS=");
3409 if (e) {
8c47c732
LP		 3410 char *t;
3411
3a2776bc 3412 if (e[7]) {
7f110ff9
LP		 3413
3414 if (!utf8_is_valid(e+7)) {
66870f90
ZJS		 3415 log_warning_unit(u->id,
3416 "Status message in notification is not UTF-8 clean.");
7f110ff9
LP		 3417 return;
3418 }
3419
3420 t = strdup(e+7);
3421 if (!t) {
66870f90
ZJS		 3422 log_error_unit(u->id,
3423 "Failed to allocate string.");
3a2776bc
LP		 3424 return;
3425 }
3426
66870f90
ZJS		 3427 log_debug_unit(u->id,
3428 "%s: got %s", u->id, e);
8c47c732 3429
3a2776bc
LP		 3430 free(s->status_text);
3431 s->status_text = t;
3432 } else {
3433 free(s->status_text);
3434 s->status_text = NULL;
3435 }
8c47c732 3436
8c47c732 3437 }
a6927d7f 3438 if (strv_find(tags, "WATCHDOG=1")) {
66870f90
ZJS		 3439 log_debug_unit(u->id,
3440 "%s: got WATCHDOG=1", u->id);
90527fbb
MO		 3441 if (dual_timestamp_is_set(&s->watchdog_timestamp))
3442 service_reset_watchdog(s);
a6927d7f 3443 }
c4e2ceae
LP		 3444
3445 /* Notify clients about changed status or main pid */
3446 unit_add_to_dbus_queue(u);
8c47c732
LP		 3447}
3448
07459bb6 3449#ifdef HAVE_SYSV_COMPAT
de3910a3 3450
2c4104f0 3451static int service_enumerate(Manager *m) {
2c4104f0
LP		 3452 char **p;
3453 unsigned i;
7fd1b19b
HH		 3454 _cleanup_closedir_ DIR *d = NULL;
3455 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
b92bea5d 3456 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
7fd1b19b 3457 _cleanup_set_free_ Set *shutdown_services = NULL;
c68364b7
LP		 3458 Unit *service;
3459 Iterator j;
2c4104f0
LP		 3460 int r;
3461
3462 assert(m);
3463
67445f4e 3464 if (m->running_as != SYSTEMD_SYSTEM)
b1bc08e5
LP		 3465 return 0;
3466
84e3543e 3467 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
09cd1ab1 3468 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
2c4104f0
LP		 3469 struct dirent *de;
3470
3471 free(path);
b7def684 3472 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
70132bd0 3473 if (!path) {
2c4104f0
LP		 3474 r = -ENOMEM;
3475 goto finish;
3476 }
3477
3478 if (d)
3479 closedir(d);
3480
117dcc57
ZJS		 3481 d = opendir(path);
3482 if (!d) {
2c4104f0 3483 if (errno != ENOENT)
117dcc57 3484 log_warning("opendir(%s) failed: %s", path, strerror(errno));
2c4104f0
LP		 3485
3486 continue;
3487 }
3488
3489 while ((de = readdir(d))) {
db06e3b6 3490 int a, b;
2c4104f0
LP		 3491
3492 if (ignore_file(de->d_name))
3493 continue;
3494
3495 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3496 continue;
3497
3498 if (strlen(de->d_name) < 4)
3499 continue;
3500
db06e3b6
LP		 3501 a = undecchar(de->d_name[1]);
3502 b = undecchar(de->d_name[2]);
3503
3504 if (a < 0 || b < 0)
3505 continue;
3506
2c4104f0 3507 free(fpath);
b7def684 3508 fpath = strjoin(path, "/", de->d_name, NULL);
8ea913b2 3509 if (!fpath) {
2c4104f0
LP		 3510 r = -ENOMEM;
3511 goto finish;
3512 }
3513
3514 if (access(fpath, X_OK) < 0) {
3515
3516 if (errno != ENOENT)
3517 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3518
3519 continue;
3520 }
3521
3522 free(name);
117dcc57
ZJS		 3523 name = sysv_translate_name(de->d_name + 3);
3524 if (!name) {
3525 r = log_oom();
2c4104f0
LP		 3526 goto finish;
3527 }
3528
66870f90
ZJS		 3529 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3530 if (r < 0) {
fbe9f3a9
LP		 3531 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3532 continue;
3533 }
2c4104f0 3534
c68364b7
LP		 3535 if (de->d_name[0] == 'S') {
3536
3cdebc21 3537 if (rcnd_table[i].type == RUNLEVEL_UP) {
ea87ca5a
LP		 3538 SERVICE(service)->sysv_start_priority_from_rcnd =
3539 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
db06e3b6 3540
c68364b7 3541 SERVICE(service)->sysv_enabled = true;
f73d93a4 3542 }
db06e3b6 3543
117dcc57
ZJS		 3544 r = set_ensure_allocated(&runlevel_services[i],
3545 trivial_hash_func, trivial_compare_func);
3546 if (r < 0)
c68364b7 3547 goto finish;
2c4104f0 3548
117dcc57
ZJS		 3549 r = set_put(runlevel_services[i], service);
3550 if (r < 0)
2c4104f0 3551 goto finish;
23a177ef 3552
fc5df99e 3553 } else if (de->d_name[0] == 'K' &&
3cdebc21 3554 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
6542952f 3555
117dcc57
ZJS		 3556 r = set_ensure_allocated(&shutdown_services,
3557 trivial_hash_func, trivial_compare_func);
3558 if (r < 0)
c68364b7
LP		 3559 goto finish;
3560
117dcc57
ZJS		 3561 r = set_put(shutdown_services, service);
3562 if (r < 0)
2c4104f0
LP		 3563 goto finish;
3564 }
3565 }
3566 }
3567
c68364b7
LP		 3568 /* Now we loaded all stubs and are aware of the lowest
3569 start-up priority for all services, not let's actually load
3570 the services, this will also tell us which services are
3571 actually native now */
3572 manager_dispatch_load_queue(m);
3573
3574 /* If this is a native service, rely on native ways to pull in
3575 * a service, don't pull it in via sysv rcN.d links. */
3576 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3577 SET_FOREACH(service, runlevel_services[i], j) {
3578 service = unit_follow_merge(service);
3579
ac155bb8 3580 if (service->fragment_path)
c68364b7
LP		 3581 continue;
3582
117dcc57
ZJS		 3583 r = unit_add_two_dependencies_by_name_inverse(
3584 service, UNIT_AFTER, UNIT_WANTS,
3585 rcnd_table[i].target, NULL, true);
3586 if (r < 0)
c68364b7
LP		 3587 goto finish;
3588 }
3589
3590 /* We honour K links only for halt/reboot. For the normal
3591 * runlevels we assume the stop jobs will be implicitly added
35b8ca3a 3592 * by the core logic. Also, we don't really distinguish here
c68364b7 3593 * between the runlevels 0 and 6 and just add them to the
3cdebc21 3594 * special shutdown target. */
c68364b7
LP		 3595 SET_FOREACH(service, shutdown_services, j) {
3596 service = unit_follow_merge(service);
3597
ac155bb8 3598 if (service->fragment_path)
c68364b7
LP		 3599 continue;
3600
117dcc57
ZJS		 3601 r = unit_add_two_dependencies_by_name(
3602 service, UNIT_BEFORE, UNIT_CONFLICTS,
3603 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3604 if (r < 0)
c68364b7
LP		 3605 goto finish;
3606 }
3607
2c4104f0
LP		 3608 r = 0;
3609
3610finish:
fbe9f3a9 3611
c68364b7
LP		 3612 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3613 set_free(runlevel_services[i]);
2c4104f0
LP		 3614
3615 return r;
3616}
07459bb6 3617#endif
2c4104f0 3618
05e343b7
LP		 3619static void service_bus_name_owner_change(
3620 Unit *u,
3621 const char *name,
3622 const char *old_owner,
3623 const char *new_owner) {
3624
3625 Service *s = SERVICE(u);
3626
3627 assert(s);
3628 assert(name);
3629
3630 assert(streq(s->bus_name, name));
3631 assert(old_owner || new_owner);
3632
3633 if (old_owner && new_owner)
66870f90
ZJS		 3634 log_debug_unit(u->id,
3635 "%s's D-Bus name %s changed owner from %s to %s",
3636 u->id, name, old_owner, new_owner);
05e343b7 3637 else if (old_owner)
66870f90
ZJS		 3638 log_debug_unit(u->id,
3639 "%s's D-Bus name %s no longer registered by %s",
3640 u->id, name, old_owner);
05e343b7 3641 else
66870f90
ZJS		 3642 log_debug_unit(u->id,
3643 "%s's D-Bus name %s now registered by %s",
3644 u->id, name, new_owner);
05e343b7
LP		 3645
3646 s->bus_name_good = !!new_owner;
3647
3648 if (s->type == SERVICE_DBUS) {
3649
3650 /* service_enter_running() will figure out what to
3651 * do */
3652 if (s->state == SERVICE_RUNNING)
f42806df 3653 service_enter_running(s, SERVICE_SUCCESS);
05e343b7
LP		 3654 else if (s->state == SERVICE_START && new_owner)
3655 service_enter_start_post(s);
3656
3657 } else if (new_owner &&
3658 s->main_pid <= 0 &&
3659 (s->state == SERVICE_START ||
3660 s->state == SERVICE_START_POST ||
3661 s->state == SERVICE_RUNNING ||
3662 s->state == SERVICE_RELOAD)) {
3663
3664 /* Try to acquire PID from bus service */
66870f90
ZJS		 3665 log_debug_unit(u->id,
3666 "Trying to acquire PID from D-Bus name...");
05e343b7 3667
ac155bb8 3668 bus_query_pid(u->manager, name);
05e343b7
LP		 3669 }
3670}
3671
3672static void service_bus_query_pid_done(
3673 Unit *u,
3674 const char *name,
3675 pid_t pid) {
3676
3677 Service *s = SERVICE(u);
3678
3679 assert(s);
3680 assert(name);
3681
66870f90
ZJS		 3682 log_debug_unit(u->id,
3683 "%s's D-Bus name %s is now owned by process %u",
3684 u->id, name, (unsigned) pid);
05e343b7
LP		 3685
3686 if (s->main_pid <= 0 &&
3687 (s->state == SERVICE_START ||
3688 s->state == SERVICE_START_POST ||
3689 s->state == SERVICE_RUNNING ||
3690 s->state == SERVICE_RELOAD))
5925dd3c 3691 service_set_main_pid(s, pid);
05e343b7
LP		 3692}
3693
6cf6bbc2 3694int service_set_socket_fd(Service *s, int fd, Socket *sock) {
57020a3a 3695
4f2d528d
LP		 3696 assert(s);
3697 assert(fd >= 0);
3698
3699 /* This is called by the socket code when instantiating a new
3700 * service for a stream socket and the socket needs to be
3701 * configured. */
3702
1124fe6f 3703 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 3704 return -EINVAL;
3705
3706 if (s->socket_fd >= 0)
3707 return -EBUSY;
3708
3709 if (s->state != SERVICE_DEAD)
3710 return -EAGAIN;
3711
3712 s->socket_fd = fd;
701cc384 3713 s->got_socket_fd = true;
6cf6bbc2 3714
57020a3a
LP		 3715 unit_ref_set(&s->accept_socket, UNIT(sock));
3716
3717 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
4f2d528d
LP		 3718}
3719
fdf20a31 3720static void service_reset_failed(Unit *u) {
5632e374
LP		 3721 Service *s = SERVICE(u);
3722
3723 assert(s);
3724
fdf20a31 3725 if (s->state == SERVICE_FAILED)
5632e374
LP		 3726 service_set_state(s, SERVICE_DEAD);
3727
f42806df
LP		 3728 s->result = SERVICE_SUCCESS;
3729 s->reload_result = SERVICE_SUCCESS;
451b34cc
LP		 3730
3731 RATELIMIT_RESET(s->start_limit);
5632e374
LP		 3732}
3733
c74f17d9 3734static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
8a0867d6 3735 Service *s = SERVICE(u);
41efeaec 3736
814cc562 3737 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
8a0867d6
LP		 3738}
3739
94f04347
LP		 3740static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3741 [SERVICE_DEAD] = "dead",
3742 [SERVICE_START_PRE] = "start-pre",
3743 [SERVICE_START] = "start",
3744 [SERVICE_START_POST] = "start-post",
3745 [SERVICE_RUNNING] = "running",
80876c20 3746 [SERVICE_EXITED] = "exited",
94f04347
LP		 3747 [SERVICE_RELOAD] = "reload",
3748 [SERVICE_STOP] = "stop",
3749 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3750 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3751 [SERVICE_STOP_POST] = "stop-post",
3752 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3753 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 3754 [SERVICE_FAILED] = "failed",
94f04347
LP		 3755 [SERVICE_AUTO_RESTART] = "auto-restart",
3756};
3757
3758DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3759
3760static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
525ee6f4
LP		 3761 [SERVICE_RESTART_NO] = "no",
3762 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
50caaedb 3763 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
dc99a976 3764 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
50caaedb
LP		 3765 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3766 [SERVICE_RESTART_ALWAYS] = "always"
94f04347
LP		 3767};
3768
3769DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3770
3771static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
94f04347 3772 [SERVICE_SIMPLE] = "simple",
0d624a78 3773 [SERVICE_FORKING] = "forking",
34e9ba66 3774 [SERVICE_ONESHOT] = "oneshot",
8c47c732 3775 [SERVICE_DBUS] = "dbus",
f2b68789
LP		 3776 [SERVICE_NOTIFY] = "notify",
3777 [SERVICE_IDLE] = "idle"
94f04347
LP		 3778};
3779
3780DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3781
e537352b 3782static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
94f04347
LP		 3783 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3784 [SERVICE_EXEC_START] = "ExecStart",
3785 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3786 [SERVICE_EXEC_RELOAD] = "ExecReload",
3787 [SERVICE_EXEC_STOP] = "ExecStop",
3788 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3789};
3790
3791DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3792
c952c6ec
LP		 3793static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3794 [NOTIFY_NONE] = "none",
3795 [NOTIFY_MAIN] = "main",
3796 [NOTIFY_ALL] = "all"
3797};
3798
3799DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3800
f42806df
LP		 3801static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3802 [SERVICE_SUCCESS] = "success",
3803 [SERVICE_FAILURE_RESOURCES] = "resources",
3804 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3805 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3806 [SERVICE_FAILURE_SIGNAL] = "signal",
bb242b7b 3807 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
8d1b002a
LP		 3808 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3809 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
f42806df
LP		 3810};
3811
3812DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3813
4b939747
MO		 3814static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3815 [SERVICE_START_LIMIT_NONE] = "none",
3816 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3817 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3818 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3819};
3820DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3821
87f0e418 3822const UnitVTable service_vtable = {
7d17cfbc 3823 .object_size = sizeof(Service),
3ef63c31 3824
f975e971
LP		 3825 .sections =
3826 "Unit\0"
3827 "Service\0"
3828 "Install\0",
5cb5a6ff 3829
4ad49000 3830 .private_section = "Service",
71645aca 3831 .exec_context_offset = offsetof(Service, exec_context),
4ad49000 3832 .cgroup_context_offset = offsetof(Service, cgroup_context),
71645aca 3833
034c6ed7
LP		 3834 .init = service_init,
3835 .done = service_done,
a16e1123
LP		 3836 .load = service_load,
3837
3838 .coldplug = service_coldplug,
034c6ed7 3839
5cb5a6ff
LP		 3840 .dump = service_dump,
3841
3842 .start = service_start,
3843 .stop = service_stop,
3844 .reload = service_reload,
3845
034c6ed7
LP		 3846 .can_reload = service_can_reload,
3847
8a0867d6
LP		 3848 .kill = service_kill,
3849
a16e1123
LP		 3850 .serialize = service_serialize,
3851 .deserialize_item = service_deserialize_item,
3852
5cb5a6ff 3853 .active_state = service_active_state,
10a94420 3854 .sub_state_to_string = service_sub_state_to_string,
5cb5a6ff 3855
701cc384
LP		 3856 .check_gc = service_check_gc,
3857 .check_snapshot = service_check_snapshot,
3858
034c6ed7
LP		 3859 .sigchld_event = service_sigchld_event,
3860 .timer_event = service_timer_event,
3a111838 3861 .fd_event = service_fd_event,
2c4104f0 3862
fdf20a31 3863 .reset_failed = service_reset_failed,
5632e374 3864
4ad49000 3865 .notify_cgroup_empty = service_notify_cgroup_empty_event,
8c47c732 3866 .notify_message = service_notify_message,
8e274523 3867
05e343b7
LP		 3868 .bus_name_owner_change = service_bus_name_owner_change,
3869 .bus_query_pid_done = service_bus_query_pid_done,
3870
c4e2ceae 3871 .bus_interface = "org.freedesktop.systemd1.Service",
4139c1b2 3872 .bus_message_handler = bus_service_message_handler,
c4e2ceae 3873 .bus_invalidating_properties = bus_service_invalidating_properties,
74c964d3
LP		 3874 .bus_set_property = bus_service_set_property,
3875 .bus_commit_properties = bus_service_commit_properties,
4139c1b2 3876
c2756a68
LP		 3877 .can_transient = true,
3878
07459bb6 3879#ifdef HAVE_SYSV_COMPAT
c6918296 3880 .enumerate = service_enumerate,
07459bb6 3881#endif
c6918296
MS		 3882 .status_message_formats = {
3883 .starting_stopping = {
3884 [0] = "Starting %s...",
3885 [1] = "Stopping %s...",
3886 },
3887 .finished_start_job = {
3888 [JOB_DONE] = "Started %s.",
3889 [JOB_FAILED] = "Failed to start %s.",
3890 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3891 [JOB_TIMEOUT] = "Timed out starting %s.",
3892 },
3893 .finished_stop_job = {
3894 [JOB_DONE] = "Stopped %s.",
3895 [JOB_FAILED] = "Stopped (with error) %s.",
3896 [JOB_TIMEOUT] = "Timed out stopping %s.",
3897 },
3898 },
5cb5a6ff 3899};
Unnamed repository; edit this file 'description' to name the repository.