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