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