]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/service.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
core: rework job_get_timeout() to use usec_t and handle USEC_INFINITY time events...
[thirdparty/systemd.git] / src / core / service.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
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
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
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
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <signal.h>
24 #include <unistd.h>
25
26 #include "alloc-util.h"
27 #include "async.h"
28 #include "bus-error.h"
29 #include "bus-kernel.h"
30 #include "bus-util.h"
31 #include "dbus-service.h"
32 #include "def.h"
33 #include "env-util.h"
34 #include "escape.h"
35 #include "exit-status.h"
36 #include "fd-util.h"
37 #include "fileio.h"
38 #include "formats-util.h"
39 #include "fs-util.h"
40 #include "load-dropin.h"
41 #include "load-fragment.h"
42 #include "log.h"
43 #include "manager.h"
44 #include "parse-util.h"
45 #include "path-util.h"
46 #include "process-util.h"
47 #include "service.h"
48 #include "signal-util.h"
49 #include "special.h"
50 #include "string-table.h"
51 #include "string-util.h"
52 #include "strv.h"
53 #include "unit-name.h"
54 #include "unit-printf.h"
55 #include "unit.h"
56 #include "utf8.h"
57 #include "util.h"
58
59 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
60 [SERVICE_DEAD] = UNIT_INACTIVE,
61 [SERVICE_START_PRE] = UNIT_ACTIVATING,
62 [SERVICE_START] = UNIT_ACTIVATING,
63 [SERVICE_START_POST] = UNIT_ACTIVATING,
64 [SERVICE_RUNNING] = UNIT_ACTIVE,
65 [SERVICE_EXITED] = UNIT_ACTIVE,
66 [SERVICE_RELOAD] = UNIT_RELOADING,
67 [SERVICE_STOP] = UNIT_DEACTIVATING,
68 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
69 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
70 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
71 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
72 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
73 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
74 [SERVICE_FAILED] = UNIT_FAILED,
75 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
76 };
77
78 /* For Type=idle we never want to delay any other jobs, hence we
79 * consider idle jobs active as soon as we start working on them */
80 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
81 [SERVICE_DEAD] = UNIT_INACTIVE,
82 [SERVICE_START_PRE] = UNIT_ACTIVE,
83 [SERVICE_START] = UNIT_ACTIVE,
84 [SERVICE_START_POST] = UNIT_ACTIVE,
85 [SERVICE_RUNNING] = UNIT_ACTIVE,
86 [SERVICE_EXITED] = UNIT_ACTIVE,
87 [SERVICE_RELOAD] = UNIT_RELOADING,
88 [SERVICE_STOP] = UNIT_DEACTIVATING,
89 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
90 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
91 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
92 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
93 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
94 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
95 [SERVICE_FAILED] = UNIT_FAILED,
96 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
97 };
98
99 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
100 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
101 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
102
103 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
104 static void service_enter_reload_by_notify(Service *s);
105
106 static void service_init(Unit *u) {
107 Service *s = SERVICE(u);
108
109 assert(u);
110 assert(u->load_state == UNIT_STUB);
111
112 s->timeout_start_usec = u->manager->default_timeout_start_usec;
113 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
114 s->restart_usec = u->manager->default_restart_usec;
115 s->runtime_max_usec = USEC_INFINITY;
116 s->type = _SERVICE_TYPE_INVALID;
117 s->socket_fd = -1;
118 s->bus_endpoint_fd = -1;
119 s->stdin_fd = s->stdout_fd = s->stderr_fd = -1;
120 s->guess_main_pid = true;
121
122 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
123
124 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
125 }
126
127 static void service_unwatch_control_pid(Service *s) {
128 assert(s);
129
130 if (s->control_pid <= 0)
131 return;
132
133 unit_unwatch_pid(UNIT(s), s->control_pid);
134 s->control_pid = 0;
135 }
136
137 static void service_unwatch_main_pid(Service *s) {
138 assert(s);
139
140 if (s->main_pid <= 0)
141 return;
142
143 unit_unwatch_pid(UNIT(s), s->main_pid);
144 s->main_pid = 0;
145 }
146
147 static void service_unwatch_pid_file(Service *s) {
148 if (!s->pid_file_pathspec)
149 return;
150
151 log_unit_debug(UNIT(s), "Stopping watch for PID file %s", s->pid_file_pathspec->path);
152 path_spec_unwatch(s->pid_file_pathspec);
153 path_spec_done(s->pid_file_pathspec);
154 s->pid_file_pathspec = mfree(s->pid_file_pathspec);
155 }
156
157 static int service_set_main_pid(Service *s, pid_t pid) {
158 pid_t ppid;
159
160 assert(s);
161
162 if (pid <= 1)
163 return -EINVAL;
164
165 if (pid == getpid())
166 return -EINVAL;
167
168 if (s->main_pid == pid && s->main_pid_known)
169 return 0;
170
171 if (s->main_pid != pid) {
172 service_unwatch_main_pid(s);
173 exec_status_start(&s->main_exec_status, pid);
174 }
175
176 s->main_pid = pid;
177 s->main_pid_known = true;
178
179 if (get_process_ppid(pid, &ppid) >= 0 && ppid != getpid()) {
180 log_unit_warning(UNIT(s), "Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", pid);
181 s->main_pid_alien = true;
182 } else
183 s->main_pid_alien = false;
184
185 return 0;
186 }
187
188 static void service_close_socket_fd(Service *s) {
189 assert(s);
190
191 s->socket_fd = asynchronous_close(s->socket_fd);
192 }
193
194 static void service_connection_unref(Service *s) {
195 assert(s);
196
197 if (!UNIT_ISSET(s->accept_socket))
198 return;
199
200 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
201 unit_ref_unset(&s->accept_socket);
202 }
203
204 static void service_stop_watchdog(Service *s) {
205 assert(s);
206
207 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
208 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
209 }
210
211 static void service_start_watchdog(Service *s) {
212 int r;
213
214 assert(s);
215
216 if (s->watchdog_usec <= 0)
217 return;
218
219 if (s->watchdog_event_source) {
220 r = sd_event_source_set_time(s->watchdog_event_source, usec_add(s->watchdog_timestamp.monotonic, s->watchdog_usec));
221 if (r < 0) {
222 log_unit_warning_errno(UNIT(s), r, "Failed to reset watchdog timer: %m");
223 return;
224 }
225
226 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
227 } else {
228 r = sd_event_add_time(
229 UNIT(s)->manager->event,
230 &s->watchdog_event_source,
231 CLOCK_MONOTONIC,
232 usec_add(s->watchdog_timestamp.monotonic, s->watchdog_usec), 0,
233 service_dispatch_watchdog, s);
234 if (r < 0) {
235 log_unit_warning_errno(UNIT(s), r, "Failed to add watchdog timer: %m");
236 return;
237 }
238
239 (void) sd_event_source_set_description(s->watchdog_event_source, "service-watchdog");
240
241 /* Let's process everything else which might be a sign
242 * of living before we consider a service died. */
243 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
244 }
245
246 if (r < 0)
247 log_unit_warning_errno(UNIT(s), r, "Failed to install watchdog timer: %m");
248 }
249
250 static void service_reset_watchdog(Service *s) {
251 assert(s);
252
253 dual_timestamp_get(&s->watchdog_timestamp);
254 service_start_watchdog(s);
255 }
256
257 static void service_fd_store_unlink(ServiceFDStore *fs) {
258
259 if (!fs)
260 return;
261
262 if (fs->service) {
263 assert(fs->service->n_fd_store > 0);
264 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
265 fs->service->n_fd_store--;
266 }
267
268 if (fs->event_source) {
269 sd_event_source_set_enabled(fs->event_source, SD_EVENT_OFF);
270 sd_event_source_unref(fs->event_source);
271 }
272
273 free(fs->fdname);
274 safe_close(fs->fd);
275 free(fs);
276 }
277
278 static void service_release_resources(Unit *u) {
279 Service *s = SERVICE(u);
280
281 assert(s);
282
283 if (!s->fd_store && s->stdin_fd < 0 && s->stdout_fd < 0 && s->stderr_fd < 0)
284 return;
285
286 log_unit_debug(u, "Releasing all resources.");
287
288 s->stdin_fd = safe_close(s->stdin_fd);
289 s->stdout_fd = safe_close(s->stdout_fd);
290 s->stderr_fd = safe_close(s->stderr_fd);
291
292 while (s->fd_store)
293 service_fd_store_unlink(s->fd_store);
294
295 assert(s->n_fd_store == 0);
296 }
297
298 static void service_done(Unit *u) {
299 Service *s = SERVICE(u);
300
301 assert(s);
302
303 s->pid_file = mfree(s->pid_file);
304 s->status_text = mfree(s->status_text);
305 s->reboot_arg = mfree(s->reboot_arg);
306
307 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
308 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
309 s->control_command = NULL;
310 s->main_command = NULL;
311
312 exit_status_set_free(&s->restart_prevent_status);
313 exit_status_set_free(&s->restart_force_status);
314 exit_status_set_free(&s->success_status);
315
316 /* This will leak a process, but at least no memory or any of
317 * our resources */
318 service_unwatch_main_pid(s);
319 service_unwatch_control_pid(s);
320 service_unwatch_pid_file(s);
321
322 if (s->bus_name) {
323 unit_unwatch_bus_name(u, s->bus_name);
324 s->bus_name = mfree(s->bus_name);
325 }
326
327 s->bus_name_owner = mfree(s->bus_name_owner);
328
329 s->bus_endpoint_fd = safe_close(s->bus_endpoint_fd);
330 service_close_socket_fd(s);
331 service_connection_unref(s);
332
333 unit_ref_unset(&s->accept_socket);
334
335 service_stop_watchdog(s);
336
337 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
338
339 service_release_resources(u);
340 }
341
342 static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
343 ServiceFDStore *fs = userdata;
344
345 assert(e);
346 assert(fs);
347
348 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
349 service_fd_store_unlink(fs);
350 return 0;
351 }
352
353 static int service_add_fd_store(Service *s, int fd, const char *name) {
354 ServiceFDStore *fs;
355 int r;
356
357 assert(s);
358 assert(fd >= 0);
359
360 if (s->n_fd_store >= s->n_fd_store_max)
361 return 0;
362
363 LIST_FOREACH(fd_store, fs, s->fd_store) {
364 r = same_fd(fs->fd, fd);
365 if (r < 0)
366 return r;
367 if (r > 0) {
368 /* Already included */
369 safe_close(fd);
370 return 1;
371 }
372 }
373
374 fs = new0(ServiceFDStore, 1);
375 if (!fs)
376 return -ENOMEM;
377
378 fs->fd = fd;
379 fs->service = s;
380 fs->fdname = strdup(name ?: "stored");
381 if (!fs->fdname) {
382 free(fs);
383 return -ENOMEM;
384 }
385
386 r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
387 if (r < 0) {
388 free(fs->fdname);
389 free(fs);
390 return r;
391 }
392
393 (void) sd_event_source_set_description(fs->event_source, "service-fd-store");
394
395 LIST_PREPEND(fd_store, s->fd_store, fs);
396 s->n_fd_store++;
397
398 return 1;
399 }
400
401 static int service_add_fd_store_set(Service *s, FDSet *fds, const char *name) {
402 int r;
403
404 assert(s);
405
406 if (fdset_size(fds) <= 0)
407 return 0;
408
409 while (s->n_fd_store < s->n_fd_store_max) {
410 _cleanup_close_ int fd = -1;
411
412 fd = fdset_steal_first(fds);
413 if (fd < 0)
414 break;
415
416 r = service_add_fd_store(s, fd, name);
417 if (r < 0)
418 return log_unit_error_errno(UNIT(s), r, "Couldn't add fd to fd store: %m");
419 if (r > 0) {
420 log_unit_debug(UNIT(s), "Added fd to fd store.");
421 fd = -1;
422 }
423 }
424
425 if (fdset_size(fds) > 0)
426 log_unit_warning(UNIT(s), "Tried to store more fds than FileDescriptorStoreMax=%u allows, closing remaining.", s->n_fd_store_max);
427
428 return 0;
429 }
430
431 static int service_arm_timer(Service *s, usec_t usec) {
432 int r;
433
434 assert(s);
435
436 if (s->timer_event_source) {
437 r = sd_event_source_set_time(s->timer_event_source, usec);
438 if (r < 0)
439 return r;
440
441 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
442 }
443
444 if (usec == USEC_INFINITY)
445 return 0;
446
447 r = sd_event_add_time(
448 UNIT(s)->manager->event,
449 &s->timer_event_source,
450 CLOCK_MONOTONIC,
451 usec, 0,
452 service_dispatch_timer, s);
453 if (r < 0)
454 return r;
455
456 (void) sd_event_source_set_description(s->timer_event_source, "service-timer");
457
458 return 0;
459 }
460
461 static int service_verify(Service *s) {
462 assert(s);
463
464 if (UNIT(s)->load_state != UNIT_LOADED)
465 return 0;
466
467 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
468 log_unit_error(UNIT(s), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
469 return -EINVAL;
470 }
471
472 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
473 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
474 return -EINVAL;
475 }
476
477 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
478 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
479 return -EINVAL;
480 }
481
482 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
483 log_unit_error(UNIT(s), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
484 return -EINVAL;
485 }
486
487 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
488 log_unit_error(UNIT(s), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
489 return -EINVAL;
490 }
491
492 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
493 log_unit_error(UNIT(s), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
494 return -EINVAL;
495 }
496
497 if (s->type == SERVICE_DBUS && !s->bus_name) {
498 log_unit_error(UNIT(s), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
499 return -EINVAL;
500 }
501
502 if (s->bus_name && s->type != SERVICE_DBUS)
503 log_unit_warning(UNIT(s), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
504
505 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
506 log_unit_error(UNIT(s), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
507 return -EINVAL;
508 }
509
510 if (s->usb_function_descriptors && !s->usb_function_strings)
511 log_unit_warning(UNIT(s), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
512
513 if (!s->usb_function_descriptors && s->usb_function_strings)
514 log_unit_warning(UNIT(s), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
515
516 if (s->runtime_max_usec != USEC_INFINITY && s->type == SERVICE_ONESHOT)
517 log_unit_warning(UNIT(s), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
518
519 return 0;
520 }
521
522 static int service_add_default_dependencies(Service *s) {
523 int r;
524
525 assert(s);
526
527 if (!UNIT(s)->default_dependencies)
528 return 0;
529
530 /* Add a number of automatic dependencies useful for the
531 * majority of services. */
532
533 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
534 /* First, pull in the really early boot stuff, and
535 * require it, so that we fail if we can't acquire
536 * it. */
537
538 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
539 if (r < 0)
540 return r;
541 } else {
542
543 /* In the --user instance there's no sysinit.target,
544 * in that case require basic.target instead. */
545
546 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
547 if (r < 0)
548 return r;
549 }
550
551 /* Second, if the rest of the base system is in the same
552 * transaction, order us after it, but do not pull it in or
553 * even require it. */
554 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_BASIC_TARGET, NULL, true);
555 if (r < 0)
556 return r;
557
558 /* Third, add us in for normal shutdown. */
559 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
560 }
561
562 static void service_fix_output(Service *s) {
563 assert(s);
564
565 /* If nothing has been explicitly configured, patch default
566 * output in. If input is socket/tty we avoid this however,
567 * since in that case we want output to default to the same
568 * place as we read input from. */
569
570 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
571 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
572 s->exec_context.std_input == EXEC_INPUT_NULL)
573 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
574
575 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
576 s->exec_context.std_input == EXEC_INPUT_NULL)
577 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
578 }
579
580 static int service_setup_bus_name(Service *s) {
581 int r;
582
583 assert(s);
584
585 if (!s->bus_name)
586 return 0;
587
588 if (is_kdbus_available()) {
589 const char *n;
590
591 n = strjoina(s->bus_name, ".busname");
592 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, n, NULL, true);
593 if (r < 0)
594 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency to .busname unit: %m");
595
596 } else {
597 /* If kdbus is not available, we know the dbus socket is required, hence pull it in, and require it */
598 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true);
599 if (r < 0)
600 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
601 }
602
603 /* Regardless if kdbus is used or not, we always want to be ordered against dbus.socket if both are in the transaction. */
604 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_DBUS_SOCKET, NULL, true);
605 if (r < 0)
606 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
607
608 r = unit_watch_bus_name(UNIT(s), s->bus_name);
609 if (r == -EEXIST)
610 return log_unit_error_errno(UNIT(s), r, "Two services allocated for the same bus name %s, refusing operation.", s->bus_name);
611 if (r < 0)
612 return log_unit_error_errno(UNIT(s), r, "Cannot watch bus name %s: %m", s->bus_name);
613
614 return 0;
615 }
616
617 static int service_add_extras(Service *s) {
618 int r;
619
620 assert(s);
621
622 if (s->type == _SERVICE_TYPE_INVALID) {
623 /* Figure out a type automatically */
624 if (s->bus_name)
625 s->type = SERVICE_DBUS;
626 else if (s->exec_command[SERVICE_EXEC_START])
627 s->type = SERVICE_SIMPLE;
628 else
629 s->type = SERVICE_ONESHOT;
630 }
631
632 /* Oneshot services have disabled start timeout by default */
633 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
634 s->timeout_start_usec = USEC_INFINITY;
635
636 service_fix_output(s);
637
638 r = unit_patch_contexts(UNIT(s));
639 if (r < 0)
640 return r;
641
642 r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
643 if (r < 0)
644 return r;
645
646 r = unit_set_default_slice(UNIT(s));
647 if (r < 0)
648 return r;
649
650 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
651 s->notify_access = NOTIFY_MAIN;
652
653 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
654 s->notify_access = NOTIFY_MAIN;
655
656 r = service_add_default_dependencies(s);
657 if (r < 0)
658 return r;
659
660 r = service_setup_bus_name(s);
661 if (r < 0)
662 return r;
663
664 return 0;
665 }
666
667 static int service_load(Unit *u) {
668 Service *s = SERVICE(u);
669 int r;
670
671 assert(s);
672
673 /* Load a .service file */
674 r = unit_load_fragment(u);
675 if (r < 0)
676 return r;
677
678 /* Still nothing found? Then let's give up */
679 if (u->load_state == UNIT_STUB)
680 return -ENOENT;
681
682 /* This is a new unit? Then let's add in some extras */
683 if (u->load_state == UNIT_LOADED) {
684
685 /* We were able to load something, then let's add in
686 * the dropin directories. */
687 r = unit_load_dropin(u);
688 if (r < 0)
689 return r;
690
691 /* This is a new unit? Then let's add in some
692 * extras */
693 r = service_add_extras(s);
694 if (r < 0)
695 return r;
696 }
697
698 return service_verify(s);
699 }
700
701 static void service_dump(Unit *u, FILE *f, const char *prefix) {
702 ServiceExecCommand c;
703 Service *s = SERVICE(u);
704 const char *prefix2;
705
706 assert(s);
707
708 prefix = strempty(prefix);
709 prefix2 = strjoina(prefix, "\t");
710
711 fprintf(f,
712 "%sService State: %s\n"
713 "%sResult: %s\n"
714 "%sReload Result: %s\n"
715 "%sPermissionsStartOnly: %s\n"
716 "%sRootDirectoryStartOnly: %s\n"
717 "%sRemainAfterExit: %s\n"
718 "%sGuessMainPID: %s\n"
719 "%sType: %s\n"
720 "%sRestart: %s\n"
721 "%sNotifyAccess: %s\n"
722 "%sNotifyState: %s\n",
723 prefix, service_state_to_string(s->state),
724 prefix, service_result_to_string(s->result),
725 prefix, service_result_to_string(s->reload_result),
726 prefix, yes_no(s->permissions_start_only),
727 prefix, yes_no(s->root_directory_start_only),
728 prefix, yes_no(s->remain_after_exit),
729 prefix, yes_no(s->guess_main_pid),
730 prefix, service_type_to_string(s->type),
731 prefix, service_restart_to_string(s->restart),
732 prefix, notify_access_to_string(s->notify_access),
733 prefix, notify_state_to_string(s->notify_state));
734
735 if (s->control_pid > 0)
736 fprintf(f,
737 "%sControl PID: "PID_FMT"\n",
738 prefix, s->control_pid);
739
740 if (s->main_pid > 0)
741 fprintf(f,
742 "%sMain PID: "PID_FMT"\n"
743 "%sMain PID Known: %s\n"
744 "%sMain PID Alien: %s\n",
745 prefix, s->main_pid,
746 prefix, yes_no(s->main_pid_known),
747 prefix, yes_no(s->main_pid_alien));
748
749 if (s->pid_file)
750 fprintf(f,
751 "%sPIDFile: %s\n",
752 prefix, s->pid_file);
753
754 if (s->bus_name)
755 fprintf(f,
756 "%sBusName: %s\n"
757 "%sBus Name Good: %s\n",
758 prefix, s->bus_name,
759 prefix, yes_no(s->bus_name_good));
760
761 kill_context_dump(&s->kill_context, f, prefix);
762 exec_context_dump(&s->exec_context, f, prefix);
763
764 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
765
766 if (!s->exec_command[c])
767 continue;
768
769 fprintf(f, "%s-> %s:\n",
770 prefix, service_exec_command_to_string(c));
771
772 exec_command_dump_list(s->exec_command[c], f, prefix2);
773 }
774
775 if (s->status_text)
776 fprintf(f, "%sStatus Text: %s\n",
777 prefix, s->status_text);
778
779 if (s->n_fd_store_max > 0)
780 fprintf(f,
781 "%sFile Descriptor Store Max: %u\n"
782 "%sFile Descriptor Store Current: %u\n",
783 prefix, s->n_fd_store_max,
784 prefix, s->n_fd_store);
785 }
786
787 static int service_load_pid_file(Service *s, bool may_warn) {
788 _cleanup_free_ char *k = NULL;
789 int r;
790 pid_t pid;
791
792 assert(s);
793
794 if (!s->pid_file)
795 return -ENOENT;
796
797 r = read_one_line_file(s->pid_file, &k);
798 if (r < 0) {
799 if (may_warn)
800 log_unit_info_errno(UNIT(s), r, "PID file %s not readable (yet?) after %s: %m", s->pid_file, service_state_to_string(s->state));
801 return r;
802 }
803
804 r = parse_pid(k, &pid);
805 if (r < 0) {
806 if (may_warn)
807 log_unit_info_errno(UNIT(s), r, "Failed to read PID from file %s: %m", s->pid_file);
808 return r;
809 }
810
811 if (!pid_is_alive(pid)) {
812 if (may_warn)
813 log_unit_info(UNIT(s), "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
814 return -ESRCH;
815 }
816
817 if (s->main_pid_known) {
818 if (pid == s->main_pid)
819 return 0;
820
821 log_unit_debug(UNIT(s), "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
822
823 service_unwatch_main_pid(s);
824 s->main_pid_known = false;
825 } else
826 log_unit_debug(UNIT(s), "Main PID loaded: "PID_FMT, pid);
827
828 r = service_set_main_pid(s, pid);
829 if (r < 0)
830 return r;
831
832 r = unit_watch_pid(UNIT(s), pid);
833 if (r < 0) {
834 /* FIXME: we need to do something here */
835 log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" for service: %m", pid);
836 return r;
837 }
838
839 return 0;
840 }
841
842 static int service_search_main_pid(Service *s) {
843 pid_t pid = 0;
844 int r;
845
846 assert(s);
847
848 /* If we know it anyway, don't ever fallback to unreliable
849 * heuristics */
850 if (s->main_pid_known)
851 return 0;
852
853 if (!s->guess_main_pid)
854 return 0;
855
856 assert(s->main_pid <= 0);
857
858 r = unit_search_main_pid(UNIT(s), &pid);
859 if (r < 0)
860 return r;
861
862 log_unit_debug(UNIT(s), "Main PID guessed: "PID_FMT, pid);
863 r = service_set_main_pid(s, pid);
864 if (r < 0)
865 return r;
866
867 r = unit_watch_pid(UNIT(s), pid);
868 if (r < 0) {
869 /* FIXME: we need to do something here */
870 log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" from: %m", pid);
871 return r;
872 }
873
874 return 0;
875 }
876
877 static void service_set_state(Service *s, ServiceState state) {
878 ServiceState old_state;
879 const UnitActiveState *table;
880
881 assert(s);
882
883 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
884
885 old_state = s->state;
886 s->state = state;
887
888 service_unwatch_pid_file(s);
889
890 if (!IN_SET(state,
891 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
892 SERVICE_RUNNING,
893 SERVICE_RELOAD,
894 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
895 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
896 SERVICE_AUTO_RESTART))
897 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
898
899 if (!IN_SET(state,
900 SERVICE_START, SERVICE_START_POST,
901 SERVICE_RUNNING, SERVICE_RELOAD,
902 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
903 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
904 service_unwatch_main_pid(s);
905 s->main_command = NULL;
906 }
907
908 if (!IN_SET(state,
909 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
910 SERVICE_RELOAD,
911 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
912 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
913 service_unwatch_control_pid(s);
914 s->control_command = NULL;
915 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
916 }
917
918 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
919 unit_unwatch_all_pids(UNIT(s));
920
921 if (!IN_SET(state,
922 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
923 SERVICE_RUNNING, SERVICE_RELOAD,
924 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
925 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
926 !(state == SERVICE_DEAD && UNIT(s)->job)) {
927 service_close_socket_fd(s);
928 service_connection_unref(s);
929 }
930
931 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
932 service_stop_watchdog(s);
933
934 /* For the inactive states unit_notify() will trim the cgroup,
935 * but for exit we have to do that ourselves... */
936 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
937 unit_prune_cgroup(UNIT(s));
938
939 /* For remain_after_exit services, let's see if we can "release" the
940 * hold on the console, since unit_notify() only does that in case of
941 * change of state */
942 if (state == SERVICE_EXITED &&
943 s->remain_after_exit &&
944 UNIT(s)->manager->n_on_console > 0) {
945
946 ExecContext *ec;
947
948 ec = unit_get_exec_context(UNIT(s));
949 if (ec && exec_context_may_touch_console(ec)) {
950 Manager *m = UNIT(s)->manager;
951
952 m->n_on_console --;
953 if (m->n_on_console == 0)
954 /* unset no_console_output flag, since the console is free */
955 m->no_console_output = false;
956 }
957 }
958
959 if (old_state != state)
960 log_unit_debug(UNIT(s), "Changed %s -> %s", service_state_to_string(old_state), service_state_to_string(state));
961
962 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
963 }
964
965 static usec_t service_coldplug_timeout(Service *s) {
966 assert(s);
967
968 switch (s->deserialized_state) {
969
970 case SERVICE_START_PRE:
971 case SERVICE_START:
972 case SERVICE_START_POST:
973 case SERVICE_RELOAD:
974 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_start_usec);
975
976 case SERVICE_RUNNING:
977 return usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec);
978
979 case SERVICE_STOP:
980 case SERVICE_STOP_SIGABRT:
981 case SERVICE_STOP_SIGTERM:
982 case SERVICE_STOP_SIGKILL:
983 case SERVICE_STOP_POST:
984 case SERVICE_FINAL_SIGTERM:
985 case SERVICE_FINAL_SIGKILL:
986 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_stop_usec);
987
988 case SERVICE_AUTO_RESTART:
989 return usec_add(UNIT(s)->inactive_enter_timestamp.monotonic, s->restart_usec);
990
991 default:
992 return USEC_INFINITY;
993 }
994 }
995
996 static int service_coldplug(Unit *u) {
997 Service *s = SERVICE(u);
998 int r;
999
1000 assert(s);
1001 assert(s->state == SERVICE_DEAD);
1002
1003 if (s->deserialized_state == s->state)
1004 return 0;
1005
1006 r = service_arm_timer(s, service_coldplug_timeout(s));
1007 if (r < 0)
1008 return r;
1009
1010 if (s->main_pid > 0 &&
1011 pid_is_unwaited(s->main_pid) &&
1012 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
1013 IN_SET(s->deserialized_state,
1014 SERVICE_START, SERVICE_START_POST,
1015 SERVICE_RUNNING, SERVICE_RELOAD,
1016 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1017 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1018 r = unit_watch_pid(UNIT(s), s->main_pid);
1019 if (r < 0)
1020 return r;
1021 }
1022
1023 if (s->control_pid > 0 &&
1024 pid_is_unwaited(s->control_pid) &&
1025 IN_SET(s->deserialized_state,
1026 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1027 SERVICE_RELOAD,
1028 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1029 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1030 r = unit_watch_pid(UNIT(s), s->control_pid);
1031 if (r < 0)
1032 return r;
1033 }
1034
1035 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1036 unit_watch_all_pids(UNIT(s));
1037
1038 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1039 service_start_watchdog(s);
1040
1041 service_set_state(s, s->deserialized_state);
1042 return 0;
1043 }
1044
1045 static int service_collect_fds(Service *s, int **fds, char ***fd_names) {
1046 _cleanup_strv_free_ char **rfd_names = NULL;
1047 _cleanup_free_ int *rfds = NULL;
1048 int rn_fds = 0, r;
1049
1050 assert(s);
1051 assert(fds);
1052 assert(fd_names);
1053
1054 if (s->socket_fd >= 0) {
1055
1056 /* Pass the per-connection socket */
1057
1058 rfds = new(int, 1);
1059 if (!rfds)
1060 return -ENOMEM;
1061 rfds[0] = s->socket_fd;
1062
1063 rfd_names = strv_new("connection", NULL);
1064 if (!rfd_names)
1065 return -ENOMEM;
1066
1067 rn_fds = 1;
1068 } else {
1069 Iterator i;
1070 Unit *u;
1071
1072 /* Pass all our configured sockets for singleton services */
1073
1074 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1075 _cleanup_free_ int *cfds = NULL;
1076 Socket *sock;
1077 int cn_fds;
1078
1079 if (u->type != UNIT_SOCKET)
1080 continue;
1081
1082 sock = SOCKET(u);
1083
1084 cn_fds = socket_collect_fds(sock, &cfds);
1085 if (cn_fds < 0)
1086 return cn_fds;
1087
1088 if (cn_fds <= 0)
1089 continue;
1090
1091 if (!rfds) {
1092 rfds = cfds;
1093 rn_fds = cn_fds;
1094
1095 cfds = NULL;
1096 } else {
1097 int *t;
1098
1099 t = realloc(rfds, (rn_fds + cn_fds) * sizeof(int));
1100 if (!t)
1101 return -ENOMEM;
1102
1103 memcpy(t + rn_fds, cfds, cn_fds * sizeof(int));
1104
1105 rfds = t;
1106 rn_fds += cn_fds;
1107 }
1108
1109 r = strv_extend_n(&rfd_names, socket_fdname(sock), cn_fds);
1110 if (r < 0)
1111 return r;
1112 }
1113 }
1114
1115 if (s->n_fd_store > 0) {
1116 ServiceFDStore *fs;
1117 char **nl;
1118 int *t;
1119
1120 t = realloc(rfds, (rn_fds + s->n_fd_store) * sizeof(int));
1121 if (!t)
1122 return -ENOMEM;
1123
1124 rfds = t;
1125
1126 nl = realloc(rfd_names, (rn_fds + s->n_fd_store + 1) * sizeof(char*));
1127 if (!nl)
1128 return -ENOMEM;
1129
1130 rfd_names = nl;
1131
1132 LIST_FOREACH(fd_store, fs, s->fd_store) {
1133 rfds[rn_fds] = fs->fd;
1134 rfd_names[rn_fds] = strdup(strempty(fs->fdname));
1135 if (!rfd_names[rn_fds])
1136 return -ENOMEM;
1137
1138 rn_fds++;
1139 }
1140
1141 rfd_names[rn_fds] = NULL;
1142 }
1143
1144 *fds = rfds;
1145 *fd_names = rfd_names;
1146
1147 rfds = NULL;
1148 rfd_names = NULL;
1149
1150 return rn_fds;
1151 }
1152
1153 static int service_spawn(
1154 Service *s,
1155 ExecCommand *c,
1156 usec_t timeout,
1157 bool pass_fds,
1158 bool apply_permissions,
1159 bool apply_chroot,
1160 bool apply_tty_stdin,
1161 bool is_control,
1162 pid_t *_pid) {
1163
1164 _cleanup_strv_free_ char **argv = NULL, **final_env = NULL, **our_env = NULL, **fd_names = NULL;
1165 _cleanup_free_ char *bus_endpoint_path = NULL;
1166 _cleanup_free_ int *fds = NULL;
1167 unsigned n_fds = 0, n_env = 0;
1168 const char *path;
1169 pid_t pid;
1170
1171 ExecParameters exec_params = {
1172 .apply_permissions = apply_permissions,
1173 .apply_chroot = apply_chroot,
1174 .apply_tty_stdin = apply_tty_stdin,
1175 .bus_endpoint_fd = -1,
1176 .stdin_fd = -1,
1177 .stdout_fd = -1,
1178 .stderr_fd = -1,
1179 };
1180
1181 int r;
1182
1183 assert(s);
1184 assert(c);
1185 assert(_pid);
1186
1187 (void) unit_realize_cgroup(UNIT(s));
1188 if (s->reset_cpu_usage) {
1189 (void) unit_reset_cpu_usage(UNIT(s));
1190 s->reset_cpu_usage = false;
1191 }
1192
1193 r = unit_setup_exec_runtime(UNIT(s));
1194 if (r < 0)
1195 return r;
1196
1197 if (pass_fds ||
1198 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1199 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1200 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1201
1202 r = service_collect_fds(s, &fds, &fd_names);
1203 if (r < 0)
1204 return r;
1205
1206 n_fds = r;
1207 }
1208
1209 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), timeout));
1210 if (r < 0)
1211 return r;
1212
1213 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1214 if (r < 0)
1215 return r;
1216
1217 our_env = new0(char*, 6);
1218 if (!our_env)
1219 return -ENOMEM;
1220
1221 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
1222 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0)
1223 return -ENOMEM;
1224
1225 if (s->main_pid > 0)
1226 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0)
1227 return -ENOMEM;
1228
1229 if (UNIT(s)->manager->running_as != MANAGER_SYSTEM)
1230 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0)
1231 return -ENOMEM;
1232
1233 if (s->socket_fd >= 0) {
1234 union sockaddr_union sa;
1235 socklen_t salen = sizeof(sa);
1236
1237 r = getpeername(s->socket_fd, &sa.sa, &salen);
1238 if (r < 0)
1239 return -errno;
1240
1241 if (IN_SET(sa.sa.sa_family, AF_INET, AF_INET6)) {
1242 _cleanup_free_ char *addr = NULL;
1243 char *t;
1244 int port;
1245
1246 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1247 if (r < 0)
1248 return r;
1249
1250 t = strappend("REMOTE_ADDR=", addr);
1251 if (!t)
1252 return -ENOMEM;
1253 our_env[n_env++] = t;
1254
1255 port = sockaddr_port(&sa.sa);
1256 if (port < 0)
1257 return port;
1258
1259 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
1260 return -ENOMEM;
1261 our_env[n_env++] = t;
1262 }
1263 }
1264
1265 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1266 if (!final_env)
1267 return -ENOMEM;
1268
1269 if (is_control && UNIT(s)->cgroup_path) {
1270 path = strjoina(UNIT(s)->cgroup_path, "/control");
1271 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1272 } else
1273 path = UNIT(s)->cgroup_path;
1274
1275 if (s->exec_context.bus_endpoint) {
1276 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == MANAGER_SYSTEM ? "system" : "user",
1277 UNIT(s)->id, &bus_endpoint_path);
1278 if (r < 0)
1279 return r;
1280
1281 /* Pass the fd to the exec_params so that the child process can upload the policy.
1282 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1283 * as the service is running. */
1284 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
1285 }
1286
1287 exec_params.argv = argv;
1288 exec_params.fds = fds;
1289 exec_params.fd_names = fd_names;
1290 exec_params.n_fds = n_fds;
1291 exec_params.environment = final_env;
1292 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1293 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1294 exec_params.cgroup_path = path;
1295 exec_params.cgroup_delegate = s->cgroup_context.delegate;
1296 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1297 exec_params.watchdog_usec = s->watchdog_usec;
1298 exec_params.bus_endpoint_path = bus_endpoint_path;
1299 exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
1300 if (s->type == SERVICE_IDLE)
1301 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1302 exec_params.stdin_fd = s->stdin_fd;
1303 exec_params.stdout_fd = s->stdout_fd;
1304 exec_params.stderr_fd = s->stderr_fd;
1305
1306 r = exec_spawn(UNIT(s),
1307 c,
1308 &s->exec_context,
1309 &exec_params,
1310 s->exec_runtime,
1311 &pid);
1312 if (r < 0)
1313 return r;
1314
1315 r = unit_watch_pid(UNIT(s), pid);
1316 if (r < 0)
1317 /* FIXME: we need to do something here */
1318 return r;
1319
1320 *_pid = pid;
1321
1322 return 0;
1323 }
1324
1325 static int main_pid_good(Service *s) {
1326 assert(s);
1327
1328 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1329 * don't know */
1330
1331 /* If we know the pid file, then let's just check if it is
1332 * still valid */
1333 if (s->main_pid_known) {
1334
1335 /* If it's an alien child let's check if it is still
1336 * alive ... */
1337 if (s->main_pid_alien && s->main_pid > 0)
1338 return pid_is_alive(s->main_pid);
1339
1340 /* .. otherwise assume we'll get a SIGCHLD for it,
1341 * which we really should wait for to collect exit
1342 * status and code */
1343 return s->main_pid > 0;
1344 }
1345
1346 /* We don't know the pid */
1347 return -EAGAIN;
1348 }
1349
1350 _pure_ static int control_pid_good(Service *s) {
1351 assert(s);
1352
1353 return s->control_pid > 0;
1354 }
1355
1356 static int cgroup_good(Service *s) {
1357 int r;
1358
1359 assert(s);
1360
1361 if (!UNIT(s)->cgroup_path)
1362 return 0;
1363
1364 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path);
1365 if (r < 0)
1366 return r;
1367
1368 return !r;
1369 }
1370
1371 static bool service_shall_restart(Service *s) {
1372 assert(s);
1373
1374 /* Don't restart after manual stops */
1375 if (s->forbid_restart)
1376 return false;
1377
1378 /* Never restart if this is configured as special exception */
1379 if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status))
1380 return false;
1381
1382 /* Restart if the exit code/status are configured as restart triggers */
1383 if (exit_status_set_test(&s->restart_force_status, s->main_exec_status.code, s->main_exec_status.status))
1384 return true;
1385
1386 switch (s->restart) {
1387
1388 case SERVICE_RESTART_NO:
1389 return false;
1390
1391 case SERVICE_RESTART_ALWAYS:
1392 return true;
1393
1394 case SERVICE_RESTART_ON_SUCCESS:
1395 return s->result == SERVICE_SUCCESS;
1396
1397 case SERVICE_RESTART_ON_FAILURE:
1398 return s->result != SERVICE_SUCCESS;
1399
1400 case SERVICE_RESTART_ON_ABNORMAL:
1401 return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE);
1402
1403 case SERVICE_RESTART_ON_WATCHDOG:
1404 return s->result == SERVICE_FAILURE_WATCHDOG;
1405
1406 case SERVICE_RESTART_ON_ABORT:
1407 return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
1408
1409 default:
1410 assert_not_reached("unknown restart setting");
1411 }
1412 }
1413
1414 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1415 int r;
1416 assert(s);
1417
1418 if (f != SERVICE_SUCCESS)
1419 s->result = f;
1420
1421 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1422
1423 if (s->result != SERVICE_SUCCESS) {
1424 log_unit_warning(UNIT(s), "Failed with result '%s'.", service_result_to_string(s->result));
1425 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1426 }
1427
1428 if (allow_restart && service_shall_restart(s)) {
1429
1430 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1431 if (r < 0)
1432 goto fail;
1433
1434 service_set_state(s, SERVICE_AUTO_RESTART);
1435 }
1436
1437 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1438 s->forbid_restart = false;
1439
1440 /* We want fresh tmpdirs in case service is started again immediately */
1441 exec_runtime_destroy(s->exec_runtime);
1442 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1443
1444 /* Also, remove the runtime directory in */
1445 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1446
1447 /* Try to delete the pid file. At this point it will be
1448 * out-of-date, and some software might be confused by it, so
1449 * let's remove it. */
1450 if (s->pid_file)
1451 (void) unlink(s->pid_file);
1452
1453 return;
1454
1455 fail:
1456 log_unit_warning_errno(UNIT(s), r, "Failed to run install restart timer: %m");
1457 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1458 }
1459
1460 static void service_enter_stop_post(Service *s, ServiceResult f) {
1461 int r;
1462 assert(s);
1463
1464 if (f != SERVICE_SUCCESS)
1465 s->result = f;
1466
1467 service_unwatch_control_pid(s);
1468 unit_watch_all_pids(UNIT(s));
1469
1470 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1471 if (s->control_command) {
1472 s->control_command_id = SERVICE_EXEC_STOP_POST;
1473
1474 r = service_spawn(s,
1475 s->control_command,
1476 s->timeout_stop_usec,
1477 false,
1478 !s->permissions_start_only,
1479 !s->root_directory_start_only,
1480 true,
1481 true,
1482 &s->control_pid);
1483 if (r < 0)
1484 goto fail;
1485
1486 service_set_state(s, SERVICE_STOP_POST);
1487 } else
1488 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1489
1490 return;
1491
1492 fail:
1493 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
1494 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1495 }
1496
1497 static int state_to_kill_operation(ServiceState state) {
1498 switch (state) {
1499
1500 case SERVICE_STOP_SIGABRT:
1501 return KILL_ABORT;
1502
1503 case SERVICE_STOP_SIGTERM:
1504 case SERVICE_FINAL_SIGTERM:
1505 return KILL_TERMINATE;
1506
1507 case SERVICE_STOP_SIGKILL:
1508 case SERVICE_FINAL_SIGKILL:
1509 return KILL_KILL;
1510
1511 default:
1512 return _KILL_OPERATION_INVALID;
1513 }
1514 }
1515
1516 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1517 int r;
1518
1519 assert(s);
1520
1521 if (f != SERVICE_SUCCESS)
1522 s->result = f;
1523
1524 unit_watch_all_pids(UNIT(s));
1525
1526 r = unit_kill_context(
1527 UNIT(s),
1528 &s->kill_context,
1529 state_to_kill_operation(state),
1530 s->main_pid,
1531 s->control_pid,
1532 s->main_pid_alien);
1533
1534 if (r < 0)
1535 goto fail;
1536
1537 if (r > 0) {
1538 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1539 if (r < 0)
1540 goto fail;
1541
1542 service_set_state(s, state);
1543 } else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
1544 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1545 else if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1546 service_enter_stop_post(s, SERVICE_SUCCESS);
1547 else if (state == SERVICE_FINAL_SIGTERM && s->kill_context.send_sigkill)
1548 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1549 else
1550 service_enter_dead(s, SERVICE_SUCCESS, true);
1551
1552 return;
1553
1554 fail:
1555 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
1556
1557 if (IN_SET(state, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1558 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1559 else
1560 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1561 }
1562
1563 static void service_enter_stop_by_notify(Service *s) {
1564 assert(s);
1565
1566 unit_watch_all_pids(UNIT(s));
1567
1568 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1569
1570 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1571 service_set_state(s, SERVICE_STOP_SIGTERM);
1572 }
1573
1574 static void service_enter_stop(Service *s, ServiceResult f) {
1575 int r;
1576
1577 assert(s);
1578
1579 if (f != SERVICE_SUCCESS)
1580 s->result = f;
1581
1582 service_unwatch_control_pid(s);
1583 unit_watch_all_pids(UNIT(s));
1584
1585 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1586 if (s->control_command) {
1587 s->control_command_id = SERVICE_EXEC_STOP;
1588
1589 r = service_spawn(s,
1590 s->control_command,
1591 s->timeout_stop_usec,
1592 false,
1593 !s->permissions_start_only,
1594 !s->root_directory_start_only,
1595 false,
1596 true,
1597 &s->control_pid);
1598 if (r < 0)
1599 goto fail;
1600
1601 service_set_state(s, SERVICE_STOP);
1602 } else
1603 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1604
1605 return;
1606
1607 fail:
1608 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop' task: %m");
1609 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1610 }
1611
1612 static bool service_good(Service *s) {
1613 int main_pid_ok;
1614 assert(s);
1615
1616 if (s->type == SERVICE_DBUS && !s->bus_name_good)
1617 return false;
1618
1619 main_pid_ok = main_pid_good(s);
1620 if (main_pid_ok > 0) /* It's alive */
1621 return true;
1622 if (main_pid_ok == 0) /* It's dead */
1623 return false;
1624
1625 /* OK, we don't know anything about the main PID, maybe
1626 * because there is none. Let's check the control group
1627 * instead. */
1628
1629 return cgroup_good(s) != 0;
1630 }
1631
1632 static void service_enter_running(Service *s, ServiceResult f) {
1633 assert(s);
1634
1635 if (f != SERVICE_SUCCESS)
1636 s->result = f;
1637
1638 service_unwatch_control_pid(s);
1639
1640 if (service_good(s)) {
1641
1642 /* If there are any queued up sd_notify()
1643 * notifications, process them now */
1644 if (s->notify_state == NOTIFY_RELOADING)
1645 service_enter_reload_by_notify(s);
1646 else if (s->notify_state == NOTIFY_STOPPING)
1647 service_enter_stop_by_notify(s);
1648 else {
1649 service_set_state(s, SERVICE_RUNNING);
1650 service_arm_timer(s, usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec));
1651 }
1652
1653 } else if (s->remain_after_exit)
1654 service_set_state(s, SERVICE_EXITED);
1655 else
1656 service_enter_stop(s, SERVICE_SUCCESS);
1657 }
1658
1659 static void service_enter_start_post(Service *s) {
1660 int r;
1661 assert(s);
1662
1663 service_unwatch_control_pid(s);
1664 service_reset_watchdog(s);
1665
1666 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1667 if (s->control_command) {
1668 s->control_command_id = SERVICE_EXEC_START_POST;
1669
1670 r = service_spawn(s,
1671 s->control_command,
1672 s->timeout_start_usec,
1673 false,
1674 !s->permissions_start_only,
1675 !s->root_directory_start_only,
1676 false,
1677 true,
1678 &s->control_pid);
1679 if (r < 0)
1680 goto fail;
1681
1682 service_set_state(s, SERVICE_START_POST);
1683 } else
1684 service_enter_running(s, SERVICE_SUCCESS);
1685
1686 return;
1687
1688 fail:
1689 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
1690 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1691 }
1692
1693 static void service_kill_control_processes(Service *s) {
1694 char *p;
1695
1696 if (!UNIT(s)->cgroup_path)
1697 return;
1698
1699 p = strjoina(UNIT(s)->cgroup_path, "/control");
1700 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1701 }
1702
1703 static void service_enter_start(Service *s) {
1704 ExecCommand *c;
1705 usec_t timeout;
1706 pid_t pid;
1707 int r;
1708
1709 assert(s);
1710
1711 service_unwatch_control_pid(s);
1712 service_unwatch_main_pid(s);
1713
1714 /* We want to ensure that nobody leaks processes from
1715 * START_PRE here, so let's go on a killing spree, People
1716 * should not spawn long running processes from START_PRE. */
1717 service_kill_control_processes(s);
1718
1719 if (s->type == SERVICE_FORKING) {
1720 s->control_command_id = SERVICE_EXEC_START;
1721 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1722
1723 s->main_command = NULL;
1724 } else {
1725 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1726 s->control_command = NULL;
1727
1728 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1729 }
1730
1731 if (!c) {
1732 assert(s->type == SERVICE_ONESHOT);
1733 service_enter_start_post(s);
1734 return;
1735 }
1736
1737 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
1738 /* For simple + idle this is the main process. We don't apply any timeout here, but
1739 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1740 timeout = USEC_INFINITY;
1741 else
1742 timeout = s->timeout_start_usec;
1743
1744 r = service_spawn(s,
1745 c,
1746 timeout,
1747 true,
1748 true,
1749 true,
1750 true,
1751 false,
1752 &pid);
1753 if (r < 0)
1754 goto fail;
1755
1756 if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE)) {
1757 /* For simple services we immediately start
1758 * the START_POST binaries. */
1759
1760 service_set_main_pid(s, pid);
1761 service_enter_start_post(s);
1762
1763 } else if (s->type == SERVICE_FORKING) {
1764
1765 /* For forking services we wait until the start
1766 * process exited. */
1767
1768 s->control_pid = pid;
1769 service_set_state(s, SERVICE_START);
1770
1771 } else if (IN_SET(s->type, SERVICE_ONESHOT, SERVICE_DBUS, SERVICE_NOTIFY)) {
1772
1773 /* For oneshot services we wait until the start
1774 * process exited, too, but it is our main process. */
1775
1776 /* For D-Bus services we know the main pid right away,
1777 * but wait for the bus name to appear on the
1778 * bus. Notify services are similar. */
1779
1780 service_set_main_pid(s, pid);
1781 service_set_state(s, SERVICE_START);
1782 } else
1783 assert_not_reached("Unknown service type");
1784
1785 return;
1786
1787 fail:
1788 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start' task: %m");
1789 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1790 }
1791
1792 static void service_enter_start_pre(Service *s) {
1793 int r;
1794
1795 assert(s);
1796
1797 service_unwatch_control_pid(s);
1798
1799 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1800 if (s->control_command) {
1801 /* Before we start anything, let's clear up what might
1802 * be left from previous runs. */
1803 service_kill_control_processes(s);
1804
1805 s->control_command_id = SERVICE_EXEC_START_PRE;
1806
1807 r = service_spawn(s,
1808 s->control_command,
1809 s->timeout_start_usec,
1810 false,
1811 !s->permissions_start_only,
1812 !s->root_directory_start_only,
1813 true,
1814 true,
1815 &s->control_pid);
1816 if (r < 0)
1817 goto fail;
1818
1819 service_set_state(s, SERVICE_START_PRE);
1820 } else
1821 service_enter_start(s);
1822
1823 return;
1824
1825 fail:
1826 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
1827 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1828 }
1829
1830 static void service_enter_restart(Service *s) {
1831 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1832 int r;
1833
1834 assert(s);
1835
1836 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1837 /* Don't restart things if we are going down anyway */
1838 log_unit_info(UNIT(s), "Stop job pending for unit, delaying automatic restart.");
1839
1840 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1841 if (r < 0)
1842 goto fail;
1843
1844 return;
1845 }
1846
1847 /* Any units that are bound to this service must also be
1848 * restarted. We use JOB_RESTART (instead of the more obvious
1849 * JOB_START) here so that those dependency jobs will be added
1850 * as well. */
1851 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, &error, NULL);
1852 if (r < 0)
1853 goto fail;
1854
1855 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1856 * it will be canceled as part of the service_stop() call that
1857 * is executed as part of JOB_RESTART. */
1858
1859 log_unit_debug(UNIT(s), "Scheduled restart job.");
1860 return;
1861
1862 fail:
1863 log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, -r));
1864 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1865 }
1866
1867 static void service_enter_reload_by_notify(Service *s) {
1868 assert(s);
1869
1870 service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_start_usec));
1871 service_set_state(s, SERVICE_RELOAD);
1872 }
1873
1874 static void service_enter_reload(Service *s) {
1875 int r;
1876
1877 assert(s);
1878
1879 service_unwatch_control_pid(s);
1880 s->reload_result = SERVICE_SUCCESS;
1881
1882 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1883 if (s->control_command) {
1884 s->control_command_id = SERVICE_EXEC_RELOAD;
1885
1886 r = service_spawn(s,
1887 s->control_command,
1888 s->timeout_start_usec,
1889 false,
1890 !s->permissions_start_only,
1891 !s->root_directory_start_only,
1892 false,
1893 true,
1894 &s->control_pid);
1895 if (r < 0)
1896 goto fail;
1897
1898 service_set_state(s, SERVICE_RELOAD);
1899 } else
1900 service_enter_running(s, SERVICE_SUCCESS);
1901
1902 return;
1903
1904 fail:
1905 log_unit_warning_errno(UNIT(s), r, "Failed to run 'reload' task: %m");
1906 s->reload_result = SERVICE_FAILURE_RESOURCES;
1907 service_enter_running(s, SERVICE_SUCCESS);
1908 }
1909
1910 static void service_run_next_control(Service *s) {
1911 usec_t timeout;
1912 int r;
1913
1914 assert(s);
1915 assert(s->control_command);
1916 assert(s->control_command->command_next);
1917
1918 assert(s->control_command_id != SERVICE_EXEC_START);
1919
1920 s->control_command = s->control_command->command_next;
1921 service_unwatch_control_pid(s);
1922
1923 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1924 timeout = s->timeout_start_usec;
1925 else
1926 timeout = s->timeout_stop_usec;
1927
1928 r = service_spawn(s,
1929 s->control_command,
1930 timeout,
1931 false,
1932 !s->permissions_start_only,
1933 !s->root_directory_start_only,
1934 s->control_command_id == SERVICE_EXEC_START_PRE ||
1935 s->control_command_id == SERVICE_EXEC_STOP_POST,
1936 true,
1937 &s->control_pid);
1938 if (r < 0)
1939 goto fail;
1940
1941 return;
1942
1943 fail:
1944 log_unit_warning_errno(UNIT(s), r, "Failed to run next control task: %m");
1945
1946 if (s->state == SERVICE_START_PRE)
1947 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1948 else if (s->state == SERVICE_STOP)
1949 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1950 else if (s->state == SERVICE_STOP_POST)
1951 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1952 else if (s->state == SERVICE_RELOAD) {
1953 s->reload_result = SERVICE_FAILURE_RESOURCES;
1954 service_enter_running(s, SERVICE_SUCCESS);
1955 } else
1956 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1957 }
1958
1959 static void service_run_next_main(Service *s) {
1960 pid_t pid;
1961 int r;
1962
1963 assert(s);
1964 assert(s->main_command);
1965 assert(s->main_command->command_next);
1966 assert(s->type == SERVICE_ONESHOT);
1967
1968 s->main_command = s->main_command->command_next;
1969 service_unwatch_main_pid(s);
1970
1971 r = service_spawn(s,
1972 s->main_command,
1973 s->timeout_start_usec,
1974 true,
1975 true,
1976 true,
1977 true,
1978 false,
1979 &pid);
1980 if (r < 0)
1981 goto fail;
1982
1983 service_set_main_pid(s, pid);
1984
1985 return;
1986
1987 fail:
1988 log_unit_warning_errno(UNIT(s), r, "Failed to run next main task: %m");
1989 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1990 }
1991
1992 static int service_start_limit_test(Service *s) {
1993 assert(s);
1994
1995 if (ratelimit_test(&s->start_limit))
1996 return 0;
1997
1998 log_unit_warning(UNIT(s), "Start request repeated too quickly.");
1999
2000 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
2001 }
2002
2003 static int service_start(Unit *u) {
2004 Service *s = SERVICE(u);
2005 int r;
2006
2007 assert(s);
2008
2009 /* We cannot fulfill this request right now, try again later
2010 * please! */
2011 if (IN_SET(s->state,
2012 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2013 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2014 return -EAGAIN;
2015
2016 /* Already on it! */
2017 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST))
2018 return 0;
2019
2020 /* A service that will be restarted must be stopped first to
2021 * trigger BindsTo and/or OnFailure dependencies. If a user
2022 * does not want to wait for the holdoff time to elapse, the
2023 * service should be manually restarted, not started. We
2024 * simply return EAGAIN here, so that any start jobs stay
2025 * queued, and assume that the auto restart timer will
2026 * eventually trigger the restart. */
2027 if (s->state == SERVICE_AUTO_RESTART)
2028 return -EAGAIN;
2029
2030 assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED));
2031
2032 /* Make sure we don't enter a busy loop of some kind. */
2033 r = service_start_limit_test(s);
2034 if (r < 0) {
2035 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2036 return r;
2037 }
2038
2039 s->result = SERVICE_SUCCESS;
2040 s->reload_result = SERVICE_SUCCESS;
2041 s->main_pid_known = false;
2042 s->main_pid_alien = false;
2043 s->forbid_restart = false;
2044 s->reset_cpu_usage = true;
2045
2046 s->status_text = mfree(s->status_text);
2047 s->status_errno = 0;
2048
2049 s->notify_state = NOTIFY_UNKNOWN;
2050
2051 service_enter_start_pre(s);
2052 return 1;
2053 }
2054
2055 static int service_stop(Unit *u) {
2056 Service *s = SERVICE(u);
2057
2058 assert(s);
2059
2060 /* Don't create restart jobs from manual stops. */
2061 s->forbid_restart = true;
2062
2063 /* Already on it */
2064 if (IN_SET(s->state,
2065 SERVICE_STOP, SERVICE_STOP_SIGABRT, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2066 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2067 return 0;
2068
2069 /* A restart will be scheduled or is in progress. */
2070 if (s->state == SERVICE_AUTO_RESTART) {
2071 service_set_state(s, SERVICE_DEAD);
2072 return 0;
2073 }
2074
2075 /* If there's already something running we go directly into
2076 * kill mode. */
2077 if (IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD)) {
2078 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2079 return 0;
2080 }
2081
2082 assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2083
2084 service_enter_stop(s, SERVICE_SUCCESS);
2085 return 1;
2086 }
2087
2088 static int service_reload(Unit *u) {
2089 Service *s = SERVICE(u);
2090
2091 assert(s);
2092
2093 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2094
2095 service_enter_reload(s);
2096 return 1;
2097 }
2098
2099 _pure_ static bool service_can_reload(Unit *u) {
2100 Service *s = SERVICE(u);
2101
2102 assert(s);
2103
2104 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2105 }
2106
2107 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2108 Service *s = SERVICE(u);
2109 ServiceFDStore *fs;
2110 int r;
2111
2112 assert(u);
2113 assert(f);
2114 assert(fds);
2115
2116 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2117 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2118 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2119
2120 if (s->control_pid > 0)
2121 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
2122
2123 if (s->main_pid_known && s->main_pid > 0)
2124 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2125
2126 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2127 unit_serialize_item(u, f, "bus-name-good", yes_no(s->bus_name_good));
2128 unit_serialize_item(u, f, "bus-name-owner", s->bus_name_owner);
2129
2130 r = unit_serialize_item_escaped(u, f, "status-text", s->status_text);
2131 if (r < 0)
2132 return r;
2133
2134 /* FIXME: There's a minor uncleanliness here: if there are
2135 * multiple commands attached here, we will start from the
2136 * first one again */
2137 if (s->control_command_id >= 0)
2138 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2139
2140 r = unit_serialize_item_fd(u, f, fds, "stdin-fd", s->stdin_fd);
2141 if (r < 0)
2142 return r;
2143 r = unit_serialize_item_fd(u, f, fds, "stdout-fd", s->stdout_fd);
2144 if (r < 0)
2145 return r;
2146 r = unit_serialize_item_fd(u, f, fds, "stderr-fd", s->stderr_fd);
2147 if (r < 0)
2148 return r;
2149
2150 r = unit_serialize_item_fd(u, f, fds, "socket-fd", s->socket_fd);
2151 if (r < 0)
2152 return r;
2153 r = unit_serialize_item_fd(u, f, fds, "endpoint-fd", s->bus_endpoint_fd);
2154 if (r < 0)
2155 return r;
2156
2157 LIST_FOREACH(fd_store, fs, s->fd_store) {
2158 _cleanup_free_ char *c = NULL;
2159 int copy;
2160
2161 copy = fdset_put_dup(fds, fs->fd);
2162 if (copy < 0)
2163 return copy;
2164
2165 c = cescape(fs->fdname);
2166
2167 unit_serialize_item_format(u, f, "fd-store-fd", "%i %s", copy, strempty(c));
2168 }
2169
2170 if (s->main_exec_status.pid > 0) {
2171 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
2172 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2173 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2174
2175 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2176 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2177 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2178 }
2179 }
2180
2181 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2182 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2183
2184 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2185
2186 return 0;
2187 }
2188
2189 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2190 Service *s = SERVICE(u);
2191 int r;
2192
2193 assert(u);
2194 assert(key);
2195 assert(value);
2196 assert(fds);
2197
2198 if (streq(key, "state")) {
2199 ServiceState state;
2200
2201 state = service_state_from_string(value);
2202 if (state < 0)
2203 log_unit_debug(u, "Failed to parse state value: %s", value);
2204 else
2205 s->deserialized_state = state;
2206 } else if (streq(key, "result")) {
2207 ServiceResult f;
2208
2209 f = service_result_from_string(value);
2210 if (f < 0)
2211 log_unit_debug(u, "Failed to parse result value: %s", value);
2212 else if (f != SERVICE_SUCCESS)
2213 s->result = f;
2214
2215 } else if (streq(key, "reload-result")) {
2216 ServiceResult f;
2217
2218 f = service_result_from_string(value);
2219 if (f < 0)
2220 log_unit_debug(u, "Failed to parse reload result value: %s", value);
2221 else if (f != SERVICE_SUCCESS)
2222 s->reload_result = f;
2223
2224 } else if (streq(key, "control-pid")) {
2225 pid_t pid;
2226
2227 if (parse_pid(value, &pid) < 0)
2228 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2229 else
2230 s->control_pid = pid;
2231 } else if (streq(key, "main-pid")) {
2232 pid_t pid;
2233
2234 if (parse_pid(value, &pid) < 0)
2235 log_unit_debug(u, "Failed to parse main-pid value: %s", value);
2236 else {
2237 service_set_main_pid(s, pid);
2238 unit_watch_pid(UNIT(s), pid);
2239 }
2240 } else if (streq(key, "main-pid-known")) {
2241 int b;
2242
2243 b = parse_boolean(value);
2244 if (b < 0)
2245 log_unit_debug(u, "Failed to parse main-pid-known value: %s", value);
2246 else
2247 s->main_pid_known = b;
2248 } else if (streq(key, "bus-name-good")) {
2249 int b;
2250
2251 b = parse_boolean(value);
2252 if (b < 0)
2253 log_unit_debug(u, "Failed to parse bus-name-good value: %s", value);
2254 else
2255 s->bus_name_good = b;
2256 } else if (streq(key, "bus-name-owner")) {
2257 r = free_and_strdup(&s->bus_name_owner, value);
2258 if (r < 0)
2259 log_unit_error_errno(u, r, "Unable to deserialize current bus owner %s: %m", value);
2260 } else if (streq(key, "status-text")) {
2261 char *t;
2262
2263 r = cunescape(value, 0, &t);
2264 if (r < 0)
2265 log_unit_debug_errno(u, r, "Failed to unescape status text: %s", value);
2266 else {
2267 free(s->status_text);
2268 s->status_text = t;
2269 }
2270
2271 } else if (streq(key, "control-command")) {
2272 ServiceExecCommand id;
2273
2274 id = service_exec_command_from_string(value);
2275 if (id < 0)
2276 log_unit_debug(u, "Failed to parse exec-command value: %s", value);
2277 else {
2278 s->control_command_id = id;
2279 s->control_command = s->exec_command[id];
2280 }
2281 } else if (streq(key, "socket-fd")) {
2282 int fd;
2283
2284 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2285 log_unit_debug(u, "Failed to parse socket-fd value: %s", value);
2286 else {
2287 asynchronous_close(s->socket_fd);
2288 s->socket_fd = fdset_remove(fds, fd);
2289 }
2290 } else if (streq(key, "endpoint-fd")) {
2291 int fd;
2292
2293 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2294 log_unit_debug(u, "Failed to parse endpoint-fd value: %s", value);
2295 else {
2296 safe_close(s->bus_endpoint_fd);
2297 s->bus_endpoint_fd = fdset_remove(fds, fd);
2298 }
2299 } else if (streq(key, "fd-store-fd")) {
2300 const char *fdv;
2301 size_t pf;
2302 int fd;
2303
2304 pf = strcspn(value, WHITESPACE);
2305 fdv = strndupa(value, pf);
2306
2307 if (safe_atoi(fdv, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2308 log_unit_debug(u, "Failed to parse fd-store-fd value: %s", value);
2309 else {
2310 _cleanup_free_ char *t = NULL;
2311 const char *fdn;
2312
2313 fdn = value + pf;
2314 fdn += strspn(fdn, WHITESPACE);
2315 (void) cunescape(fdn, 0, &t);
2316
2317 r = service_add_fd_store(s, fd, t);
2318 if (r < 0)
2319 log_unit_error_errno(u, r, "Failed to add fd to store: %m");
2320 else if (r > 0)
2321 fdset_remove(fds, fd);
2322 }
2323
2324 } else if (streq(key, "main-exec-status-pid")) {
2325 pid_t pid;
2326
2327 if (parse_pid(value, &pid) < 0)
2328 log_unit_debug(u, "Failed to parse main-exec-status-pid value: %s", value);
2329 else
2330 s->main_exec_status.pid = pid;
2331 } else if (streq(key, "main-exec-status-code")) {
2332 int i;
2333
2334 if (safe_atoi(value, &i) < 0)
2335 log_unit_debug(u, "Failed to parse main-exec-status-code value: %s", value);
2336 else
2337 s->main_exec_status.code = i;
2338 } else if (streq(key, "main-exec-status-status")) {
2339 int i;
2340
2341 if (safe_atoi(value, &i) < 0)
2342 log_unit_debug(u, "Failed to parse main-exec-status-status value: %s", value);
2343 else
2344 s->main_exec_status.status = i;
2345 } else if (streq(key, "main-exec-status-start"))
2346 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2347 else if (streq(key, "main-exec-status-exit"))
2348 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2349 else if (streq(key, "watchdog-timestamp"))
2350 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2351 else if (streq(key, "forbid-restart")) {
2352 int b;
2353
2354 b = parse_boolean(value);
2355 if (b < 0)
2356 log_unit_debug(u, "Failed to parse forbid-restart value: %s", value);
2357 else
2358 s->forbid_restart = b;
2359 } else if (streq(key, "stdin-fd")) {
2360 int fd;
2361
2362 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2363 log_unit_debug(u, "Failed to parse stdin-fd value: %s", value);
2364 else {
2365 asynchronous_close(s->stdin_fd);
2366 s->stdin_fd = fdset_remove(fds, fd);
2367 s->exec_context.stdio_as_fds = true;
2368 }
2369 } else if (streq(key, "stdout-fd")) {
2370 int fd;
2371
2372 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2373 log_unit_debug(u, "Failed to parse stdout-fd value: %s", value);
2374 else {
2375 asynchronous_close(s->stdout_fd);
2376 s->stdout_fd = fdset_remove(fds, fd);
2377 s->exec_context.stdio_as_fds = true;
2378 }
2379 } else if (streq(key, "stderr-fd")) {
2380 int fd;
2381
2382 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2383 log_unit_debug(u, "Failed to parse stderr-fd value: %s", value);
2384 else {
2385 asynchronous_close(s->stderr_fd);
2386 s->stderr_fd = fdset_remove(fds, fd);
2387 s->exec_context.stdio_as_fds = true;
2388 }
2389 } else
2390 log_unit_debug(u, "Unknown serialization key: %s", key);
2391
2392 return 0;
2393 }
2394
2395 _pure_ static UnitActiveState service_active_state(Unit *u) {
2396 const UnitActiveState *table;
2397
2398 assert(u);
2399
2400 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2401
2402 return table[SERVICE(u)->state];
2403 }
2404
2405 static const char *service_sub_state_to_string(Unit *u) {
2406 assert(u);
2407
2408 return service_state_to_string(SERVICE(u)->state);
2409 }
2410
2411 static bool service_check_gc(Unit *u) {
2412 Service *s = SERVICE(u);
2413
2414 assert(s);
2415
2416 /* Never clean up services that still have a process around,
2417 * even if the service is formally dead. */
2418 if (cgroup_good(s) > 0 ||
2419 main_pid_good(s) > 0 ||
2420 control_pid_good(s) > 0)
2421 return true;
2422
2423 return false;
2424 }
2425
2426 static int service_retry_pid_file(Service *s) {
2427 int r;
2428
2429 assert(s->pid_file);
2430 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2431
2432 r = service_load_pid_file(s, false);
2433 if (r < 0)
2434 return r;
2435
2436 service_unwatch_pid_file(s);
2437
2438 service_enter_running(s, SERVICE_SUCCESS);
2439 return 0;
2440 }
2441
2442 static int service_watch_pid_file(Service *s) {
2443 int r;
2444
2445 log_unit_debug(UNIT(s), "Setting watch for PID file %s", s->pid_file_pathspec->path);
2446
2447 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2448 if (r < 0)
2449 goto fail;
2450
2451 /* the pidfile might have appeared just before we set the watch */
2452 log_unit_debug(UNIT(s), "Trying to read PID file %s in case it changed", s->pid_file_pathspec->path);
2453 service_retry_pid_file(s);
2454
2455 return 0;
2456 fail:
2457 log_unit_error_errno(UNIT(s), r, "Failed to set a watch for PID file %s: %m", s->pid_file_pathspec->path);
2458 service_unwatch_pid_file(s);
2459 return r;
2460 }
2461
2462 static int service_demand_pid_file(Service *s) {
2463 PathSpec *ps;
2464
2465 assert(s->pid_file);
2466 assert(!s->pid_file_pathspec);
2467
2468 ps = new0(PathSpec, 1);
2469 if (!ps)
2470 return -ENOMEM;
2471
2472 ps->unit = UNIT(s);
2473 ps->path = strdup(s->pid_file);
2474 if (!ps->path) {
2475 free(ps);
2476 return -ENOMEM;
2477 }
2478
2479 path_kill_slashes(ps->path);
2480
2481 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2482 * keep their PID file open all the time. */
2483 ps->type = PATH_MODIFIED;
2484 ps->inotify_fd = -1;
2485
2486 s->pid_file_pathspec = ps;
2487
2488 return service_watch_pid_file(s);
2489 }
2490
2491 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2492 PathSpec *p = userdata;
2493 Service *s;
2494
2495 assert(p);
2496
2497 s = SERVICE(p->unit);
2498
2499 assert(s);
2500 assert(fd >= 0);
2501 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2502 assert(s->pid_file_pathspec);
2503 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2504
2505 log_unit_debug(UNIT(s), "inotify event");
2506
2507 if (path_spec_fd_event(p, events) < 0)
2508 goto fail;
2509
2510 if (service_retry_pid_file(s) == 0)
2511 return 0;
2512
2513 if (service_watch_pid_file(s) < 0)
2514 goto fail;
2515
2516 return 0;
2517
2518 fail:
2519 service_unwatch_pid_file(s);
2520 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2521 return 0;
2522 }
2523
2524 static void service_notify_cgroup_empty_event(Unit *u) {
2525 Service *s = SERVICE(u);
2526
2527 assert(u);
2528
2529 log_unit_debug(u, "cgroup is empty");
2530
2531 switch (s->state) {
2532
2533 /* Waiting for SIGCHLD is usually more interesting,
2534 * because it includes return codes/signals. Which is
2535 * why we ignore the cgroup events for most cases,
2536 * except when we don't know pid which to expect the
2537 * SIGCHLD for. */
2538
2539 case SERVICE_START:
2540 case SERVICE_START_POST:
2541 /* If we were hoping for the daemon to write its PID file,
2542 * we can give up now. */
2543 if (s->pid_file_pathspec) {
2544 log_unit_warning(u, "Daemon never wrote its PID file. Failing.");
2545
2546 service_unwatch_pid_file(s);
2547 if (s->state == SERVICE_START)
2548 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2549 else
2550 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2551 }
2552 break;
2553
2554 case SERVICE_RUNNING:
2555 /* service_enter_running() will figure out what to do */
2556 service_enter_running(s, SERVICE_SUCCESS);
2557 break;
2558
2559 case SERVICE_STOP_SIGABRT:
2560 case SERVICE_STOP_SIGTERM:
2561 case SERVICE_STOP_SIGKILL:
2562
2563 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2564 service_enter_stop_post(s, SERVICE_SUCCESS);
2565
2566 break;
2567
2568 case SERVICE_STOP_POST:
2569 case SERVICE_FINAL_SIGTERM:
2570 case SERVICE_FINAL_SIGKILL:
2571 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2572 service_enter_dead(s, SERVICE_SUCCESS, true);
2573
2574 break;
2575
2576 default:
2577 ;
2578 }
2579 }
2580
2581 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2582 Service *s = SERVICE(u);
2583 ServiceResult f;
2584
2585 assert(s);
2586 assert(pid >= 0);
2587
2588 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2589 is_clean_exit_lsb(code, status, &s->success_status))
2590 f = SERVICE_SUCCESS;
2591 else if (code == CLD_EXITED)
2592 f = SERVICE_FAILURE_EXIT_CODE;
2593 else if (code == CLD_KILLED)
2594 f = SERVICE_FAILURE_SIGNAL;
2595 else if (code == CLD_DUMPED)
2596 f = SERVICE_FAILURE_CORE_DUMP;
2597 else
2598 assert_not_reached("Unknown code");
2599
2600 if (s->main_pid == pid) {
2601 /* Forking services may occasionally move to a new PID.
2602 * As long as they update the PID file before exiting the old
2603 * PID, they're fine. */
2604 if (service_load_pid_file(s, false) == 0)
2605 return;
2606
2607 s->main_pid = 0;
2608 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2609
2610 if (s->main_command) {
2611 /* If this is not a forking service than the
2612 * main process got started and hence we copy
2613 * the exit status so that it is recorded both
2614 * as main and as control process exit
2615 * status */
2616
2617 s->main_command->exec_status = s->main_exec_status;
2618
2619 if (s->main_command->ignore)
2620 f = SERVICE_SUCCESS;
2621 } else if (s->exec_command[SERVICE_EXEC_START]) {
2622
2623 /* If this is a forked process, then we should
2624 * ignore the return value if this was
2625 * configured for the starter process */
2626
2627 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2628 f = SERVICE_SUCCESS;
2629 }
2630
2631 log_struct(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2632 LOG_UNIT_ID(u),
2633 LOG_UNIT_MESSAGE(u, "Main process exited, code=%s, status=%i/%s",
2634 sigchld_code_to_string(code), status,
2635 strna(code == CLD_EXITED
2636 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2637 : signal_to_string(status))),
2638 "EXIT_CODE=%s", sigchld_code_to_string(code),
2639 "EXIT_STATUS=%i", status,
2640 NULL);
2641
2642 if (f != SERVICE_SUCCESS)
2643 s->result = f;
2644
2645 if (s->main_command &&
2646 s->main_command->command_next &&
2647 f == SERVICE_SUCCESS) {
2648
2649 /* There is another command to *
2650 * execute, so let's do that. */
2651
2652 log_unit_debug(u, "Running next main command for state %s.", service_state_to_string(s->state));
2653 service_run_next_main(s);
2654
2655 } else {
2656
2657 /* The service exited, so the service is officially
2658 * gone. */
2659 s->main_command = NULL;
2660
2661 switch (s->state) {
2662
2663 case SERVICE_START_POST:
2664 case SERVICE_RELOAD:
2665 case SERVICE_STOP:
2666 /* Need to wait until the operation is
2667 * done */
2668 break;
2669
2670 case SERVICE_START:
2671 if (s->type == SERVICE_ONESHOT) {
2672 /* This was our main goal, so let's go on */
2673 if (f == SERVICE_SUCCESS)
2674 service_enter_start_post(s);
2675 else
2676 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2677 break;
2678 }
2679
2680 /* Fall through */
2681
2682 case SERVICE_RUNNING:
2683 service_enter_running(s, f);
2684 break;
2685
2686 case SERVICE_STOP_SIGABRT:
2687 case SERVICE_STOP_SIGTERM:
2688 case SERVICE_STOP_SIGKILL:
2689
2690 if (!control_pid_good(s))
2691 service_enter_stop_post(s, f);
2692
2693 /* If there is still a control process, wait for that first */
2694 break;
2695
2696 case SERVICE_STOP_POST:
2697 case SERVICE_FINAL_SIGTERM:
2698 case SERVICE_FINAL_SIGKILL:
2699
2700 if (!control_pid_good(s))
2701 service_enter_dead(s, f, true);
2702 break;
2703
2704 default:
2705 assert_not_reached("Uh, main process died at wrong time.");
2706 }
2707 }
2708
2709 } else if (s->control_pid == pid) {
2710 s->control_pid = 0;
2711
2712 if (s->control_command) {
2713 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2714
2715 if (s->control_command->ignore)
2716 f = SERVICE_SUCCESS;
2717 }
2718
2719 log_unit_full(u, f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
2720 "Control process exited, code=%s status=%i",
2721 sigchld_code_to_string(code), status);
2722
2723 if (f != SERVICE_SUCCESS)
2724 s->result = f;
2725
2726 /* Immediately get rid of the cgroup, so that the
2727 * kernel doesn't delay the cgroup empty messages for
2728 * the service cgroup any longer than necessary */
2729 service_kill_control_processes(s);
2730
2731 if (s->control_command &&
2732 s->control_command->command_next &&
2733 f == SERVICE_SUCCESS) {
2734
2735 /* There is another command to *
2736 * execute, so let's do that. */
2737
2738 log_unit_debug(u, "Running next control command for state %s.", service_state_to_string(s->state));
2739 service_run_next_control(s);
2740
2741 } else {
2742 /* No further commands for this step, so let's
2743 * figure out what to do next */
2744
2745 s->control_command = NULL;
2746 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2747
2748 log_unit_debug(u, "Got final SIGCHLD for state %s.", service_state_to_string(s->state));
2749
2750 switch (s->state) {
2751
2752 case SERVICE_START_PRE:
2753 if (f == SERVICE_SUCCESS)
2754 service_enter_start(s);
2755 else
2756 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2757 break;
2758
2759 case SERVICE_START:
2760 if (s->type != SERVICE_FORKING)
2761 /* Maybe spurious event due to a reload that changed the type? */
2762 break;
2763
2764 if (f != SERVICE_SUCCESS) {
2765 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2766 break;
2767 }
2768
2769 if (s->pid_file) {
2770 bool has_start_post;
2771 int r;
2772
2773 /* Let's try to load the pid file here if we can.
2774 * The PID file might actually be created by a START_POST
2775 * script. In that case don't worry if the loading fails. */
2776
2777 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2778 r = service_load_pid_file(s, !has_start_post);
2779 if (!has_start_post && r < 0) {
2780 r = service_demand_pid_file(s);
2781 if (r < 0 || !cgroup_good(s))
2782 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2783 break;
2784 }
2785 } else
2786 (void) service_search_main_pid(s);
2787
2788 service_enter_start_post(s);
2789 break;
2790
2791 case SERVICE_START_POST:
2792 if (f != SERVICE_SUCCESS) {
2793 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2794 break;
2795 }
2796
2797 if (s->pid_file) {
2798 int r;
2799
2800 r = service_load_pid_file(s, true);
2801 if (r < 0) {
2802 r = service_demand_pid_file(s);
2803 if (r < 0 || !cgroup_good(s))
2804 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2805 break;
2806 }
2807 } else
2808 (void) service_search_main_pid(s);
2809
2810 service_enter_running(s, SERVICE_SUCCESS);
2811 break;
2812
2813 case SERVICE_RELOAD:
2814 if (f == SERVICE_SUCCESS) {
2815 service_load_pid_file(s, true);
2816 (void) service_search_main_pid(s);
2817 }
2818
2819 s->reload_result = f;
2820 service_enter_running(s, SERVICE_SUCCESS);
2821 break;
2822
2823 case SERVICE_STOP:
2824 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2825 break;
2826
2827 case SERVICE_STOP_SIGABRT:
2828 case SERVICE_STOP_SIGTERM:
2829 case SERVICE_STOP_SIGKILL:
2830 if (main_pid_good(s) <= 0)
2831 service_enter_stop_post(s, f);
2832
2833 /* If there is still a service
2834 * process around, wait until
2835 * that one quit, too */
2836 break;
2837
2838 case SERVICE_STOP_POST:
2839 case SERVICE_FINAL_SIGTERM:
2840 case SERVICE_FINAL_SIGKILL:
2841 if (main_pid_good(s) <= 0)
2842 service_enter_dead(s, f, true);
2843 break;
2844
2845 default:
2846 assert_not_reached("Uh, control process died at wrong time.");
2847 }
2848 }
2849 }
2850
2851 /* Notify clients about changed exit status */
2852 unit_add_to_dbus_queue(u);
2853
2854 /* We got one SIGCHLD for the service, let's watch all
2855 * processes that are now running of the service, and watch
2856 * that. Among the PIDs we then watch will be children
2857 * reassigned to us, which hopefully allows us to identify
2858 * when all children are gone */
2859 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2860 unit_watch_all_pids(u);
2861
2862 /* If the PID set is empty now, then let's finish this off */
2863 if (set_isempty(u->pids))
2864 service_notify_cgroup_empty_event(u);
2865 }
2866
2867 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2868 Service *s = SERVICE(userdata);
2869
2870 assert(s);
2871 assert(source == s->timer_event_source);
2872
2873 switch (s->state) {
2874
2875 case SERVICE_START_PRE:
2876 case SERVICE_START:
2877 log_unit_warning(UNIT(s), "%s operation timed out. Terminating.", s->state == SERVICE_START ? "Start" : "Start-pre");
2878 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2879 break;
2880
2881 case SERVICE_START_POST:
2882 log_unit_warning(UNIT(s), "Start-post operation timed out. Stopping.");
2883 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2884 break;
2885
2886 case SERVICE_RUNNING:
2887 log_unit_warning(UNIT(s), "Service reached runtime time limit. Stopping.");
2888 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2889 break;
2890
2891 case SERVICE_RELOAD:
2892 log_unit_warning(UNIT(s), "Reload operation timed out. Killing reload process.");
2893 service_kill_control_processes(s);
2894 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2895 service_enter_running(s, SERVICE_SUCCESS);
2896 break;
2897
2898 case SERVICE_STOP:
2899 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
2900 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2901 break;
2902
2903 case SERVICE_STOP_SIGABRT:
2904 log_unit_warning(UNIT(s), "State 'stop-sigabrt' timed out. Terminating.");
2905 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2906 break;
2907
2908 case SERVICE_STOP_SIGTERM:
2909 if (s->kill_context.send_sigkill) {
2910 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Killing.");
2911 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2912 } else {
2913 log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2914 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2915 }
2916
2917 break;
2918
2919 case SERVICE_STOP_SIGKILL:
2920 /* Uh, we sent a SIGKILL and it is still not gone?
2921 * Must be something we cannot kill, so let's just be
2922 * weirded out and continue */
2923
2924 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
2925 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2926 break;
2927
2928 case SERVICE_STOP_POST:
2929 log_unit_warning(UNIT(s), "State 'stop-post' timed out. Terminating.");
2930 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2931 break;
2932
2933 case SERVICE_FINAL_SIGTERM:
2934 if (s->kill_context.send_sigkill) {
2935 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Killing.");
2936 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2937 } else {
2938 log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2939 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2940 }
2941
2942 break;
2943
2944 case SERVICE_FINAL_SIGKILL:
2945 log_unit_warning(UNIT(s), "Processes still around after final SIGKILL. Entering failed mode.");
2946 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2947 break;
2948
2949 case SERVICE_AUTO_RESTART:
2950 log_unit_info(UNIT(s),
2951 s->restart_usec > 0 ?
2952 "Service hold-off time over, scheduling restart." :
2953 "Service has no hold-off time, scheduling restart.");
2954 service_enter_restart(s);
2955 break;
2956
2957 default:
2958 assert_not_reached("Timeout at wrong time.");
2959 }
2960
2961 return 0;
2962 }
2963
2964 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2965 Service *s = SERVICE(userdata);
2966 char t[FORMAT_TIMESPAN_MAX];
2967
2968 assert(s);
2969 assert(source == s->watchdog_event_source);
2970
2971 log_unit_error(UNIT(s), "Watchdog timeout (limit %s)!",
2972 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2973
2974 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2975
2976 return 0;
2977 }
2978
2979 static void service_notify_message(Unit *u, pid_t pid, char **tags, FDSet *fds) {
2980 Service *s = SERVICE(u);
2981 _cleanup_free_ char *cc = NULL;
2982 bool notify_dbus = false;
2983 const char *e;
2984
2985 assert(u);
2986
2987 cc = strv_join(tags, ", ");
2988
2989 if (s->notify_access == NOTIFY_NONE) {
2990 log_unit_warning(u, "Got notification message from PID "PID_FMT", but reception is disabled.", pid);
2991 return;
2992 } else if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2993 if (s->main_pid != 0)
2994 log_unit_warning(u, "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, pid, s->main_pid);
2995 else
2996 log_unit_debug(u, "Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", pid);
2997 return;
2998 } else
2999 log_unit_debug(u, "Got notification message from PID "PID_FMT" (%s)", pid, isempty(cc) ? "n/a" : cc);
3000
3001 /* Interpret MAINPID= */
3002 e = strv_find_startswith(tags, "MAINPID=");
3003 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
3004 if (parse_pid(e, &pid) < 0)
3005 log_unit_warning(u, "Failed to parse MAINPID= field in notification message: %s", e);
3006 else {
3007 service_set_main_pid(s, pid);
3008 unit_watch_pid(UNIT(s), pid);
3009 notify_dbus = true;
3010 }
3011 }
3012
3013 /* Interpret RELOADING= */
3014 if (strv_find(tags, "RELOADING=1")) {
3015
3016 s->notify_state = NOTIFY_RELOADING;
3017
3018 if (s->state == SERVICE_RUNNING)
3019 service_enter_reload_by_notify(s);
3020
3021 notify_dbus = true;
3022 }
3023
3024 /* Interpret READY= */
3025 if (strv_find(tags, "READY=1")) {
3026
3027 s->notify_state = NOTIFY_READY;
3028
3029 /* Type=notify services inform us about completed
3030 * initialization with READY=1 */
3031 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
3032 service_enter_start_post(s);
3033
3034 /* Sending READY=1 while we are reloading informs us
3035 * that the reloading is complete */
3036 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
3037 service_enter_running(s, SERVICE_SUCCESS);
3038
3039 notify_dbus = true;
3040 }
3041
3042 /* Interpret STOPPING= */
3043 if (strv_find(tags, "STOPPING=1")) {
3044
3045 s->notify_state = NOTIFY_STOPPING;
3046
3047 if (s->state == SERVICE_RUNNING)
3048 service_enter_stop_by_notify(s);
3049
3050 notify_dbus = true;
3051 }
3052
3053 /* Interpret STATUS= */
3054 e = strv_find_startswith(tags, "STATUS=");
3055 if (e) {
3056 _cleanup_free_ char *t = NULL;
3057
3058 if (!isempty(e)) {
3059 if (!utf8_is_valid(e))
3060 log_unit_warning(u, "Status message in notification message is not UTF-8 clean.");
3061 else {
3062 t = strdup(e);
3063 if (!t)
3064 log_oom();
3065 }
3066 }
3067
3068 if (!streq_ptr(s->status_text, t)) {
3069
3070 free(s->status_text);
3071 s->status_text = t;
3072 t = NULL;
3073
3074 notify_dbus = true;
3075 }
3076 }
3077
3078 /* Interpret ERRNO= */
3079 e = strv_find_startswith(tags, "ERRNO=");
3080 if (e) {
3081 int status_errno;
3082
3083 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
3084 log_unit_warning(u, "Failed to parse ERRNO= field in notification message: %s", e);
3085 else {
3086 if (s->status_errno != status_errno) {
3087 s->status_errno = status_errno;
3088 notify_dbus = true;
3089 }
3090 }
3091 }
3092
3093 /* Interpret WATCHDOG= */
3094 if (strv_find(tags, "WATCHDOG=1"))
3095 service_reset_watchdog(s);
3096
3097 if (strv_find(tags, "FDSTORE=1")) {
3098 const char *name;
3099
3100 name = strv_find_startswith(tags, "FDNAME=");
3101 if (name && !fdname_is_valid(name)) {
3102 log_unit_warning(u, "Passed FDNAME= name is invalid, ignoring.");
3103 name = NULL;
3104 }
3105
3106 service_add_fd_store_set(s, fds, name);
3107 }
3108
3109 /* Notify clients about changed status or main pid */
3110 if (notify_dbus)
3111 unit_add_to_dbus_queue(u);
3112 }
3113
3114 static int service_get_timeout(Unit *u, usec_t *timeout) {
3115 Service *s = SERVICE(u);
3116 uint64_t t;
3117 int r;
3118
3119 if (!s->timer_event_source)
3120 return 0;
3121
3122 r = sd_event_source_get_time(s->timer_event_source, &t);
3123 if (r < 0)
3124 return r;
3125 if (t == USEC_INFINITY)
3126 return 0;
3127
3128 *timeout = t;
3129 return 1;
3130 }
3131
3132 static void service_bus_name_owner_change(
3133 Unit *u,
3134 const char *name,
3135 const char *old_owner,
3136 const char *new_owner) {
3137
3138 Service *s = SERVICE(u);
3139 int r;
3140
3141 assert(s);
3142 assert(name);
3143
3144 assert(streq(s->bus_name, name));
3145 assert(old_owner || new_owner);
3146
3147 if (old_owner && new_owner)
3148 log_unit_debug(u, "D-Bus name %s changed owner from %s to %s", name, old_owner, new_owner);
3149 else if (old_owner)
3150 log_unit_debug(u, "D-Bus name %s no longer registered by %s", name, old_owner);
3151 else
3152 log_unit_debug(u, "D-Bus name %s now registered by %s", name, new_owner);
3153
3154 s->bus_name_good = !!new_owner;
3155
3156 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3157 r = free_and_strdup(&s->bus_name_owner, new_owner);
3158 if (r < 0) {
3159 log_unit_error_errno(u, r, "Unable to set new bus name owner %s: %m", new_owner);
3160 return;
3161 }
3162
3163 if (s->type == SERVICE_DBUS) {
3164
3165 /* service_enter_running() will figure out what to
3166 * do */
3167 if (s->state == SERVICE_RUNNING)
3168 service_enter_running(s, SERVICE_SUCCESS);
3169 else if (s->state == SERVICE_START && new_owner)
3170 service_enter_start_post(s);
3171
3172 } else if (new_owner &&
3173 s->main_pid <= 0 &&
3174 (s->state == SERVICE_START ||
3175 s->state == SERVICE_START_POST ||
3176 s->state == SERVICE_RUNNING ||
3177 s->state == SERVICE_RELOAD)) {
3178
3179 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
3180 pid_t pid;
3181
3182 /* Try to acquire PID from bus service */
3183
3184 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3185 if (r >= 0)
3186 r = sd_bus_creds_get_pid(creds, &pid);
3187 if (r >= 0) {
3188 log_unit_debug(u, "D-Bus name %s is now owned by process %u", name, (unsigned) pid);
3189
3190 service_set_main_pid(s, pid);
3191 unit_watch_pid(UNIT(s), pid);
3192 }
3193 }
3194 }
3195
3196 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
3197 _cleanup_free_ char *peer = NULL;
3198 int r;
3199
3200 assert(s);
3201 assert(fd >= 0);
3202
3203 /* This is called by the socket code when instantiating a new
3204 * service for a stream socket and the socket needs to be
3205 * configured. */
3206
3207 if (UNIT(s)->load_state != UNIT_LOADED)
3208 return -EINVAL;
3209
3210 if (s->socket_fd >= 0)
3211 return -EBUSY;
3212
3213 if (s->state != SERVICE_DEAD)
3214 return -EAGAIN;
3215
3216 if (getpeername_pretty(fd, true, &peer) >= 0) {
3217
3218 if (UNIT(s)->description) {
3219 _cleanup_free_ char *a;
3220
3221 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3222 if (!a)
3223 return -ENOMEM;
3224
3225 r = unit_set_description(UNIT(s), a);
3226 } else
3227 r = unit_set_description(UNIT(s), peer);
3228
3229 if (r < 0)
3230 return r;
3231 }
3232
3233 s->socket_fd = fd;
3234 s->socket_fd_selinux_context_net = selinux_context_net;
3235
3236 unit_ref_set(&s->accept_socket, UNIT(sock));
3237
3238 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3239 }
3240
3241 static void service_reset_failed(Unit *u) {
3242 Service *s = SERVICE(u);
3243
3244 assert(s);
3245
3246 if (s->state == SERVICE_FAILED)
3247 service_set_state(s, SERVICE_DEAD);
3248
3249 s->result = SERVICE_SUCCESS;
3250 s->reload_result = SERVICE_SUCCESS;
3251
3252 RATELIMIT_RESET(s->start_limit);
3253 }
3254
3255 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3256 Service *s = SERVICE(u);
3257
3258 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3259 }
3260
3261 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3262 [SERVICE_RESTART_NO] = "no",
3263 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3264 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3265 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
3266 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3267 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3268 [SERVICE_RESTART_ALWAYS] = "always",
3269 };
3270
3271 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3272
3273 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3274 [SERVICE_SIMPLE] = "simple",
3275 [SERVICE_FORKING] = "forking",
3276 [SERVICE_ONESHOT] = "oneshot",
3277 [SERVICE_DBUS] = "dbus",
3278 [SERVICE_NOTIFY] = "notify",
3279 [SERVICE_IDLE] = "idle"
3280 };
3281
3282 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3283
3284 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3285 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3286 [SERVICE_EXEC_START] = "ExecStart",
3287 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3288 [SERVICE_EXEC_RELOAD] = "ExecReload",
3289 [SERVICE_EXEC_STOP] = "ExecStop",
3290 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3291 };
3292
3293 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3294
3295 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3296 [NOTIFY_NONE] = "none",
3297 [NOTIFY_MAIN] = "main",
3298 [NOTIFY_ALL] = "all"
3299 };
3300
3301 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3302
3303 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3304 [NOTIFY_UNKNOWN] = "unknown",
3305 [NOTIFY_READY] = "ready",
3306 [NOTIFY_RELOADING] = "reloading",
3307 [NOTIFY_STOPPING] = "stopping",
3308 };
3309
3310 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3311
3312 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3313 [SERVICE_SUCCESS] = "success",
3314 [SERVICE_FAILURE_RESOURCES] = "resources",
3315 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3316 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3317 [SERVICE_FAILURE_SIGNAL] = "signal",
3318 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3319 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3320 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3321 };
3322
3323 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3324
3325 const UnitVTable service_vtable = {
3326 .object_size = sizeof(Service),
3327 .exec_context_offset = offsetof(Service, exec_context),
3328 .cgroup_context_offset = offsetof(Service, cgroup_context),
3329 .kill_context_offset = offsetof(Service, kill_context),
3330 .exec_runtime_offset = offsetof(Service, exec_runtime),
3331
3332 .sections =
3333 "Unit\0"
3334 "Service\0"
3335 "Install\0",
3336 .private_section = "Service",
3337
3338 .init = service_init,
3339 .done = service_done,
3340 .load = service_load,
3341 .release_resources = service_release_resources,
3342
3343 .coldplug = service_coldplug,
3344
3345 .dump = service_dump,
3346
3347 .start = service_start,
3348 .stop = service_stop,
3349 .reload = service_reload,
3350
3351 .can_reload = service_can_reload,
3352
3353 .kill = service_kill,
3354
3355 .serialize = service_serialize,
3356 .deserialize_item = service_deserialize_item,
3357
3358 .active_state = service_active_state,
3359 .sub_state_to_string = service_sub_state_to_string,
3360
3361 .check_gc = service_check_gc,
3362
3363 .sigchld_event = service_sigchld_event,
3364
3365 .reset_failed = service_reset_failed,
3366
3367 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3368 .notify_message = service_notify_message,
3369
3370 .bus_name_owner_change = service_bus_name_owner_change,
3371
3372 .bus_vtable = bus_service_vtable,
3373 .bus_set_property = bus_service_set_property,
3374 .bus_commit_properties = bus_service_commit_properties,
3375
3376 .get_timeout = service_get_timeout,
3377 .can_transient = true,
3378
3379 .status_message_formats = {
3380 .starting_stopping = {
3381 [0] = "Starting %s...",
3382 [1] = "Stopping %s...",
3383 },
3384 .finished_start_job = {
3385 [JOB_DONE] = "Started %s.",
3386 [JOB_FAILED] = "Failed to start %s.",
3387 },
3388 .finished_stop_job = {
3389 [JOB_DONE] = "Stopped %s.",
3390 [JOB_FAILED] = "Stopped (with error) %s.",
3391 },
3392 },
3393 };
Unnamed repository; edit this file 'description' to name the repository.