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