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