src/core/service.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <signal.h>
   5 #include <sys/stat.h>
   6 #include <sys/types.h>
   7 #include <unistd.h>
   8
   9 #include "sd-messages.h"
  10
  11 #include "alloc-util.h"
  12 #include "async.h"
  13 #include "bus-error.h"
  14 #include "bus-kernel.h"
  15 #include "bus-util.h"
  16 #include "dbus-service.h"
  17 #include "dbus-unit.h"
  18 #include "def.h"
  19 #include "env-util.h"
  20 #include "escape.h"
  21 #include "exit-status.h"
  22 #include "fd-util.h"
  23 #include "fileio.h"
  24 #include "format-util.h"
  25 #include "fs-util.h"
  26 #include "load-dropin.h"
  27 #include "load-fragment.h"
  28 #include "log.h"
  29 #include "manager.h"
  30 #include "parse-util.h"
  31 #include "path-util.h"
  32 #include "process-util.h"
  33 #include "serialize.h"
  34 #include "service.h"
  35 #include "signal-util.h"
  36 #include "special.h"
  37 #include "stdio-util.h"
  38 #include "string-table.h"
  39 #include "string-util.h"
  40 #include "strv.h"
  41 #include "unit-name.h"
  42 #include "unit.h"
  43 #include "utf8.h"
  44 #include "util.h"
  45
  46 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
  47         [SERVICE_DEAD] = UNIT_INACTIVE,
  48         [SERVICE_CONDITION] = UNIT_ACTIVATING,
  49         [SERVICE_START_PRE] = UNIT_ACTIVATING,
  50         [SERVICE_START] = UNIT_ACTIVATING,
  51         [SERVICE_START_POST] = UNIT_ACTIVATING,
  52         [SERVICE_RUNNING] = UNIT_ACTIVE,
  53         [SERVICE_EXITED] = UNIT_ACTIVE,
  54         [SERVICE_RELOAD] = UNIT_RELOADING,
  55         [SERVICE_STOP] = UNIT_DEACTIVATING,
  56         [SERVICE_STOP_WATCHDOG] = UNIT_DEACTIVATING,
  57         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
  58         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
  59         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
  60         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  61         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  62         [SERVICE_FAILED] = UNIT_FAILED,
  63         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
  64         [SERVICE_CLEANING] = UNIT_MAINTENANCE,
  65 };
  66
  67 /* For Type=idle we never want to delay any other jobs, hence we
  68  * consider idle jobs active as soon as we start working on them */
  69 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
  70         [SERVICE_DEAD] = UNIT_INACTIVE,
  71         [SERVICE_CONDITION] = UNIT_ACTIVE,
  72         [SERVICE_START_PRE] = UNIT_ACTIVE,
  73         [SERVICE_START] = UNIT_ACTIVE,
  74         [SERVICE_START_POST] = UNIT_ACTIVE,
  75         [SERVICE_RUNNING] = UNIT_ACTIVE,
  76         [SERVICE_EXITED] = UNIT_ACTIVE,
  77         [SERVICE_RELOAD] = UNIT_RELOADING,
  78         [SERVICE_STOP] = UNIT_DEACTIVATING,
  79         [SERVICE_STOP_WATCHDOG] = UNIT_DEACTIVATING,
  80         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
  81         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
  82         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
  83         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  84         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  85         [SERVICE_FAILED] = UNIT_FAILED,
  86         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
  87         [SERVICE_CLEANING] = UNIT_MAINTENANCE,
  88 };
  89
  90 static int service_dispatch_inotify_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
  91 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  92 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
  93 static int service_dispatch_exec_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
  94
  95 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
  96 static void service_enter_reload_by_notify(Service *s);
  97
  98 static void service_init(Unit *u) {
  99         Service *s = SERVICE(u);
 100
 101         assert(u);
 102         assert(u->load_state == UNIT_STUB);
 103
 104         s->timeout_start_usec = u->manager->default_timeout_start_usec;
 105         s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
 106         s->timeout_abort_usec = u->manager->default_timeout_abort_usec;
 107         s->timeout_abort_set = u->manager->default_timeout_abort_set;
 108         s->restart_usec = u->manager->default_restart_usec;
 109         s->runtime_max_usec = USEC_INFINITY;
 110         s->type = _SERVICE_TYPE_INVALID;
 111         s->socket_fd = -1;
 112         s->stdin_fd = s->stdout_fd = s->stderr_fd = -1;
 113         s->guess_main_pid = true;
 114
 115         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
 116
 117         s->exec_context.keyring_mode = MANAGER_IS_SYSTEM(u->manager) ?
 118                 EXEC_KEYRING_PRIVATE : EXEC_KEYRING_INHERIT;
 119
 120         s->watchdog_original_usec = USEC_INFINITY;
 121
 122         s->oom_policy = _OOM_POLICY_INVALID;
 123 }
 124
 125 static void service_unwatch_control_pid(Service *s) {
 126         assert(s);
 127
 128         if (s->control_pid <= 0)
 129                 return;
 130
 131         unit_unwatch_pid(UNIT(s), s->control_pid);
 132         s->control_pid = 0;
 133 }
 134
 135 static void service_unwatch_main_pid(Service *s) {
 136         assert(s);
 137
 138         if (s->main_pid <= 0)
 139                 return;
 140
 141         unit_unwatch_pid(UNIT(s), s->main_pid);
 142         s->main_pid = 0;
 143 }
 144
 145 static void service_unwatch_pid_file(Service *s) {
 146         if (!s->pid_file_pathspec)
 147                 return;
 148
 149         log_unit_debug(UNIT(s), "Stopping watch for PID file %s", s->pid_file_pathspec->path);
 150         path_spec_unwatch(s->pid_file_pathspec);
 151         path_spec_done(s->pid_file_pathspec);
 152         s->pid_file_pathspec = mfree(s->pid_file_pathspec);
 153 }
 154
 155 static int service_set_main_pid(Service *s, pid_t pid) {
 156         assert(s);
 157
 158         if (pid <= 1)
 159                 return -EINVAL;
 160
 161         if (pid == getpid_cached())
 162                 return -EINVAL;
 163
 164         if (s->main_pid == pid && s->main_pid_known)
 165                 return 0;
 166
 167         if (s->main_pid != pid) {
 168                 service_unwatch_main_pid(s);
 169                 exec_status_start(&s->main_exec_status, pid);
 170         }
 171
 172         s->main_pid = pid;
 173         s->main_pid_known = true;
 174         s->main_pid_alien = pid_is_my_child(pid) == 0;
 175
 176         if (s->main_pid_alien)
 177                 log_unit_warning(UNIT(s), "Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", pid);
 178
 179         return 0;
 180 }
 181
 182 void service_close_socket_fd(Service *s) {
 183         assert(s);
 184
 185         /* Undo the effect of service_set_socket_fd(). */
 186
 187         s->socket_fd = asynchronous_close(s->socket_fd);
 188
 189         if (UNIT_ISSET(s->accept_socket)) {
 190                 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
 191                 unit_ref_unset(&s->accept_socket);
 192         }
 193 }
 194
 195 static void service_stop_watchdog(Service *s) {
 196         assert(s);
 197
 198         s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
 199         s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
 200 }
 201
 202 static usec_t service_get_watchdog_usec(Service *s) {
 203         assert(s);
 204
 205         if (s->watchdog_override_enable)
 206                 return s->watchdog_override_usec;
 207
 208         return s->watchdog_original_usec;
 209 }
 210
 211 static void service_start_watchdog(Service *s) {
 212         usec_t watchdog_usec;
 213         int r;
 214
 215         assert(s);
 216
 217         watchdog_usec = service_get_watchdog_usec(s);
 218         if (IN_SET(watchdog_usec, 0, USEC_INFINITY)) {
 219                 service_stop_watchdog(s);
 220                 return;
 221         }
 222
 223         if (s->watchdog_event_source) {
 224                 r = sd_event_source_set_time(s->watchdog_event_source, usec_add(s->watchdog_timestamp.monotonic, watchdog_usec));
 225                 if (r < 0) {
 226                         log_unit_warning_errno(UNIT(s), r, "Failed to reset watchdog timer: %m");
 227                         return;
 228                 }
 229
 230                 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
 231         } else {
 232                 r = sd_event_add_time(
 233                                 UNIT(s)->manager->event,
 234                                 &s->watchdog_event_source,
 235                                 CLOCK_MONOTONIC,
 236                                 usec_add(s->watchdog_timestamp.monotonic, watchdog_usec), 0,
 237                                 service_dispatch_watchdog, s);
 238                 if (r < 0) {
 239                         log_unit_warning_errno(UNIT(s), r, "Failed to add watchdog timer: %m");
 240                         return;
 241                 }
 242
 243                 (void) sd_event_source_set_description(s->watchdog_event_source, "service-watchdog");
 244
 245                 /* Let's process everything else which might be a sign
 246                  * of living before we consider a service died. */
 247                 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
 248         }
 249         if (r < 0)
 250                 log_unit_warning_errno(UNIT(s), r, "Failed to install watchdog timer: %m");
 251 }
 252
 253 static void service_extend_event_source_timeout(Service *s, sd_event_source *source, usec_t extended) {
 254         usec_t current;
 255         int r;
 256
 257         assert(s);
 258
 259         /* Extends the specified event source timer to at least the specified time, unless it is already later
 260          * anyway. */
 261
 262         if (!source)
 263                 return;
 264
 265         r = sd_event_source_get_time(source, &current);
 266         if (r < 0) {
 267                 const char *desc;
 268                 (void) sd_event_source_get_description(s->timer_event_source, &desc);
 269                 log_unit_warning_errno(UNIT(s), r, "Failed to retrieve timeout time for event source '%s', ignoring: %m", strna(desc));
 270                 return;
 271         }
 272
 273         if (current >= extended) /* Current timeout is already longer, ignore this. */
 274                 return;
 275
 276         r = sd_event_source_set_time(source, extended);
 277         if (r < 0) {
 278                 const char *desc;
 279                 (void) sd_event_source_get_description(s->timer_event_source, &desc);
 280                 log_unit_warning_errno(UNIT(s), r, "Failed to set timeout time for even source '%s', ignoring %m", strna(desc));
 281         }
 282 }
 283
 284 static void service_extend_timeout(Service *s, usec_t extend_timeout_usec) {
 285         usec_t extended;
 286
 287         assert(s);
 288
 289         if (IN_SET(extend_timeout_usec, 0, USEC_INFINITY))
 290                 return;
 291
 292         extended = usec_add(now(CLOCK_MONOTONIC), extend_timeout_usec);
 293
 294         service_extend_event_source_timeout(s, s->timer_event_source, extended);
 295         service_extend_event_source_timeout(s, s->watchdog_event_source, extended);
 296 }
 297
 298 static void service_reset_watchdog(Service *s) {
 299         assert(s);
 300
 301         dual_timestamp_get(&s->watchdog_timestamp);
 302         service_start_watchdog(s);
 303 }
 304
 305 static void service_override_watchdog_timeout(Service *s, usec_t watchdog_override_usec) {
 306         assert(s);
 307
 308         s->watchdog_override_enable = true;
 309         s->watchdog_override_usec = watchdog_override_usec;
 310         service_reset_watchdog(s);
 311
 312         log_unit_debug(UNIT(s), "watchdog_usec="USEC_FMT, s->watchdog_usec);
 313         log_unit_debug(UNIT(s), "watchdog_override_usec="USEC_FMT, s->watchdog_override_usec);
 314 }
 315
 316 static void service_fd_store_unlink(ServiceFDStore *fs) {
 317
 318         if (!fs)
 319                 return;
 320
 321         if (fs->service) {
 322                 assert(fs->service->n_fd_store > 0);
 323                 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
 324                 fs->service->n_fd_store--;
 325         }
 326
 327         sd_event_source_disable_unref(fs->event_source);
 328
 329         free(fs->fdname);
 330         safe_close(fs->fd);
 331         free(fs);
 332 }
 333
 334 static void service_release_fd_store(Service *s) {
 335         assert(s);
 336
 337         if (s->n_keep_fd_store > 0)
 338                 return;
 339
 340         log_unit_debug(UNIT(s), "Releasing all stored fds");
 341         while (s->fd_store)
 342                 service_fd_store_unlink(s->fd_store);
 343
 344         assert(s->n_fd_store == 0);
 345 }
 346
 347 static void service_release_resources(Unit *u) {
 348         Service *s = SERVICE(u);
 349
 350         assert(s);
 351
 352         if (!s->fd_store && s->stdin_fd < 0 && s->stdout_fd < 0 && s->stderr_fd < 0)
 353                 return;
 354
 355         log_unit_debug(u, "Releasing resources.");
 356
 357         s->stdin_fd = safe_close(s->stdin_fd);
 358         s->stdout_fd = safe_close(s->stdout_fd);
 359         s->stderr_fd = safe_close(s->stderr_fd);
 360
 361         service_release_fd_store(s);
 362 }
 363
 364 static void service_done(Unit *u) {
 365         Service *s = SERVICE(u);
 366
 367         assert(s);
 368
 369         s->pid_file = mfree(s->pid_file);
 370         s->status_text = mfree(s->status_text);
 371
 372         s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
 373         exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
 374         s->control_command = NULL;
 375         s->main_command = NULL;
 376
 377         dynamic_creds_unref(&s->dynamic_creds);
 378
 379         exit_status_set_free(&s->restart_prevent_status);
 380         exit_status_set_free(&s->restart_force_status);
 381         exit_status_set_free(&s->success_status);
 382
 383         /* This will leak a process, but at least no memory or any of
 384          * our resources */
 385         service_unwatch_main_pid(s);
 386         service_unwatch_control_pid(s);
 387         service_unwatch_pid_file(s);
 388
 389         if (s->bus_name)  {
 390                 unit_unwatch_bus_name(u, s->bus_name);
 391                 s->bus_name = mfree(s->bus_name);
 392         }
 393
 394         s->bus_name_owner = mfree(s->bus_name_owner);
 395
 396         s->usb_function_descriptors = mfree(s->usb_function_descriptors);
 397         s->usb_function_strings = mfree(s->usb_function_strings);
 398
 399         service_close_socket_fd(s);
 400         s->peer = socket_peer_unref(s->peer);
 401
 402         unit_ref_unset(&s->accept_socket);
 403
 404         service_stop_watchdog(s);
 405
 406         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 407         s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
 408
 409         service_release_resources(u);
 410 }
 411
 412 static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
 413         ServiceFDStore *fs = userdata;
 414
 415         assert(e);
 416         assert(fs);
 417
 418         /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
 419         log_unit_debug(UNIT(fs->service),
 420                        "Received %s on stored fd %d (%s), closing.",
 421                        revents & EPOLLERR ? "EPOLLERR" : "EPOLLHUP",
 422                        fs->fd, strna(fs->fdname));
 423         service_fd_store_unlink(fs);
 424         return 0;
 425 }
 426
 427 static int service_add_fd_store(Service *s, int fd, const char *name) {
 428         ServiceFDStore *fs;
 429         int r;
 430
 431         /* fd is always consumed if we return >= 0 */
 432
 433         assert(s);
 434         assert(fd >= 0);
 435
 436         if (s->n_fd_store >= s->n_fd_store_max)
 437                 return -EXFULL; /* Our store is full.
 438                                  * Use this errno rather than E[NM]FILE to distinguish from
 439                                  * the case where systemd itself hits the file limit. */
 440
 441         LIST_FOREACH(fd_store, fs, s->fd_store) {
 442                 r = same_fd(fs->fd, fd);
 443                 if (r < 0)
 444                         return r;
 445                 if (r > 0) {
 446                         safe_close(fd);
 447                         return 0; /* fd already included */
 448                 }
 449         }
 450
 451         fs = new0(ServiceFDStore, 1);
 452         if (!fs)
 453                 return -ENOMEM;
 454
 455         fs->fd = fd;
 456         fs->service = s;
 457         fs->fdname = strdup(name ?: "stored");
 458         if (!fs->fdname) {
 459                 free(fs);
 460                 return -ENOMEM;
 461         }
 462
 463         r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
 464         if (r < 0 && r != -EPERM) { /* EPERM indicates fds that aren't pollable, which is OK */
 465                 free(fs->fdname);
 466                 free(fs);
 467                 return r;
 468         } else if (r >= 0)
 469                 (void) sd_event_source_set_description(fs->event_source, "service-fd-store");
 470
 471         LIST_PREPEND(fd_store, s->fd_store, fs);
 472         s->n_fd_store++;
 473
 474         return 1; /* fd newly stored */
 475 }
 476
 477 static int service_add_fd_store_set(Service *s, FDSet *fds, const char *name) {
 478         int r;
 479
 480         assert(s);
 481
 482         while (fdset_size(fds) > 0) {
 483                 _cleanup_close_ int fd = -1;
 484
 485                 fd = fdset_steal_first(fds);
 486                 if (fd < 0)
 487                         break;
 488
 489                 r = service_add_fd_store(s, fd, name);
 490                 if (r == -EXFULL)
 491                         return log_unit_warning_errno(UNIT(s), r,
 492                                                       "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
 493                                                       s->n_fd_store_max);
 494                 if (r < 0)
 495                         return log_unit_error_errno(UNIT(s), r, "Failed to add fd to store: %m");
 496                 if (r > 0)
 497                         log_unit_debug(UNIT(s), "Added fd %u (%s) to fd store.", fd, strna(name));
 498                 fd = -1;
 499         }
 500
 501         return 0;
 502 }
 503
 504 static void service_remove_fd_store(Service *s, const char *name) {
 505         ServiceFDStore *fs, *n;
 506
 507         assert(s);
 508         assert(name);
 509
 510         LIST_FOREACH_SAFE(fd_store, fs, n, s->fd_store) {
 511                 if (!streq(fs->fdname, name))
 512                         continue;
 513
 514                 log_unit_debug(UNIT(s), "Got explicit request to remove fd %i (%s), closing.", fs->fd, name);
 515                 service_fd_store_unlink(fs);
 516         }
 517 }
 518
 519 static int service_arm_timer(Service *s, usec_t usec) {
 520         int r;
 521
 522         assert(s);
 523
 524         if (s->timer_event_source) {
 525                 r = sd_event_source_set_time(s->timer_event_source, usec);
 526                 if (r < 0)
 527                         return r;
 528
 529                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 530         }
 531
 532         if (usec == USEC_INFINITY)
 533                 return 0;
 534
 535         r = sd_event_add_time(
 536                         UNIT(s)->manager->event,
 537                         &s->timer_event_source,
 538                         CLOCK_MONOTONIC,
 539                         usec, 0,
 540                         service_dispatch_timer, s);
 541         if (r < 0)
 542                 return r;
 543
 544         (void) sd_event_source_set_description(s->timer_event_source, "service-timer");
 545
 546         return 0;
 547 }
 548
 549 static int service_verify(Service *s) {
 550         assert(s);
 551
 552         if (UNIT(s)->load_state != UNIT_LOADED)
 553                 return 0;
 554
 555         if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]
 556             && UNIT(s)->success_action == EMERGENCY_ACTION_NONE) {
 557                 /* FailureAction= only makes sense if one of the start or stop commands is specified.
 558                  * SuccessAction= will be executed unconditionally if no commands are specified. Hence,
 559                  * either a command or SuccessAction= are required. */
 560
 561                 log_unit_error(UNIT(s), "Service has no ExecStart=, ExecStop=, or SuccessAction=. Refusing.");
 562                 return -ENOEXEC;
 563         }
 564
 565         if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
 566                 log_unit_error(UNIT(s), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
 567                 return -ENOEXEC;
 568         }
 569
 570         if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START] && UNIT(s)->success_action == EMERGENCY_ACTION_NONE) {
 571                 log_unit_error(UNIT(s), "Service has no ExecStart= and no SuccessAction= settings and does not have RemainAfterExit=yes set. Refusing.");
 572                 return -ENOEXEC;
 573         }
 574
 575         if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
 576                 log_unit_error(UNIT(s), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
 577                 return -ENOEXEC;
 578         }
 579
 580         if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
 581                 log_unit_error(UNIT(s), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
 582                 return -ENOEXEC;
 583         }
 584
 585         if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
 586                 log_unit_error(UNIT(s), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
 587                 return -ENOEXEC;
 588         }
 589
 590         if (s->type == SERVICE_DBUS && !s->bus_name) {
 591                 log_unit_error(UNIT(s), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
 592                 return -ENOEXEC;
 593         }
 594
 595         if (s->bus_name && s->type != SERVICE_DBUS)
 596                 log_unit_warning(UNIT(s), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
 597
 598         if (s->exec_context.pam_name && !IN_SET(s->kill_context.kill_mode, KILL_CONTROL_GROUP, KILL_MIXED)) {
 599                 log_unit_error(UNIT(s), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
 600                 return -ENOEXEC;
 601         }
 602
 603         if (s->usb_function_descriptors && !s->usb_function_strings)
 604                 log_unit_warning(UNIT(s), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
 605
 606         if (!s->usb_function_descriptors && s->usb_function_strings)
 607                 log_unit_warning(UNIT(s), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
 608
 609         if (s->runtime_max_usec != USEC_INFINITY && s->type == SERVICE_ONESHOT)
 610                 log_unit_warning(UNIT(s), "RuntimeMaxSec= has no effect in combination with Type=oneshot. Ignoring.");
 611
 612         return 0;
 613 }
 614
 615 static int service_add_default_dependencies(Service *s) {
 616         int r;
 617
 618         assert(s);
 619
 620         if (!UNIT(s)->default_dependencies)
 621                 return 0;
 622
 623         /* Add a number of automatic dependencies useful for the
 624          * majority of services. */
 625
 626         if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
 627                 /* First, pull in the really early boot stuff, and
 628                  * require it, so that we fail if we can't acquire
 629                  * it. */
 630
 631                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 632                 if (r < 0)
 633                         return r;
 634         } else {
 635
 636                 /* In the --user instance there's no sysinit.target,
 637                  * in that case require basic.target instead. */
 638
 639                 r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_BASIC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 640                 if (r < 0)
 641                         return r;
 642         }
 643
 644         /* Second, if the rest of the base system is in the same
 645          * transaction, order us after it, but do not pull it in or
 646          * even require it. */
 647         r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_BASIC_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 648         if (r < 0)
 649                 return r;
 650
 651         /* Third, add us in for normal shutdown. */
 652         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 653 }
 654
 655 static void service_fix_output(Service *s) {
 656         assert(s);
 657
 658         /* If nothing has been explicitly configured, patch default output in. If input is socket/tty we avoid this
 659          * however, since in that case we want output to default to the same place as we read input from. */
 660
 661         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
 662             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
 663             s->exec_context.std_input == EXEC_INPUT_NULL)
 664                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
 665
 666         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
 667             s->exec_context.std_input == EXEC_INPUT_NULL)
 668                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
 669
 670         if (s->exec_context.std_input == EXEC_INPUT_NULL &&
 671             s->exec_context.stdin_data_size > 0)
 672                 s->exec_context.std_input = EXEC_INPUT_DATA;
 673 }
 674
 675 static int service_setup_bus_name(Service *s) {
 676         int r;
 677
 678         assert(s);
 679
 680         if (!s->bus_name)
 681                 return 0;
 682
 683         r = unit_add_dependency_by_name(UNIT(s), UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, true, UNIT_DEPENDENCY_FILE);
 684         if (r < 0)
 685                 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
 686
 687         /* We always want to be ordered against dbus.socket if both are in the transaction. */
 688         r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_DBUS_SOCKET, true, UNIT_DEPENDENCY_FILE);
 689         if (r < 0)
 690                 return log_unit_error_errno(UNIT(s), r, "Failed to add dependency on " SPECIAL_DBUS_SOCKET ": %m");
 691
 692         r = unit_watch_bus_name(UNIT(s), s->bus_name);
 693         if (r == -EEXIST)
 694                 return log_unit_error_errno(UNIT(s), r, "Two services allocated for the same bus name %s, refusing operation.", s->bus_name);
 695         if (r < 0)
 696                 return log_unit_error_errno(UNIT(s), r, "Cannot watch bus name %s: %m", s->bus_name);
 697
 698         return 0;
 699 }
 700
 701 static int service_add_extras(Service *s) {
 702         int r;
 703
 704         assert(s);
 705
 706         if (s->type == _SERVICE_TYPE_INVALID) {
 707                 /* Figure out a type automatically */
 708                 if (s->bus_name)
 709                         s->type = SERVICE_DBUS;
 710                 else if (s->exec_command[SERVICE_EXEC_START])
 711                         s->type = SERVICE_SIMPLE;
 712                 else
 713                         s->type = SERVICE_ONESHOT;
 714         }
 715
 716         /* Oneshot services have disabled start timeout by default */
 717         if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
 718                 s->timeout_start_usec = USEC_INFINITY;
 719
 720         service_fix_output(s);
 721
 722         r = unit_patch_contexts(UNIT(s));
 723         if (r < 0)
 724                 return r;
 725
 726         r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
 727         if (r < 0)
 728                 return r;
 729
 730         r = unit_set_default_slice(UNIT(s));
 731         if (r < 0)
 732                 return r;
 733
 734         /* If the service needs the notify socket, let's enable it automatically. */
 735         if (s->notify_access == NOTIFY_NONE &&
 736             (s->type == SERVICE_NOTIFY || s->watchdog_usec > 0 || s->n_fd_store_max > 0))
 737                 s->notify_access = NOTIFY_MAIN;
 738
 739         /* If no OOM policy was explicitly set, then default to the configure default OOM policy. Except when
 740          * delegation is on, in that case it we assume the payload knows better what to do and can process
 741          * things in a more focused way. */
 742         if (s->oom_policy < 0)
 743                 s->oom_policy = s->cgroup_context.delegate ? OOM_CONTINUE : UNIT(s)->manager->default_oom_policy;
 744
 745         /* Let the kernel do the killing if that's requested. */
 746         s->cgroup_context.memory_oom_group = s->oom_policy == OOM_KILL;
 747
 748         r = service_add_default_dependencies(s);
 749         if (r < 0)
 750                 return r;
 751
 752         r = service_setup_bus_name(s);
 753         if (r < 0)
 754                 return r;
 755
 756         return 0;
 757 }
 758
 759 static int service_load(Unit *u) {
 760         Service *s = SERVICE(u);
 761         int r;
 762
 763         assert(s);
 764
 765         /* Load a .service file */
 766         r = unit_load_fragment(u);
 767         if (r < 0)
 768                 return r;
 769
 770         /* Still nothing found? Then let's give up */
 771         if (u->load_state == UNIT_STUB)
 772                 return -ENOENT;
 773
 774         /* This is a new unit? Then let's add in some extras */
 775         if (u->load_state == UNIT_LOADED) {
 776
 777                 /* We were able to load something, then let's add in
 778                  * the dropin directories. */
 779                 r = unit_load_dropin(u);
 780                 if (r < 0)
 781                         return r;
 782
 783                 /* This is a new unit? Then let's add in some
 784                  * extras */
 785                 r = service_add_extras(s);
 786                 if (r < 0)
 787                         return r;
 788         }
 789
 790         return service_verify(s);
 791 }
 792
 793 static void service_dump(Unit *u, FILE *f, const char *prefix) {
 794         char buf_restart[FORMAT_TIMESPAN_MAX], buf_start[FORMAT_TIMESPAN_MAX], buf_stop[FORMAT_TIMESPAN_MAX],
 795                 buf_runtime[FORMAT_TIMESPAN_MAX], buf_watchdog[FORMAT_TIMESPAN_MAX], buf_abort[FORMAT_TIMESPAN_MAX];
 796         ServiceExecCommand c;
 797         Service *s = SERVICE(u);
 798         const char *prefix2;
 799
 800         assert(s);
 801
 802         prefix = strempty(prefix);
 803         prefix2 = strjoina(prefix, "\t");
 804
 805         fprintf(f,
 806                 "%sService State: %s\n"
 807                 "%sResult: %s\n"
 808                 "%sReload Result: %s\n"
 809                 "%sClean Result: %s\n"
 810                 "%sPermissionsStartOnly: %s\n"
 811                 "%sRootDirectoryStartOnly: %s\n"
 812                 "%sRemainAfterExit: %s\n"
 813                 "%sGuessMainPID: %s\n"
 814                 "%sType: %s\n"
 815                 "%sRestart: %s\n"
 816                 "%sNotifyAccess: %s\n"
 817                 "%sNotifyState: %s\n"
 818                 "%sOOMPolicy: %s\n",
 819                 prefix, service_state_to_string(s->state),
 820                 prefix, service_result_to_string(s->result),
 821                 prefix, service_result_to_string(s->reload_result),
 822                 prefix, service_result_to_string(s->clean_result),
 823                 prefix, yes_no(s->permissions_start_only),
 824                 prefix, yes_no(s->root_directory_start_only),
 825                 prefix, yes_no(s->remain_after_exit),
 826                 prefix, yes_no(s->guess_main_pid),
 827                 prefix, service_type_to_string(s->type),
 828                 prefix, service_restart_to_string(s->restart),
 829                 prefix, notify_access_to_string(s->notify_access),
 830                 prefix, notify_state_to_string(s->notify_state),
 831                 prefix, oom_policy_to_string(s->oom_policy));
 832
 833         if (s->control_pid > 0)
 834                 fprintf(f,
 835                         "%sControl PID: "PID_FMT"\n",
 836                         prefix, s->control_pid);
 837
 838         if (s->main_pid > 0)
 839                 fprintf(f,
 840                         "%sMain PID: "PID_FMT"\n"
 841                         "%sMain PID Known: %s\n"
 842                         "%sMain PID Alien: %s\n",
 843                         prefix, s->main_pid,
 844                         prefix, yes_no(s->main_pid_known),
 845                         prefix, yes_no(s->main_pid_alien));
 846
 847         if (s->pid_file)
 848                 fprintf(f,
 849                         "%sPIDFile: %s\n",
 850                         prefix, s->pid_file);
 851
 852         if (s->bus_name)
 853                 fprintf(f,
 854                         "%sBusName: %s\n"
 855                         "%sBus Name Good: %s\n",
 856                         prefix, s->bus_name,
 857                         prefix, yes_no(s->bus_name_good));
 858
 859         if (UNIT_ISSET(s->accept_socket))
 860                 fprintf(f,
 861                         "%sAccept Socket: %s\n",
 862                         prefix, UNIT_DEREF(s->accept_socket)->id);
 863
 864         fprintf(f,
 865                 "%sRestartSec: %s\n"
 866                 "%sTimeoutStartSec: %s\n"
 867                 "%sTimeoutStopSec: %s\n",
 868                 prefix, format_timespan(buf_restart, sizeof(buf_restart), s->restart_usec, USEC_PER_SEC),
 869                 prefix, format_timespan(buf_start, sizeof(buf_start), s->timeout_start_usec, USEC_PER_SEC),
 870                 prefix, format_timespan(buf_stop, sizeof(buf_stop), s->timeout_stop_usec, USEC_PER_SEC));
 871
 872         if (s->timeout_abort_set)
 873                 fprintf(f,
 874                         "%sTimeoutAbortSec: %s\n",
 875                         prefix, format_timespan(buf_abort, sizeof(buf_abort), s->timeout_abort_usec, USEC_PER_SEC));
 876
 877         fprintf(f,
 878                 "%sRuntimeMaxSec: %s\n"
 879                 "%sWatchdogSec: %s\n",
 880                 prefix, format_timespan(buf_runtime, sizeof(buf_runtime), s->runtime_max_usec, USEC_PER_SEC),
 881                 prefix, format_timespan(buf_watchdog, sizeof(buf_watchdog), s->watchdog_usec, USEC_PER_SEC));
 882
 883         kill_context_dump(&s->kill_context, f, prefix);
 884         exec_context_dump(&s->exec_context, f, prefix);
 885
 886         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
 887
 888                 if (!s->exec_command[c])
 889                         continue;
 890
 891                 fprintf(f, "%s-> %s:\n",
 892                         prefix, service_exec_command_to_string(c));
 893
 894                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 895         }
 896
 897         if (s->status_text)
 898                 fprintf(f, "%sStatus Text: %s\n",
 899                         prefix, s->status_text);
 900
 901         if (s->n_fd_store_max > 0)
 902                 fprintf(f,
 903                         "%sFile Descriptor Store Max: %u\n"
 904                         "%sFile Descriptor Store Current: %zu\n",
 905                         prefix, s->n_fd_store_max,
 906                         prefix, s->n_fd_store);
 907
 908         cgroup_context_dump(&s->cgroup_context, f, prefix);
 909 }
 910
 911 static int service_is_suitable_main_pid(Service *s, pid_t pid, int prio) {
 912         Unit *owner;
 913
 914         assert(s);
 915         assert(pid_is_valid(pid));
 916
 917         /* Checks whether the specified PID is suitable as main PID for this service. returns negative if not, 0 if the
 918          * PID is questionnable but should be accepted if the source of configuration is trusted. > 0 if the PID is
 919          * good */
 920
 921         if (pid == getpid_cached() || pid == 1) {
 922                 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the manager, refusing.", pid);
 923                 return -EPERM;
 924         }
 925
 926         if (pid == s->control_pid) {
 927                 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" is the control process, refusing.", pid);
 928                 return -EPERM;
 929         }
 930
 931         if (!pid_is_alive(pid)) {
 932                 log_unit_full(UNIT(s), prio, 0, "New main PID "PID_FMT" does not exist or is a zombie.", pid);
 933                 return -ESRCH;
 934         }
 935
 936         owner = manager_get_unit_by_pid(UNIT(s)->manager, pid);
 937         if (owner == UNIT(s)) {
 938                 log_unit_debug(UNIT(s), "New main PID "PID_FMT" belongs to service, we are happy.", pid);
 939                 return 1; /* Yay, it's definitely a good PID */
 940         }
 941
 942         return 0; /* Hmm it's a suspicious PID, let's accept it if configuration source is trusted */
 943 }
 944
 945 static int service_load_pid_file(Service *s, bool may_warn) {
 946         char procfs[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
 947         bool questionable_pid_file = false;
 948         _cleanup_free_ char *k = NULL;
 949         _cleanup_close_ int fd = -1;
 950         int r, prio;
 951         pid_t pid;
 952
 953         assert(s);
 954
 955         if (!s->pid_file)
 956                 return -ENOENT;
 957
 958         prio = may_warn ? LOG_INFO : LOG_DEBUG;
 959
 960         fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN|CHASE_SAFE, NULL);
 961         if (fd == -ENOLINK) {
 962                 log_unit_full(UNIT(s), LOG_DEBUG, fd, "Potentially unsafe symlink chain, will now retry with relaxed checks: %s", s->pid_file);
 963
 964                 questionable_pid_file = true;
 965
 966                 fd = chase_symlinks(s->pid_file, NULL, CHASE_OPEN, NULL);
 967         }
 968         if (fd < 0)
 969                 return log_unit_full(UNIT(s), prio, fd, "Can't open PID file %s (yet?) after %s: %m", s->pid_file, service_state_to_string(s->state));
 970
 971         /* Let's read the PID file now that we chased it down. But we need to convert the O_PATH fd chase_symlinks() returned us into a proper fd first. */
 972         xsprintf(procfs, "/proc/self/fd/%i", fd);
 973         r = read_one_line_file(procfs, &k);
 974         if (r < 0)
 975                 return log_unit_error_errno(UNIT(s), r, "Can't convert PID files %s O_PATH file descriptor to proper file descriptor: %m", s->pid_file);
 976
 977         r = parse_pid(k, &pid);
 978         if (r < 0)
 979                 return log_unit_full(UNIT(s), prio, r, "Failed to parse PID from file %s: %m", s->pid_file);
 980
 981         if (s->main_pid_known && pid == s->main_pid)
 982                 return 0;
 983
 984         r = service_is_suitable_main_pid(s, pid, prio);
 985         if (r < 0)
 986                 return r;
 987         if (r == 0) {
 988                 struct stat st;
 989
 990                 if (questionable_pid_file) {
 991                         log_unit_error(UNIT(s), "Refusing to accept PID outside of service control group, acquired through unsafe symlink chain: %s", s->pid_file);
 992                         return -EPERM;
 993                 }
 994
 995                 /* Hmm, it's not clear if the new main PID is safe. Let's allow this if the PID file is owned by root */
 996
 997                 if (fstat(fd, &st) < 0)
 998                         return log_unit_error_errno(UNIT(s), errno, "Failed to fstat() PID file O_PATH fd: %m");
 999
1000                 if (st.st_uid != 0) {
1001                         log_unit_error(UNIT(s), "New main PID "PID_FMT" does not belong to service, and PID file is not owned by root. Refusing.", pid);
1002                         return -EPERM;
1003                 }
1004
1005                 log_unit_debug(UNIT(s), "New main PID "PID_FMT" does not belong to service, but we'll accept it since PID file is owned by root.", pid);
1006         }
1007
1008         if (s->main_pid_known) {
1009                 log_unit_debug(UNIT(s), "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
1010
1011                 service_unwatch_main_pid(s);
1012                 s->main_pid_known = false;
1013         } else
1014                 log_unit_debug(UNIT(s), "Main PID loaded: "PID_FMT, pid);
1015
1016         r = service_set_main_pid(s, pid);
1017         if (r < 0)
1018                 return r;
1019
1020         r = unit_watch_pid(UNIT(s), pid, false);
1021         if (r < 0) /* FIXME: we need to do something here */
1022                 return log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" for service: %m", pid);
1023
1024         return 1;
1025 }
1026
1027 static void service_search_main_pid(Service *s) {
1028         pid_t pid = 0;
1029         int r;
1030
1031         assert(s);
1032
1033         /* If we know it anyway, don't ever fallback to unreliable
1034          * heuristics */
1035         if (s->main_pid_known)
1036                 return;
1037
1038         if (!s->guess_main_pid)
1039                 return;
1040
1041         assert(s->main_pid <= 0);
1042
1043         if (unit_search_main_pid(UNIT(s), &pid) < 0)
1044                 return;
1045
1046         log_unit_debug(UNIT(s), "Main PID guessed: "PID_FMT, pid);
1047         if (service_set_main_pid(s, pid) < 0)
1048                 return;
1049
1050         r = unit_watch_pid(UNIT(s), pid, false);
1051         if (r < 0)
1052                 /* FIXME: we need to do something here */
1053                 log_unit_warning_errno(UNIT(s), r, "Failed to watch PID "PID_FMT" from: %m", pid);
1054 }
1055
1056 static void service_set_state(Service *s, ServiceState state) {
1057         ServiceState old_state;
1058         const UnitActiveState *table;
1059
1060         assert(s);
1061
1062         if (s->state != state)
1063                 bus_unit_send_pending_change_signal(UNIT(s), false);
1064
1065         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1066
1067         old_state = s->state;
1068         s->state = state;
1069
1070         service_unwatch_pid_file(s);
1071
1072         if (!IN_SET(state,
1073                     SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1074                     SERVICE_RUNNING,
1075                     SERVICE_RELOAD,
1076                     SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1077                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1078                     SERVICE_AUTO_RESTART,
1079                     SERVICE_CLEANING))
1080                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1081
1082         if (!IN_SET(state,
1083                     SERVICE_START, SERVICE_START_POST,
1084                     SERVICE_RUNNING, SERVICE_RELOAD,
1085                     SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1086                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1087                 service_unwatch_main_pid(s);
1088                 s->main_command = NULL;
1089         }
1090
1091         if (!IN_SET(state,
1092                     SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1093                     SERVICE_RELOAD,
1094                     SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1095                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1096                     SERVICE_CLEANING)) {
1097                 service_unwatch_control_pid(s);
1098                 s->control_command = NULL;
1099                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1100         }
1101
1102         if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
1103                 unit_unwatch_all_pids(UNIT(s));
1104                 unit_dequeue_rewatch_pids(UNIT(s));
1105         }
1106
1107         if (!IN_SET(state,
1108                     SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1109                     SERVICE_RUNNING, SERVICE_RELOAD,
1110                     SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1111                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1112             !(state == SERVICE_DEAD && UNIT(s)->job))
1113                 service_close_socket_fd(s);
1114
1115         if (state != SERVICE_START)
1116                 s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
1117
1118         if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1119                 service_stop_watchdog(s);
1120
1121         /* For the inactive states unit_notify() will trim the cgroup,
1122          * but for exit we have to do that ourselves... */
1123         if (state == SERVICE_EXITED && !MANAGER_IS_RELOADING(UNIT(s)->manager))
1124                 unit_prune_cgroup(UNIT(s));
1125
1126         if (old_state != state)
1127                 log_unit_debug(UNIT(s), "Changed %s -> %s", service_state_to_string(old_state), service_state_to_string(state));
1128
1129         unit_notify(UNIT(s), table[old_state], table[state],
1130                     (s->reload_result == SERVICE_SUCCESS ? 0 : UNIT_NOTIFY_RELOAD_FAILURE) |
1131                     (s->will_auto_restart ? UNIT_NOTIFY_WILL_AUTO_RESTART : 0) |
1132                     (s->result == SERVICE_SKIP_CONDITION ? UNIT_NOTIFY_SKIP_CONDITION : 0));
1133 }
1134
1135 static usec_t service_coldplug_timeout(Service *s) {
1136         assert(s);
1137
1138         switch (s->deserialized_state) {
1139
1140         case SERVICE_CONDITION:
1141         case SERVICE_START_PRE:
1142         case SERVICE_START:
1143         case SERVICE_START_POST:
1144         case SERVICE_RELOAD:
1145                 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_start_usec);
1146
1147         case SERVICE_RUNNING:
1148                 return usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec);
1149
1150         case SERVICE_STOP:
1151         case SERVICE_STOP_SIGTERM:
1152         case SERVICE_STOP_SIGKILL:
1153         case SERVICE_STOP_POST:
1154         case SERVICE_FINAL_SIGTERM:
1155         case SERVICE_FINAL_SIGKILL:
1156                 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->timeout_stop_usec);
1157
1158         case SERVICE_STOP_WATCHDOG:
1159                 return usec_add(UNIT(s)->state_change_timestamp.monotonic, service_timeout_abort_usec(s));
1160
1161         case SERVICE_AUTO_RESTART:
1162                 return usec_add(UNIT(s)->inactive_enter_timestamp.monotonic, s->restart_usec);
1163
1164         case SERVICE_CLEANING:
1165                 return usec_add(UNIT(s)->state_change_timestamp.monotonic, s->exec_context.timeout_clean_usec);
1166
1167         default:
1168                 return USEC_INFINITY;
1169         }
1170 }
1171
1172 static int service_coldplug(Unit *u) {
1173         Service *s = SERVICE(u);
1174         int r;
1175
1176         assert(s);
1177         assert(s->state == SERVICE_DEAD);
1178
1179         if (s->deserialized_state == s->state)
1180                 return 0;
1181
1182         r = service_arm_timer(s, service_coldplug_timeout(s));
1183         if (r < 0)
1184                 return r;
1185
1186         if (s->main_pid > 0 &&
1187             pid_is_unwaited(s->main_pid) &&
1188             (IN_SET(s->deserialized_state,
1189                     SERVICE_START, SERVICE_START_POST,
1190                     SERVICE_RUNNING, SERVICE_RELOAD,
1191                     SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1192                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1193                 r = unit_watch_pid(UNIT(s), s->main_pid, false);
1194                 if (r < 0)
1195                         return r;
1196         }
1197
1198         if (s->control_pid > 0 &&
1199             pid_is_unwaited(s->control_pid) &&
1200             IN_SET(s->deserialized_state,
1201                    SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1202                    SERVICE_RELOAD,
1203                    SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1204                    SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1205                    SERVICE_CLEANING)) {
1206                 r = unit_watch_pid(UNIT(s), s->control_pid, false);
1207                 if (r < 0)
1208                         return r;
1209         }
1210
1211         if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART, SERVICE_CLEANING)) {
1212                 (void) unit_enqueue_rewatch_pids(u);
1213                 (void) unit_setup_dynamic_creds(u);
1214                 (void) unit_setup_exec_runtime(u);
1215         }
1216
1217         if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1218                 service_start_watchdog(s);
1219
1220         if (UNIT_ISSET(s->accept_socket)) {
1221                 Socket* socket = SOCKET(UNIT_DEREF(s->accept_socket));
1222
1223                 if (socket->max_connections_per_source > 0) {
1224                         SocketPeer *peer;
1225
1226                         /* Make a best-effort attempt at bumping the connection count */
1227                         if (socket_acquire_peer(socket, s->socket_fd, &peer) > 0) {
1228                                 socket_peer_unref(s->peer);
1229                                 s->peer = peer;
1230                         }
1231                 }
1232         }
1233
1234         service_set_state(s, s->deserialized_state);
1235         return 0;
1236 }
1237
1238 static int service_collect_fds(
1239                 Service *s,
1240                 int **fds,
1241                 char ***fd_names,
1242                 size_t *n_socket_fds,
1243                 size_t *n_storage_fds) {
1244
1245         _cleanup_strv_free_ char **rfd_names = NULL;
1246         _cleanup_free_ int *rfds = NULL;
1247         size_t rn_socket_fds = 0, rn_storage_fds = 0;
1248         int r;
1249
1250         assert(s);
1251         assert(fds);
1252         assert(fd_names);
1253         assert(n_socket_fds);
1254         assert(n_storage_fds);
1255
1256         if (s->socket_fd >= 0) {
1257
1258                 /* Pass the per-connection socket */
1259
1260                 rfds = new(int, 1);
1261                 if (!rfds)
1262                         return -ENOMEM;
1263                 rfds[0] = s->socket_fd;
1264
1265                 rfd_names = strv_new("connection");
1266                 if (!rfd_names)
1267                         return -ENOMEM;
1268
1269                 rn_socket_fds = 1;
1270         } else {
1271                 Iterator i;
1272                 void *v;
1273                 Unit *u;
1274
1275                 /* Pass all our configured sockets for singleton services */
1276
1277                 HASHMAP_FOREACH_KEY(v, u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1278                         _cleanup_free_ int *cfds = NULL;
1279                         Socket *sock;
1280                         int cn_fds;
1281
1282                         if (u->type != UNIT_SOCKET)
1283                                 continue;
1284
1285                         sock = SOCKET(u);
1286
1287                         cn_fds = socket_collect_fds(sock, &cfds);
1288                         if (cn_fds < 0)
1289                                 return cn_fds;
1290
1291                         if (cn_fds <= 0)
1292                                 continue;
1293
1294                         if (!rfds) {
1295                                 rfds = TAKE_PTR(cfds);
1296                                 rn_socket_fds = cn_fds;
1297                         } else {
1298                                 int *t;
1299
1300                                 t = reallocarray(rfds, rn_socket_fds + cn_fds, sizeof(int));
1301                                 if (!t)
1302                                         return -ENOMEM;
1303
1304                                 memcpy(t + rn_socket_fds, cfds, cn_fds * sizeof(int));
1305
1306                                 rfds = t;
1307                                 rn_socket_fds += cn_fds;
1308                         }
1309
1310                         r = strv_extend_n(&rfd_names, socket_fdname(sock), cn_fds);
1311                         if (r < 0)
1312                                 return r;
1313                 }
1314         }
1315
1316         if (s->n_fd_store > 0) {
1317                 ServiceFDStore *fs;
1318                 size_t n_fds;
1319                 char **nl;
1320                 int *t;
1321
1322                 t = reallocarray(rfds, rn_socket_fds + s->n_fd_store, sizeof(int));
1323                 if (!t)
1324                         return -ENOMEM;
1325
1326                 rfds = t;
1327
1328                 nl = reallocarray(rfd_names, rn_socket_fds + s->n_fd_store + 1, sizeof(char *));
1329                 if (!nl)
1330                         return -ENOMEM;
1331
1332                 rfd_names = nl;
1333                 n_fds = rn_socket_fds;
1334
1335                 LIST_FOREACH(fd_store, fs, s->fd_store) {
1336                         rfds[n_fds] = fs->fd;
1337                         rfd_names[n_fds] = strdup(strempty(fs->fdname));
1338                         if (!rfd_names[n_fds])
1339                                 return -ENOMEM;
1340
1341                         rn_storage_fds++;
1342                         n_fds++;
1343                 }
1344
1345                 rfd_names[n_fds] = NULL;
1346         }
1347
1348         *fds = TAKE_PTR(rfds);
1349         *fd_names = TAKE_PTR(rfd_names);
1350         *n_socket_fds = rn_socket_fds;
1351         *n_storage_fds = rn_storage_fds;
1352
1353         return 0;
1354 }
1355
1356 static int service_allocate_exec_fd_event_source(
1357                 Service *s,
1358                 int fd,
1359                 sd_event_source **ret_event_source) {
1360
1361         _cleanup_(sd_event_source_unrefp) sd_event_source *source = NULL;
1362         int r;
1363
1364         assert(s);
1365         assert(fd >= 0);
1366         assert(ret_event_source);
1367
1368         r = sd_event_add_io(UNIT(s)->manager->event, &source, fd, 0, service_dispatch_exec_io, s);
1369         if (r < 0)
1370                 return log_unit_error_errno(UNIT(s), r, "Failed to allocate exec_fd event source: %m");
1371
1372         /* This is a bit lower priority than SIGCHLD, as that carries a lot more interesting failure information */
1373
1374         r = sd_event_source_set_priority(source, SD_EVENT_PRIORITY_NORMAL-3);
1375         if (r < 0)
1376                 return log_unit_error_errno(UNIT(s), r, "Failed to adjust priority of exec_fd event source: %m");
1377
1378         (void) sd_event_source_set_description(source, "service event_fd");
1379
1380         r = sd_event_source_set_io_fd_own(source, true);
1381         if (r < 0)
1382                 return log_unit_error_errno(UNIT(s), r, "Failed to pass ownership of fd to event source: %m");
1383
1384         *ret_event_source = TAKE_PTR(source);
1385         return 0;
1386 }
1387
1388 static int service_allocate_exec_fd(
1389                 Service *s,
1390                 sd_event_source **ret_event_source,
1391                 int* ret_exec_fd) {
1392
1393         _cleanup_close_pair_ int p[2] = { -1, -1 };
1394         int r;
1395
1396         assert(s);
1397         assert(ret_event_source);
1398         assert(ret_exec_fd);
1399
1400         if (pipe2(p, O_CLOEXEC|O_NONBLOCK) < 0)
1401                 return log_unit_error_errno(UNIT(s), errno, "Failed to allocate exec_fd pipe: %m");
1402
1403         r = service_allocate_exec_fd_event_source(s, p[0], ret_event_source);
1404         if (r < 0)
1405                 return r;
1406
1407         p[0] = -1;
1408         *ret_exec_fd = TAKE_FD(p[1]);
1409
1410         return 0;
1411 }
1412
1413 static bool service_exec_needs_notify_socket(Service *s, ExecFlags flags) {
1414         assert(s);
1415
1416         /* Notifications are accepted depending on the process and
1417          * the access setting of the service:
1418          *     process: \ access:  NONE  MAIN  EXEC   ALL
1419          *     main                  no   yes   yes   yes
1420          *     control               no    no   yes   yes
1421          *     other (forked)        no    no    no   yes */
1422
1423         if (flags & EXEC_IS_CONTROL)
1424                 /* A control process */
1425                 return IN_SET(s->notify_access, NOTIFY_EXEC, NOTIFY_ALL);
1426
1427         /* We only spawn main processes and control processes, so any
1428          * process that is not a control process is a main process */
1429         return s->notify_access != NOTIFY_NONE;
1430 }
1431
1432 static int service_spawn(
1433                 Service *s,
1434                 ExecCommand *c,
1435                 usec_t timeout,
1436                 ExecFlags flags,
1437                 pid_t *_pid) {
1438
1439         _cleanup_(exec_params_clear) ExecParameters exec_params = {
1440                 .flags      = flags,
1441                 .stdin_fd   = -1,
1442                 .stdout_fd  = -1,
1443                 .stderr_fd  = -1,
1444                 .exec_fd    = -1,
1445         };
1446         _cleanup_strv_free_ char **final_env = NULL, **our_env = NULL, **fd_names = NULL;
1447         _cleanup_(sd_event_source_unrefp) sd_event_source *exec_fd_source = NULL;
1448         size_t n_socket_fds = 0, n_storage_fds = 0, n_env = 0;
1449         _cleanup_close_ int exec_fd = -1;
1450         _cleanup_free_ int *fds = NULL;
1451         pid_t pid;
1452         int r;
1453
1454         assert(s);
1455         assert(c);
1456         assert(_pid);
1457
1458         r = unit_prepare_exec(UNIT(s)); /* This realizes the cgroup, among other things */
1459         if (r < 0)
1460                 return r;
1461
1462         if (flags & EXEC_IS_CONTROL) {
1463                 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1464                 if (s->permissions_start_only)
1465                         exec_params.flags &= ~EXEC_APPLY_SANDBOXING;
1466                 if (s->root_directory_start_only)
1467                         exec_params.flags &= ~EXEC_APPLY_CHROOT;
1468         }
1469
1470         if ((flags & EXEC_PASS_FDS) ||
1471             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1472             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1473             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1474
1475                 r = service_collect_fds(s, &fds, &fd_names, &n_socket_fds, &n_storage_fds);
1476                 if (r < 0)
1477                         return r;
1478
1479                 log_unit_debug(UNIT(s), "Passing %zu fds to service", n_socket_fds + n_storage_fds);
1480         }
1481
1482         if (!FLAGS_SET(flags, EXEC_IS_CONTROL) && s->type == SERVICE_EXEC) {
1483                 assert(!s->exec_fd_event_source);
1484
1485                 r = service_allocate_exec_fd(s, &exec_fd_source, &exec_fd);
1486                 if (r < 0)
1487                         return r;
1488         }
1489
1490         r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), timeout));
1491         if (r < 0)
1492                 return r;
1493
1494         our_env = new0(char*, 10);
1495         if (!our_env)
1496                 return -ENOMEM;
1497
1498         if (service_exec_needs_notify_socket(s, flags))
1499                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0)
1500                         return -ENOMEM;
1501
1502         if (s->main_pid > 0)
1503                 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0)
1504                         return -ENOMEM;
1505
1506         if (MANAGER_IS_USER(UNIT(s)->manager))
1507                 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid_cached()) < 0)
1508                         return -ENOMEM;
1509
1510         if (s->pid_file)
1511                 if (asprintf(our_env + n_env++, "PIDFILE=%s", s->pid_file) < 0)
1512                         return -ENOMEM;
1513
1514         if (s->socket_fd >= 0) {
1515                 union sockaddr_union sa;
1516                 socklen_t salen = sizeof(sa);
1517
1518                 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1519                  * useful. Note that we do this only when we are still connected at this point in time, which we might
1520                  * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1521                  * in ENOTCONN), and just use whate we can use. */
1522
1523                 if (getpeername(s->socket_fd, &sa.sa, &salen) >= 0 &&
1524                     IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
1525
1526                         _cleanup_free_ char *addr = NULL;
1527                         char *t;
1528                         unsigned port;
1529
1530                         r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1531                         if (r < 0)
1532                                 return r;
1533
1534                         t = strjoin("REMOTE_ADDR=", addr);
1535                         if (!t)
1536                                 return -ENOMEM;
1537                         our_env[n_env++] = t;
1538
1539                         r = sockaddr_port(&sa.sa, &port);
1540                         if (r < 0)
1541                                 return r;
1542
1543                         if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
1544                                 return -ENOMEM;
1545                         our_env[n_env++] = t;
1546                 }
1547         }
1548
1549         if (flags & EXEC_SETENV_RESULT) {
1550                 if (asprintf(our_env + n_env++, "SERVICE_RESULT=%s", service_result_to_string(s->result)) < 0)
1551                         return -ENOMEM;
1552
1553                 if (s->main_exec_status.pid > 0 &&
1554                     dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1555                         if (asprintf(our_env + n_env++, "EXIT_CODE=%s", sigchld_code_to_string(s->main_exec_status.code)) < 0)
1556                                 return -ENOMEM;
1557
1558                         if (s->main_exec_status.code == CLD_EXITED)
1559                                 r = asprintf(our_env + n_env++, "EXIT_STATUS=%i", s->main_exec_status.status);
1560                         else
1561                                 r = asprintf(our_env + n_env++, "EXIT_STATUS=%s", signal_to_string(s->main_exec_status.status));
1562                         if (r < 0)
1563                                 return -ENOMEM;
1564                 }
1565         }
1566
1567         r = unit_set_exec_params(UNIT(s), &exec_params);
1568         if (r < 0)
1569                 return r;
1570
1571         final_env = strv_env_merge(2, exec_params.environment, our_env, NULL);
1572         if (!final_env)
1573                 return -ENOMEM;
1574
1575         /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1576         SET_FLAG(exec_params.flags, EXEC_NSS_BYPASS_BUS,
1577                  MANAGER_IS_SYSTEM(UNIT(s)->manager) && unit_has_name(UNIT(s), SPECIAL_DBUS_SERVICE));
1578
1579         strv_free_and_replace(exec_params.environment, final_env);
1580         exec_params.fds = fds;
1581         exec_params.fd_names = fd_names;
1582         exec_params.n_socket_fds = n_socket_fds;
1583         exec_params.n_storage_fds = n_storage_fds;
1584         exec_params.watchdog_usec = service_get_watchdog_usec(s);
1585         exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
1586         if (s->type == SERVICE_IDLE)
1587                 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1588         exec_params.stdin_fd = s->stdin_fd;
1589         exec_params.stdout_fd = s->stdout_fd;
1590         exec_params.stderr_fd = s->stderr_fd;
1591         exec_params.exec_fd = exec_fd;
1592
1593         r = exec_spawn(UNIT(s),
1594                        c,
1595                        &s->exec_context,
1596                        &exec_params,
1597                        s->exec_runtime,
1598                        &s->dynamic_creds,
1599                        &pid);
1600         if (r < 0)
1601                 return r;
1602
1603         s->exec_fd_event_source = TAKE_PTR(exec_fd_source);
1604         s->exec_fd_hot = false;
1605
1606         r = unit_watch_pid(UNIT(s), pid, true);
1607         if (r < 0)
1608                 return r;
1609
1610         *_pid = pid;
1611
1612         return 0;
1613 }
1614
1615 static int main_pid_good(Service *s) {
1616         assert(s);
1617
1618         /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1619
1620         /* If we know the pid file, then let's just check if it is
1621          * still valid */
1622         if (s->main_pid_known) {
1623
1624                 /* If it's an alien child let's check if it is still
1625                  * alive ... */
1626                 if (s->main_pid_alien && s->main_pid > 0)
1627                         return pid_is_alive(s->main_pid);
1628
1629                 /* .. otherwise assume we'll get a SIGCHLD for it,
1630                  * which we really should wait for to collect exit
1631                  * status and code */
1632                 return s->main_pid > 0;
1633         }
1634
1635         /* We don't know the pid */
1636         return -EAGAIN;
1637 }
1638
1639 static int control_pid_good(Service *s) {
1640         assert(s);
1641
1642         /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1643          * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1644          * means: we can't figure it out. */
1645
1646         return s->control_pid > 0;
1647 }
1648
1649 static int cgroup_good(Service *s) {
1650         int r;
1651
1652         assert(s);
1653
1654         /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1655          * figure it out */
1656
1657         if (!UNIT(s)->cgroup_path)
1658                 return 0;
1659
1660         r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path);
1661         if (r < 0)
1662                 return r;
1663
1664         return r == 0;
1665 }
1666
1667 static bool service_shall_restart(Service *s) {
1668         assert(s);
1669
1670         /* Don't restart after manual stops */
1671         if (s->forbid_restart)
1672                 return false;
1673
1674         /* Never restart if this is configured as special exception */
1675         if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status))
1676                 return false;
1677
1678         /* Restart if the exit code/status are configured as restart triggers */
1679         if (exit_status_set_test(&s->restart_force_status,  s->main_exec_status.code, s->main_exec_status.status))
1680                 return true;
1681
1682         switch (s->restart) {
1683
1684         case SERVICE_RESTART_NO:
1685                 return false;
1686
1687         case SERVICE_RESTART_ALWAYS:
1688                 return true;
1689
1690         case SERVICE_RESTART_ON_SUCCESS:
1691                 return s->result == SERVICE_SUCCESS;
1692
1693         case SERVICE_RESTART_ON_FAILURE:
1694                 return s->result != SERVICE_SUCCESS;
1695
1696         case SERVICE_RESTART_ON_ABNORMAL:
1697                 return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE);
1698
1699         case SERVICE_RESTART_ON_WATCHDOG:
1700                 return s->result == SERVICE_FAILURE_WATCHDOG;
1701
1702         case SERVICE_RESTART_ON_ABORT:
1703                 return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
1704
1705         default:
1706                 assert_not_reached("unknown restart setting");
1707         }
1708 }
1709
1710 static bool service_will_restart(Unit *u) {
1711         Service *s = SERVICE(u);
1712
1713         assert(s);
1714
1715         if (s->will_auto_restart)
1716                 return true;
1717         if (s->state == SERVICE_AUTO_RESTART)
1718                 return true;
1719
1720         return unit_will_restart_default(u);
1721 }
1722
1723 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1724         ServiceState end_state;
1725         int r;
1726
1727         assert(s);
1728
1729         /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1730          * undo what has already been enqueued. */
1731         if (unit_stop_pending(UNIT(s)))
1732                 allow_restart = false;
1733
1734         if (s->result == SERVICE_SUCCESS)
1735                 s->result = f;
1736
1737         if (s->result == SERVICE_SUCCESS) {
1738                 unit_log_success(UNIT(s));
1739                 end_state = SERVICE_DEAD;
1740         } else if (s->result == SERVICE_SKIP_CONDITION) {
1741                 unit_log_skip(UNIT(s), service_result_to_string(s->result));
1742                 end_state = SERVICE_DEAD;
1743         } else {
1744                 unit_log_failure(UNIT(s), service_result_to_string(s->result));
1745                 end_state = SERVICE_FAILED;
1746         }
1747
1748         if (allow_restart && service_shall_restart(s))
1749                 s->will_auto_restart = true;
1750
1751         /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1752          * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1753         s->n_keep_fd_store ++;
1754
1755         service_set_state(s, end_state);
1756
1757         if (s->will_auto_restart) {
1758                 s->will_auto_restart = false;
1759
1760                 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
1761                 if (r < 0) {
1762                         s->n_keep_fd_store--;
1763                         goto fail;
1764                 }
1765
1766                 service_set_state(s, SERVICE_AUTO_RESTART);
1767         } else
1768                 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1769                  * user can still introspect the counter. Do so on the next start. */
1770                 s->flush_n_restarts = true;
1771
1772         /* The new state is in effect, let's decrease the fd store ref counter again. Let's also re-add us to the GC
1773          * queue, so that the fd store is possibly gc'ed again */
1774         s->n_keep_fd_store--;
1775         unit_add_to_gc_queue(UNIT(s));
1776
1777         /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1778         s->forbid_restart = false;
1779
1780         /* We want fresh tmpdirs in case service is started again immediately */
1781         s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
1782
1783         /* Also, remove the runtime directory */
1784         unit_destroy_runtime_directory(UNIT(s), &s->exec_context);
1785
1786         /* Get rid of the IPC bits of the user */
1787         unit_unref_uid_gid(UNIT(s), true);
1788
1789         /* Release the user, and destroy it if we are the only remaining owner */
1790         dynamic_creds_destroy(&s->dynamic_creds);
1791
1792         /* Try to delete the pid file. At this point it will be
1793          * out-of-date, and some software might be confused by it, so
1794          * let's remove it. */
1795         if (s->pid_file)
1796                 (void) unlink(s->pid_file);
1797
1798         /* Reset TTY ownership if necessary */
1799         exec_context_revert_tty(&s->exec_context);
1800
1801         return;
1802
1803 fail:
1804         log_unit_warning_errno(UNIT(s), r, "Failed to run install restart timer: %m");
1805         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1806 }
1807
1808 static void service_enter_stop_post(Service *s, ServiceResult f) {
1809         int r;
1810         assert(s);
1811
1812         if (s->result == SERVICE_SUCCESS)
1813                 s->result = f;
1814
1815         service_unwatch_control_pid(s);
1816         (void) unit_enqueue_rewatch_pids(UNIT(s));
1817
1818         s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1819         if (s->control_command) {
1820                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1821
1822                 r = service_spawn(s,
1823                                   s->control_command,
1824                                   s->timeout_stop_usec,
1825                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_IS_CONTROL|EXEC_SETENV_RESULT|EXEC_CONTROL_CGROUP,
1826                                   &s->control_pid);
1827                 if (r < 0)
1828                         goto fail;
1829
1830                 service_set_state(s, SERVICE_STOP_POST);
1831         } else
1832                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1833
1834         return;
1835
1836 fail:
1837         log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
1838         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1839 }
1840
1841 static int state_to_kill_operation(ServiceState state) {
1842         switch (state) {
1843
1844         case SERVICE_STOP_WATCHDOG:
1845                 return KILL_WATCHDOG;
1846
1847         case SERVICE_STOP_SIGTERM:
1848         case SERVICE_FINAL_SIGTERM:
1849                 return KILL_TERMINATE;
1850
1851         case SERVICE_STOP_SIGKILL:
1852         case SERVICE_FINAL_SIGKILL:
1853                 return KILL_KILL;
1854
1855         default:
1856                 return _KILL_OPERATION_INVALID;
1857         }
1858 }
1859
1860 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1861         int r;
1862
1863         assert(s);
1864
1865         if (s->result == SERVICE_SUCCESS)
1866                 s->result = f;
1867
1868         /* Before sending any signal, make sure we track all members of this cgroup */
1869         (void) unit_watch_all_pids(UNIT(s));
1870
1871         /* Also, enqueue a job that we recheck all our PIDs a bit later, given that it's likely some processes have
1872          * died now */
1873         (void) unit_enqueue_rewatch_pids(UNIT(s));
1874
1875         r = unit_kill_context(
1876                         UNIT(s),
1877                         &s->kill_context,
1878                         state_to_kill_operation(state),
1879                         s->main_pid,
1880                         s->control_pid,
1881                         s->main_pid_alien);
1882         if (r < 0)
1883                 goto fail;
1884
1885         if (r > 0) {
1886                 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC),
1887                                       state == SERVICE_STOP_WATCHDOG ? service_timeout_abort_usec(s) : s->timeout_stop_usec));
1888                 if (r < 0)
1889                         goto fail;
1890
1891                 service_set_state(s, state);
1892         } else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
1893                 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1894         else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1895                 service_enter_stop_post(s, SERVICE_SUCCESS);
1896         else if (state == SERVICE_FINAL_SIGTERM && s->kill_context.send_sigkill)
1897                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1898         else
1899                 service_enter_dead(s, SERVICE_SUCCESS, true);
1900
1901         return;
1902
1903 fail:
1904         log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
1905
1906         if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
1907                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1908         else
1909                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1910 }
1911
1912 static void service_enter_stop_by_notify(Service *s) {
1913         assert(s);
1914
1915         (void) unit_enqueue_rewatch_pids(UNIT(s));
1916
1917         service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_stop_usec));
1918
1919         /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1920         service_set_state(s, SERVICE_STOP_SIGTERM);
1921 }
1922
1923 static void service_enter_stop(Service *s, ServiceResult f) {
1924         int r;
1925
1926         assert(s);
1927
1928         if (s->result == SERVICE_SUCCESS)
1929                 s->result = f;
1930
1931         service_unwatch_control_pid(s);
1932         (void) unit_enqueue_rewatch_pids(UNIT(s));
1933
1934         s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1935         if (s->control_command) {
1936                 s->control_command_id = SERVICE_EXEC_STOP;
1937
1938                 r = service_spawn(s,
1939                                   s->control_command,
1940                                   s->timeout_stop_usec,
1941                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_SETENV_RESULT|EXEC_CONTROL_CGROUP,
1942                                   &s->control_pid);
1943                 if (r < 0)
1944                         goto fail;
1945
1946                 service_set_state(s, SERVICE_STOP);
1947         } else
1948                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1949
1950         return;
1951
1952 fail:
1953         log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop' task: %m");
1954         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1955 }
1956
1957 static bool service_good(Service *s) {
1958         int main_pid_ok;
1959         assert(s);
1960
1961         if (s->type == SERVICE_DBUS && !s->bus_name_good)
1962                 return false;
1963
1964         main_pid_ok = main_pid_good(s);
1965         if (main_pid_ok > 0) /* It's alive */
1966                 return true;
1967         if (main_pid_ok == 0) /* It's dead */
1968                 return false;
1969
1970         /* OK, we don't know anything about the main PID, maybe
1971          * because there is none. Let's check the control group
1972          * instead. */
1973
1974         return cgroup_good(s) != 0;
1975 }
1976
1977 static void service_enter_running(Service *s, ServiceResult f) {
1978         assert(s);
1979
1980         if (s->result == SERVICE_SUCCESS)
1981                 s->result = f;
1982
1983         service_unwatch_control_pid(s);
1984
1985         if (s->result != SERVICE_SUCCESS)
1986                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
1987         else if (service_good(s)) {
1988
1989                 /* If there are any queued up sd_notify() notifications, process them now */
1990                 if (s->notify_state == NOTIFY_RELOADING)
1991                         service_enter_reload_by_notify(s);
1992                 else if (s->notify_state == NOTIFY_STOPPING)
1993                         service_enter_stop_by_notify(s);
1994                 else {
1995                         service_set_state(s, SERVICE_RUNNING);
1996                         service_arm_timer(s, usec_add(UNIT(s)->active_enter_timestamp.monotonic, s->runtime_max_usec));
1997                 }
1998
1999         } else if (s->remain_after_exit)
2000                 service_set_state(s, SERVICE_EXITED);
2001         else
2002                 service_enter_stop(s, SERVICE_SUCCESS);
2003 }
2004
2005 static void service_enter_start_post(Service *s) {
2006         int r;
2007         assert(s);
2008
2009         service_unwatch_control_pid(s);
2010         service_reset_watchdog(s);
2011
2012         s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2013         if (s->control_command) {
2014                 s->control_command_id = SERVICE_EXEC_START_POST;
2015
2016                 r = service_spawn(s,
2017                                   s->control_command,
2018                                   s->timeout_start_usec,
2019                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_CONTROL_CGROUP,
2020                                   &s->control_pid);
2021                 if (r < 0)
2022                         goto fail;
2023
2024                 service_set_state(s, SERVICE_START_POST);
2025         } else
2026                 service_enter_running(s, SERVICE_SUCCESS);
2027
2028         return;
2029
2030 fail:
2031         log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
2032         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2033 }
2034
2035 static void service_kill_control_process(Service *s) {
2036         int r;
2037
2038         assert(s);
2039
2040         if (s->control_pid <= 0)
2041                 return;
2042
2043         r = kill_and_sigcont(s->control_pid, SIGKILL);
2044         if (r < 0) {
2045                 _cleanup_free_ char *comm = NULL;
2046
2047                 (void) get_process_comm(s->control_pid, &comm);
2048
2049                 log_unit_debug_errno(UNIT(s), r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m",
2050                                      s->control_pid, strna(comm));
2051         }
2052 }
2053
2054 static int service_adverse_to_leftover_processes(Service *s) {
2055         assert(s);
2056
2057         /* KillMode=mixed and control group are used to indicate that all process should be killed off.
2058          * SendSIGKILL is used for services that require a clean shutdown. These are typically database
2059          * service where a SigKilled process would result in a lengthy recovery and who's shutdown or
2060          * startup time is quite variable (so Timeout settings aren't of use).
2061          *
2062          * Here we take these two factors and refuse to start a service if there are existing processes
2063          * within a control group. Databases, while generally having some protection against multiple
2064          * instances running, lets not stress the rigor of these. Also ExecStartPre parts of the service
2065          * aren't as rigoriously written to protect aganst against multiple use. */
2066         if (unit_warn_leftover_processes(UNIT(s)) &&
2067             IN_SET(s->kill_context.kill_mode, KILL_MIXED, KILL_CONTROL_GROUP) &&
2068             !s->kill_context.send_sigkill)
2069                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(EBUSY),
2070                                            "Will not start SendSIGKILL=no service of type KillMode=control-group or mixed while processes exist");
2071
2072         return 0;
2073 }
2074
2075 static void service_enter_start(Service *s) {
2076         ExecCommand *c;
2077         usec_t timeout;
2078         pid_t pid;
2079         int r;
2080
2081         assert(s);
2082
2083         service_unwatch_control_pid(s);
2084         service_unwatch_main_pid(s);
2085
2086         r = service_adverse_to_leftover_processes(s);
2087         if (r < 0)
2088                 goto fail;
2089
2090         if (s->type == SERVICE_FORKING) {
2091                 s->control_command_id = SERVICE_EXEC_START;
2092                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2093
2094                 s->main_command = NULL;
2095         } else {
2096                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2097                 s->control_command = NULL;
2098
2099                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2100         }
2101
2102         if (!c) {
2103                 if (s->type != SERVICE_ONESHOT) {
2104                         /* There's no command line configured for the main command? Hmm, that is strange. This can only
2105                          * happen if the configuration changes at runtime. In this case, let's enter a failure
2106                          * state. */
2107                         log_unit_error(UNIT(s), "There's no 'start' task anymore we could start.");
2108                         r = -ENXIO;
2109                         goto fail;
2110                 }
2111
2112                 /* We force a fake state transition here. Otherwise, the unit would go directly from
2113                  * SERVICE_DEAD to SERVICE_DEAD without SERVICE_ACTIVATING or SERVICE_ACTIVE
2114                  * in between. This way we can later trigger actions that depend on the state
2115                  * transition, including SuccessAction=. */
2116                 service_set_state(s, SERVICE_START);
2117
2118                 service_enter_start_post(s);
2119                 return;
2120         }
2121
2122         if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
2123                 /* For simple + idle this is the main process. We don't apply any timeout here, but
2124                  * service_enter_running() will later apply the .runtime_max_usec timeout. */
2125                 timeout = USEC_INFINITY;
2126         else
2127                 timeout = s->timeout_start_usec;
2128
2129         r = service_spawn(s,
2130                           c,
2131                           timeout,
2132                           EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2133                           &pid);
2134         if (r < 0)
2135                 goto fail;
2136
2137         if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE)) {
2138                 /* For simple services we immediately start
2139                  * the START_POST binaries. */
2140
2141                 service_set_main_pid(s, pid);
2142                 service_enter_start_post(s);
2143
2144         } else  if (s->type == SERVICE_FORKING) {
2145
2146                 /* For forking services we wait until the start
2147                  * process exited. */
2148
2149                 s->control_pid = pid;
2150                 service_set_state(s, SERVICE_START);
2151
2152         } else if (IN_SET(s->type, SERVICE_ONESHOT, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_EXEC)) {
2153
2154                 /* For oneshot services we wait until the start process exited, too, but it is our main process. */
2155
2156                 /* For D-Bus services we know the main pid right away, but wait for the bus name to appear on the
2157                  * bus. 'notify' and 'exec' services are similar. */
2158
2159                 service_set_main_pid(s, pid);
2160                 service_set_state(s, SERVICE_START);
2161         } else
2162                 assert_not_reached("Unknown service type");
2163
2164         return;
2165
2166 fail:
2167         log_unit_warning_errno(UNIT(s), r, "Failed to run 'start' task: %m");
2168         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2169 }
2170
2171 static void service_enter_start_pre(Service *s) {
2172         int r;
2173
2174         assert(s);
2175
2176         service_unwatch_control_pid(s);
2177
2178         s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2179         if (s->control_command) {
2180
2181                 r = service_adverse_to_leftover_processes(s);
2182                 if (r < 0)
2183                         goto fail;
2184
2185                 s->control_command_id = SERVICE_EXEC_START_PRE;
2186
2187                 r = service_spawn(s,
2188                                   s->control_command,
2189                                   s->timeout_start_usec,
2190                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_APPLY_TTY_STDIN,
2191                                   &s->control_pid);
2192                 if (r < 0)
2193                         goto fail;
2194
2195                 service_set_state(s, SERVICE_START_PRE);
2196         } else
2197                 service_enter_start(s);
2198
2199         return;
2200
2201 fail:
2202         log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2203         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2204 }
2205
2206 static void service_enter_condition(Service *s) {
2207         int r;
2208
2209         assert(s);
2210
2211         service_unwatch_control_pid(s);
2212
2213         s->control_command = s->exec_command[SERVICE_EXEC_CONDITION];
2214         if (s->control_command) {
2215
2216                 r = service_adverse_to_leftover_processes(s);
2217                 if (r < 0)
2218                         goto fail;
2219
2220                 s->control_command_id = SERVICE_EXEC_CONDITION;
2221
2222                 r = service_spawn(s,
2223                                   s->control_command,
2224                                   s->timeout_start_usec,
2225                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_APPLY_TTY_STDIN,
2226                                   &s->control_pid);
2227
2228                 if (r < 0)
2229                         goto fail;
2230
2231                 service_set_state(s, SERVICE_CONDITION);
2232         } else
2233                 service_enter_start_pre(s);
2234
2235         return;
2236
2237 fail:
2238         log_unit_warning_errno(UNIT(s), r, "Failed to run 'exec-condition' task: %m");
2239         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2240 }
2241
2242 static void service_enter_restart(Service *s) {
2243         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2244         int r;
2245
2246         assert(s);
2247
2248         if (unit_has_job_type(UNIT(s), JOB_STOP)) {
2249                 /* Don't restart things if we are going down anyway */
2250                 log_unit_info(UNIT(s), "Stop job pending for unit, delaying automatic restart.");
2251
2252                 r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->restart_usec));
2253                 if (r < 0)
2254                         goto fail;
2255
2256                 return;
2257         }
2258
2259         /* Any units that are bound to this service must also be
2260          * restarted. We use JOB_RESTART (instead of the more obvious
2261          * JOB_START) here so that those dependency jobs will be added
2262          * as well. */
2263         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_REPLACE, NULL, &error, NULL);
2264         if (r < 0)
2265                 goto fail;
2266
2267         /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2268          * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2269          * explicitly however via the usual "systemctl reset-failure" logic. */
2270         s->n_restarts ++;
2271         s->flush_n_restarts = false;
2272
2273         log_struct(LOG_INFO,
2274                    "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR,
2275                    LOG_UNIT_ID(UNIT(s)),
2276                    LOG_UNIT_INVOCATION_ID(UNIT(s)),
2277                    LOG_UNIT_MESSAGE(UNIT(s), "Scheduled restart job, restart counter is at %u.", s->n_restarts),
2278                    "N_RESTARTS=%u", s->n_restarts);
2279
2280         /* Notify clients about changed restart counter */
2281         unit_add_to_dbus_queue(UNIT(s));
2282
2283         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2284          * it will be canceled as part of the service_stop() call that
2285          * is executed as part of JOB_RESTART. */
2286
2287         return;
2288
2289 fail:
2290         log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, -r));
2291         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2292 }
2293
2294 static void service_enter_reload_by_notify(Service *s) {
2295         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2296         int r;
2297
2298         assert(s);
2299
2300         service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_start_usec));
2301         service_set_state(s, SERVICE_RELOAD);
2302
2303         /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2304         r = manager_propagate_reload(UNIT(s)->manager, UNIT(s), JOB_FAIL, &error);
2305         if (r < 0)
2306                 log_unit_warning(UNIT(s), "Failed to schedule propagation of reload: %s", bus_error_message(&error, -r));
2307 }
2308
2309 static void service_enter_reload(Service *s) {
2310         int r;
2311
2312         assert(s);
2313
2314         service_unwatch_control_pid(s);
2315         s->reload_result = SERVICE_SUCCESS;
2316
2317         s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2318         if (s->control_command) {
2319                 s->control_command_id = SERVICE_EXEC_RELOAD;
2320
2321                 r = service_spawn(s,
2322                                   s->control_command,
2323                                   s->timeout_start_usec,
2324                                   EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|EXEC_CONTROL_CGROUP,
2325                                   &s->control_pid);
2326                 if (r < 0)
2327                         goto fail;
2328
2329                 service_set_state(s, SERVICE_RELOAD);
2330         } else
2331                 service_enter_running(s, SERVICE_SUCCESS);
2332
2333         return;
2334
2335 fail:
2336         log_unit_warning_errno(UNIT(s), r, "Failed to run 'reload' task: %m");
2337         s->reload_result = SERVICE_FAILURE_RESOURCES;
2338         service_enter_running(s, SERVICE_SUCCESS);
2339 }
2340
2341 static void service_run_next_control(Service *s) {
2342         usec_t timeout;
2343         int r;
2344
2345         assert(s);
2346         assert(s->control_command);
2347         assert(s->control_command->command_next);
2348
2349         assert(s->control_command_id != SERVICE_EXEC_START);
2350
2351         s->control_command = s->control_command->command_next;
2352         service_unwatch_control_pid(s);
2353
2354         if (IN_SET(s->state, SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
2355                 timeout = s->timeout_start_usec;
2356         else
2357                 timeout = s->timeout_stop_usec;
2358
2359         r = service_spawn(s,
2360                           s->control_command,
2361                           timeout,
2362                           EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_IS_CONTROL|
2363                           (IN_SET(s->control_command_id, SERVICE_EXEC_CONDITION, SERVICE_EXEC_START_PRE, SERVICE_EXEC_STOP_POST) ? EXEC_APPLY_TTY_STDIN : 0)|
2364                           (IN_SET(s->control_command_id, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST) ? EXEC_SETENV_RESULT : 0)|
2365                           (IN_SET(s->control_command_id, SERVICE_EXEC_START_POST, SERVICE_EXEC_RELOAD, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST) ? EXEC_CONTROL_CGROUP : 0),
2366                           &s->control_pid);
2367         if (r < 0)
2368                 goto fail;
2369
2370         return;
2371
2372 fail:
2373         log_unit_warning_errno(UNIT(s), r, "Failed to run next control task: %m");
2374
2375         if (IN_SET(s->state, SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START_POST, SERVICE_STOP))
2376                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2377         else if (s->state == SERVICE_STOP_POST)
2378                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2379         else if (s->state == SERVICE_RELOAD) {
2380                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2381                 service_enter_running(s, SERVICE_SUCCESS);
2382         } else
2383                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2384 }
2385
2386 static void service_run_next_main(Service *s) {
2387         pid_t pid;
2388         int r;
2389
2390         assert(s);
2391         assert(s->main_command);
2392         assert(s->main_command->command_next);
2393         assert(s->type == SERVICE_ONESHOT);
2394
2395         s->main_command = s->main_command->command_next;
2396         service_unwatch_main_pid(s);
2397
2398         r = service_spawn(s,
2399                           s->main_command,
2400                           s->timeout_start_usec,
2401                           EXEC_PASS_FDS|EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN|EXEC_SET_WATCHDOG,
2402                           &pid);
2403         if (r < 0)
2404                 goto fail;
2405
2406         service_set_main_pid(s, pid);
2407
2408         return;
2409
2410 fail:
2411         log_unit_warning_errno(UNIT(s), r, "Failed to run next main task: %m");
2412         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2413 }
2414
2415 static int service_start(Unit *u) {
2416         Service *s = SERVICE(u);
2417         int r;
2418
2419         assert(s);
2420
2421         /* We cannot fulfill this request right now, try again later
2422          * please! */
2423         if (IN_SET(s->state,
2424                    SERVICE_STOP, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2425                    SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL, SERVICE_CLEANING))
2426                 return -EAGAIN;
2427
2428         /* Already on it! */
2429         if (IN_SET(s->state, SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST))
2430                 return 0;
2431
2432         /* A service that will be restarted must be stopped first to
2433          * trigger BindsTo and/or OnFailure dependencies. If a user
2434          * does not want to wait for the holdoff time to elapse, the
2435          * service should be manually restarted, not started. We
2436          * simply return EAGAIN here, so that any start jobs stay
2437          * queued, and assume that the auto restart timer will
2438          * eventually trigger the restart. */
2439         if (s->state == SERVICE_AUTO_RESTART)
2440                 return -EAGAIN;
2441
2442         assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED));
2443
2444         /* Make sure we don't enter a busy loop of some kind. */
2445         r = unit_test_start_limit(u);
2446         if (r < 0) {
2447                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT_HIT, false);
2448                 return r;
2449         }
2450
2451         r = unit_acquire_invocation_id(u);
2452         if (r < 0)
2453                 return r;
2454
2455         s->result = SERVICE_SUCCESS;
2456         s->reload_result = SERVICE_SUCCESS;
2457         s->main_pid_known = false;
2458         s->main_pid_alien = false;
2459         s->forbid_restart = false;
2460
2461         s->status_text = mfree(s->status_text);
2462         s->status_errno = 0;
2463
2464         s->notify_state = NOTIFY_UNKNOWN;
2465
2466         s->watchdog_original_usec = s->watchdog_usec;
2467         s->watchdog_override_enable = false;
2468         s->watchdog_override_usec = USEC_INFINITY;
2469
2470         exec_command_reset_status_list_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
2471         exec_status_reset(&s->main_exec_status);
2472
2473         /* This is not an automatic restart? Flush the restart counter then */
2474         if (s->flush_n_restarts) {
2475                 s->n_restarts = 0;
2476                 s->flush_n_restarts = false;
2477         }
2478
2479         u->reset_accounting = true;
2480
2481         service_enter_condition(s);
2482         return 1;
2483 }
2484
2485 static int service_stop(Unit *u) {
2486         Service *s = SERVICE(u);
2487
2488         assert(s);
2489
2490         /* Don't create restart jobs from manual stops. */
2491         s->forbid_restart = true;
2492
2493         /* Already on it */
2494         if (IN_SET(s->state,
2495                    SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
2496                    SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))
2497                 return 0;
2498
2499         /* A restart will be scheduled or is in progress. */
2500         if (s->state == SERVICE_AUTO_RESTART) {
2501                 service_set_state(s, SERVICE_DEAD);
2502                 return 0;
2503         }
2504
2505         /* If there's already something running we go directly into
2506          * kill mode. */
2507         if (IN_SET(s->state, SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD, SERVICE_STOP_WATCHDOG)) {
2508                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2509                 return 0;
2510         }
2511
2512         /* If we are currently cleaning, then abort it, brutally. */
2513         if (s->state == SERVICE_CLEANING) {
2514                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
2515                 return 0;
2516         }
2517
2518         assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2519
2520         service_enter_stop(s, SERVICE_SUCCESS);
2521         return 1;
2522 }
2523
2524 static int service_reload(Unit *u) {
2525         Service *s = SERVICE(u);
2526
2527         assert(s);
2528
2529         assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_EXITED));
2530
2531         service_enter_reload(s);
2532         return 1;
2533 }
2534
2535 _pure_ static bool service_can_reload(Unit *u) {
2536         Service *s = SERVICE(u);
2537
2538         assert(s);
2539
2540         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2541 }
2542
2543 static unsigned service_exec_command_index(Unit *u, ServiceExecCommand id, ExecCommand *current) {
2544         Service *s = SERVICE(u);
2545         unsigned idx = 0;
2546         ExecCommand *first, *c;
2547
2548         assert(s);
2549
2550         first = s->exec_command[id];
2551
2552         /* Figure out where we are in the list by walking back to the beginning */
2553         for (c = current; c != first; c = c->command_prev)
2554                 idx++;
2555
2556         return idx;
2557 }
2558
2559 static int service_serialize_exec_command(Unit *u, FILE *f, ExecCommand *command) {
2560         _cleanup_free_ char *args = NULL, *p = NULL;
2561         size_t allocated = 0, length = 0;
2562         Service *s = SERVICE(u);
2563         const char *type, *key;
2564         ServiceExecCommand id;
2565         unsigned idx;
2566         char **arg;
2567
2568         assert(s);
2569         assert(f);
2570
2571         if (!command)
2572                 return 0;
2573
2574         if (command == s->control_command) {
2575                 type = "control";
2576                 id = s->control_command_id;
2577         } else {
2578                 type = "main";
2579                 id = SERVICE_EXEC_START;
2580         }
2581
2582         idx = service_exec_command_index(u, id, command);
2583
2584         STRV_FOREACH(arg, command->argv) {
2585                 _cleanup_free_ char *e = NULL;
2586                 size_t n;
2587
2588                 e = cescape(*arg);
2589                 if (!e)
2590                         return log_oom();
2591
2592                 n = strlen(e);
2593                 if (!GREEDY_REALLOC(args, allocated, length + 2 + n + 2))
2594                         return log_oom();
2595
2596                 if (length > 0)
2597                         args[length++] = ' ';
2598
2599                 args[length++] = '"';
2600                 memcpy(args + length, e, n);
2601                 length += n;
2602                 args[length++] = '"';
2603         }
2604
2605         if (!GREEDY_REALLOC(args, allocated, length + 1))
2606                 return log_oom();
2607
2608         args[length++] = 0;
2609
2610         p = cescape(command->path);
2611         if (!p)
2612                 return -ENOMEM;
2613
2614         key = strjoina(type, "-command");
2615         return serialize_item_format(f, key, "%s %u %s %s", service_exec_command_to_string(id), idx, p, args);
2616 }
2617
2618 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2619         Service *s = SERVICE(u);
2620         ServiceFDStore *fs;
2621         int r;
2622
2623         assert(u);
2624         assert(f);
2625         assert(fds);
2626
2627         (void) serialize_item(f, "state", service_state_to_string(s->state));
2628         (void) serialize_item(f, "result", service_result_to_string(s->result));
2629         (void) serialize_item(f, "reload-result", service_result_to_string(s->reload_result));
2630
2631         if (s->control_pid > 0)
2632                 (void) serialize_item_format(f, "control-pid", PID_FMT, s->control_pid);
2633
2634         if (s->main_pid_known && s->main_pid > 0)
2635                 (void) serialize_item_format(f, "main-pid", PID_FMT, s->main_pid);
2636
2637         (void) serialize_bool(f, "main-pid-known", s->main_pid_known);
2638         (void) serialize_bool(f, "bus-name-good", s->bus_name_good);
2639         (void) serialize_bool(f, "bus-name-owner", s->bus_name_owner);
2640
2641         (void) serialize_item_format(f, "n-restarts", "%u", s->n_restarts);
2642         (void) serialize_bool(f, "flush-n-restarts", s->flush_n_restarts);
2643
2644         r = serialize_item_escaped(f, "status-text", s->status_text);
2645         if (r < 0)
2646                 return r;
2647
2648         service_serialize_exec_command(u, f, s->control_command);
2649         service_serialize_exec_command(u, f, s->main_command);
2650
2651         r = serialize_fd(f, fds, "stdin-fd", s->stdin_fd);
2652         if (r < 0)
2653                 return r;
2654         r = serialize_fd(f, fds, "stdout-fd", s->stdout_fd);
2655         if (r < 0)
2656                 return r;
2657         r = serialize_fd(f, fds, "stderr-fd", s->stderr_fd);
2658         if (r < 0)
2659                 return r;
2660
2661         if (s->exec_fd_event_source) {
2662                 r = serialize_fd(f, fds, "exec-fd", sd_event_source_get_io_fd(s->exec_fd_event_source));
2663                 if (r < 0)
2664                         return r;
2665
2666                 (void) serialize_bool(f, "exec-fd-hot", s->exec_fd_hot);
2667         }
2668
2669         if (UNIT_ISSET(s->accept_socket)) {
2670                 r = serialize_item(f, "accept-socket", UNIT_DEREF(s->accept_socket)->id);
2671                 if (r < 0)
2672                         return r;
2673         }
2674
2675         r = serialize_fd(f, fds, "socket-fd", s->socket_fd);
2676         if (r < 0)
2677                 return r;
2678
2679         LIST_FOREACH(fd_store, fs, s->fd_store) {
2680                 _cleanup_free_ char *c = NULL;
2681                 int copy;
2682
2683                 copy = fdset_put_dup(fds, fs->fd);
2684                 if (copy < 0)
2685                         return log_error_errno(copy, "Failed to copy file descriptor for serialization: %m");
2686
2687                 c = cescape(fs->fdname);
2688                 if (!c)
2689                         return log_oom();
2690
2691                 (void) serialize_item_format(f, "fd-store-fd", "%i %s", copy, c);
2692         }
2693
2694         if (s->main_exec_status.pid > 0) {
2695                 (void) serialize_item_format(f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
2696                 (void) serialize_dual_timestamp(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2697                 (void) serialize_dual_timestamp(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2698
2699                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2700                         (void) serialize_item_format(f, "main-exec-status-code", "%i", s->main_exec_status.code);
2701                         (void) serialize_item_format(f, "main-exec-status-status", "%i", s->main_exec_status.status);
2702                 }
2703         }
2704
2705         (void) serialize_dual_timestamp(f, "watchdog-timestamp", &s->watchdog_timestamp);
2706         (void) serialize_bool(f, "forbid-restart", s->forbid_restart);
2707
2708         if (s->watchdog_override_enable)
2709                 (void) serialize_item_format(f, "watchdog-override-usec", USEC_FMT, s->watchdog_override_usec);
2710
2711         if (s->watchdog_original_usec != USEC_INFINITY)
2712                 (void) serialize_item_format(f, "watchdog-original-usec", USEC_FMT, s->watchdog_original_usec);
2713
2714         return 0;
2715 }
2716
2717 static int service_deserialize_exec_command(Unit *u, const char *key, const char *value) {
2718         Service *s = SERVICE(u);
2719         int r;
2720         unsigned idx = 0, i;
2721         bool control, found = false;
2722         ServiceExecCommand id = _SERVICE_EXEC_COMMAND_INVALID;
2723         ExecCommand *command = NULL;
2724         _cleanup_free_ char *path = NULL;
2725         _cleanup_strv_free_ char **argv = NULL;
2726
2727         enum ExecCommandState {
2728                 STATE_EXEC_COMMAND_TYPE,
2729                 STATE_EXEC_COMMAND_INDEX,
2730                 STATE_EXEC_COMMAND_PATH,
2731                 STATE_EXEC_COMMAND_ARGS,
2732                 _STATE_EXEC_COMMAND_MAX,
2733                 _STATE_EXEC_COMMAND_INVALID = -1,
2734         } state;
2735
2736         assert(s);
2737         assert(key);
2738         assert(value);
2739
2740         control = streq(key, "control-command");
2741
2742         state = STATE_EXEC_COMMAND_TYPE;
2743
2744         for (;;) {
2745                 _cleanup_free_ char *arg = NULL;
2746
2747                 r = extract_first_word(&value, &arg, NULL, EXTRACT_CUNESCAPE | EXTRACT_UNQUOTE);
2748                 if (r < 0)
2749                         return r;
2750                 if (r == 0)
2751                         break;
2752
2753                 switch (state) {
2754                 case STATE_EXEC_COMMAND_TYPE:
2755                         id = service_exec_command_from_string(arg);
2756                         if (id < 0)
2757                                 return -EINVAL;
2758
2759                         state = STATE_EXEC_COMMAND_INDEX;
2760                         break;
2761                 case STATE_EXEC_COMMAND_INDEX:
2762                         r = safe_atou(arg, &idx);
2763                         if (r < 0)
2764                                 return -EINVAL;
2765
2766                         state = STATE_EXEC_COMMAND_PATH;
2767                         break;
2768                 case STATE_EXEC_COMMAND_PATH:
2769                         path = TAKE_PTR(arg);
2770                         state = STATE_EXEC_COMMAND_ARGS;
2771
2772                         if (!path_is_absolute(path))
2773                                 return -EINVAL;
2774                         break;
2775                 case STATE_EXEC_COMMAND_ARGS:
2776                         r = strv_extend(&argv, arg);
2777                         if (r < 0)
2778                                 return -ENOMEM;
2779                         break;
2780                 default:
2781                         assert_not_reached("Unknown error at deserialization of exec command");
2782                         break;
2783                 }
2784         }
2785
2786         if (state != STATE_EXEC_COMMAND_ARGS)
2787                 return -EINVAL;
2788
2789         /* Let's check whether exec command on given offset matches data that we just deserialized */
2790         for (command = s->exec_command[id], i = 0; command; command = command->command_next, i++) {
2791                 if (i != idx)
2792                         continue;
2793
2794                 found = strv_equal(argv, command->argv) && streq(command->path, path);
2795                 break;
2796         }
2797
2798         if (!found) {
2799                 /* Command at the index we serialized is different, let's look for command that exactly
2800                  * matches but is on different index. If there is no such command we will not resume execution. */
2801                 for (command = s->exec_command[id]; command; command = command->command_next)
2802                         if (strv_equal(command->argv, argv) && streq(command->path, path))
2803                                 break;
2804         }
2805
2806         if (command && control)
2807                 s->control_command = command;
2808         else if (command)
2809                 s->main_command = command;
2810         else
2811                 log_unit_warning(u, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2812
2813         return 0;
2814 }
2815
2816 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2817         Service *s = SERVICE(u);
2818         int r;
2819
2820         assert(u);
2821         assert(key);
2822         assert(value);
2823         assert(fds);
2824
2825         if (streq(key, "state")) {
2826                 ServiceState state;
2827
2828                 state = service_state_from_string(value);
2829                 if (state < 0)
2830                         log_unit_debug(u, "Failed to parse state value: %s", value);
2831                 else
2832                         s->deserialized_state = state;
2833         } else if (streq(key, "result")) {
2834                 ServiceResult f;
2835
2836                 f = service_result_from_string(value);
2837                 if (f < 0)
2838                         log_unit_debug(u, "Failed to parse result value: %s", value);
2839                 else if (f != SERVICE_SUCCESS)
2840                         s->result = f;
2841
2842         } else if (streq(key, "reload-result")) {
2843                 ServiceResult f;
2844
2845                 f = service_result_from_string(value);
2846                 if (f < 0)
2847                         log_unit_debug(u, "Failed to parse reload result value: %s", value);
2848                 else if (f != SERVICE_SUCCESS)
2849                         s->reload_result = f;
2850
2851         } else if (streq(key, "control-pid")) {
2852                 pid_t pid;
2853
2854                 if (parse_pid(value, &pid) < 0)
2855                         log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2856                 else
2857                         s->control_pid = pid;
2858         } else if (streq(key, "main-pid")) {
2859                 pid_t pid;
2860
2861                 if (parse_pid(value, &pid) < 0)
2862                         log_unit_debug(u, "Failed to parse main-pid value: %s", value);
2863                 else
2864                         (void) service_set_main_pid(s, pid);
2865         } else if (streq(key, "main-pid-known")) {
2866                 int b;
2867
2868                 b = parse_boolean(value);
2869                 if (b < 0)
2870                         log_unit_debug(u, "Failed to parse main-pid-known value: %s", value);
2871                 else
2872                         s->main_pid_known = b;
2873         } else if (streq(key, "bus-name-good")) {
2874                 int b;
2875
2876                 b = parse_boolean(value);
2877                 if (b < 0)
2878                         log_unit_debug(u, "Failed to parse bus-name-good value: %s", value);
2879                 else
2880                         s->bus_name_good = b;
2881         } else if (streq(key, "bus-name-owner")) {
2882                 r = free_and_strdup(&s->bus_name_owner, value);
2883                 if (r < 0)
2884                         log_unit_error_errno(u, r, "Unable to deserialize current bus owner %s: %m", value);
2885         } else if (streq(key, "status-text")) {
2886                 char *t;
2887
2888                 r = cunescape(value, 0, &t);
2889                 if (r < 0)
2890                         log_unit_debug_errno(u, r, "Failed to unescape status text '%s': %m", value);
2891                 else
2892                         free_and_replace(s->status_text, t);
2893
2894         } else if (streq(key, "accept-socket")) {
2895                 Unit *socket;
2896
2897                 r = manager_load_unit(u->manager, value, NULL, NULL, &socket);
2898                 if (r < 0)
2899                         log_unit_debug_errno(u, r, "Failed to load accept-socket unit '%s': %m", value);
2900                 else {
2901                         unit_ref_set(&s->accept_socket, u, socket);
2902                         SOCKET(socket)->n_connections++;
2903                 }
2904
2905         } else if (streq(key, "socket-fd")) {
2906                 int fd;
2907
2908                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2909                         log_unit_debug(u, "Failed to parse socket-fd value: %s", value);
2910                 else {
2911                         asynchronous_close(s->socket_fd);
2912                         s->socket_fd = fdset_remove(fds, fd);
2913                 }
2914         } else if (streq(key, "fd-store-fd")) {
2915                 const char *fdv;
2916                 size_t pf;
2917                 int fd;
2918
2919                 pf = strcspn(value, WHITESPACE);
2920                 fdv = strndupa(value, pf);
2921
2922                 if (safe_atoi(fdv, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2923                         log_unit_debug(u, "Failed to parse fd-store-fd value: %s", value);
2924                 else {
2925                         _cleanup_free_ char *t = NULL;
2926                         const char *fdn;
2927
2928                         fdn = value + pf;
2929                         fdn += strspn(fdn, WHITESPACE);
2930                         (void) cunescape(fdn, 0, &t);
2931
2932                         r = service_add_fd_store(s, fd, t);
2933                         if (r < 0)
2934                                 log_unit_error_errno(u, r, "Failed to add fd to store: %m");
2935                         else
2936                                 fdset_remove(fds, fd);
2937                 }
2938
2939         } else if (streq(key, "main-exec-status-pid")) {
2940                 pid_t pid;
2941
2942                 if (parse_pid(value, &pid) < 0)
2943                         log_unit_debug(u, "Failed to parse main-exec-status-pid value: %s", value);
2944                 else
2945                         s->main_exec_status.pid = pid;
2946         } else if (streq(key, "main-exec-status-code")) {
2947                 int i;
2948
2949                 if (safe_atoi(value, &i) < 0)
2950                         log_unit_debug(u, "Failed to parse main-exec-status-code value: %s", value);
2951                 else
2952                         s->main_exec_status.code = i;
2953         } else if (streq(key, "main-exec-status-status")) {
2954                 int i;
2955
2956                 if (safe_atoi(value, &i) < 0)
2957                         log_unit_debug(u, "Failed to parse main-exec-status-status value: %s", value);
2958                 else
2959                         s->main_exec_status.status = i;
2960         } else if (streq(key, "main-exec-status-start"))
2961                 deserialize_dual_timestamp(value, &s->main_exec_status.start_timestamp);
2962         else if (streq(key, "main-exec-status-exit"))
2963                 deserialize_dual_timestamp(value, &s->main_exec_status.exit_timestamp);
2964         else if (streq(key, "watchdog-timestamp"))
2965                 deserialize_dual_timestamp(value, &s->watchdog_timestamp);
2966         else if (streq(key, "forbid-restart")) {
2967                 int b;
2968
2969                 b = parse_boolean(value);
2970                 if (b < 0)
2971                         log_unit_debug(u, "Failed to parse forbid-restart value: %s", value);
2972                 else
2973                         s->forbid_restart = b;
2974         } else if (streq(key, "stdin-fd")) {
2975                 int fd;
2976
2977                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2978                         log_unit_debug(u, "Failed to parse stdin-fd value: %s", value);
2979                 else {
2980                         asynchronous_close(s->stdin_fd);
2981                         s->stdin_fd = fdset_remove(fds, fd);
2982                         s->exec_context.stdio_as_fds = true;
2983                 }
2984         } else if (streq(key, "stdout-fd")) {
2985                 int fd;
2986
2987                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2988                         log_unit_debug(u, "Failed to parse stdout-fd value: %s", value);
2989                 else {
2990                         asynchronous_close(s->stdout_fd);
2991                         s->stdout_fd = fdset_remove(fds, fd);
2992                         s->exec_context.stdio_as_fds = true;
2993                 }
2994         } else if (streq(key, "stderr-fd")) {
2995                 int fd;
2996
2997                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2998                         log_unit_debug(u, "Failed to parse stderr-fd value: %s", value);
2999                 else {
3000                         asynchronous_close(s->stderr_fd);
3001                         s->stderr_fd = fdset_remove(fds, fd);
3002                         s->exec_context.stdio_as_fds = true;
3003                 }
3004         } else if (streq(key, "exec-fd")) {
3005                 int fd;
3006
3007                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
3008                         log_unit_debug(u, "Failed to parse exec-fd value: %s", value);
3009                 else {
3010                         s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
3011
3012                         fd = fdset_remove(fds, fd);
3013                         if (service_allocate_exec_fd_event_source(s, fd, &s->exec_fd_event_source) < 0)
3014                                 safe_close(fd);
3015                 }
3016         } else if (streq(key, "watchdog-override-usec")) {
3017                 if (deserialize_usec(value, &s->watchdog_override_usec) < 0)
3018                         log_unit_debug(u, "Failed to parse watchdog_override_usec value: %s", value);
3019                 else
3020                         s->watchdog_override_enable = true;
3021
3022         } else if (streq(key, "watchdog-original-usec")) {
3023                 if (deserialize_usec(value, &s->watchdog_original_usec) < 0)
3024                         log_unit_debug(u, "Failed to parse watchdog_original_usec value: %s", value);
3025
3026         } else if (STR_IN_SET(key, "main-command", "control-command")) {
3027                 r = service_deserialize_exec_command(u, key, value);
3028                 if (r < 0)
3029                         log_unit_debug_errno(u, r, "Failed to parse serialized command \"%s\": %m", value);
3030
3031         } else if (streq(key, "n-restarts")) {
3032                 r = safe_atou(value, &s->n_restarts);
3033                 if (r < 0)
3034                         log_unit_debug_errno(u, r, "Failed to parse serialized restart counter '%s': %m", value);
3035
3036         } else if (streq(key, "flush-n-restarts")) {
3037                 r = parse_boolean(value);
3038                 if (r < 0)
3039                         log_unit_debug_errno(u, r, "Failed to parse serialized flush restart counter setting '%s': %m", value);
3040                 else
3041                         s->flush_n_restarts = r;
3042         } else
3043                 log_unit_debug(u, "Unknown serialization key: %s", key);
3044
3045         return 0;
3046 }
3047
3048 _pure_ static UnitActiveState service_active_state(Unit *u) {
3049         const UnitActiveState *table;
3050
3051         assert(u);
3052
3053         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
3054
3055         return table[SERVICE(u)->state];
3056 }
3057
3058 static const char *service_sub_state_to_string(Unit *u) {
3059         assert(u);
3060
3061         return service_state_to_string(SERVICE(u)->state);
3062 }
3063
3064 static bool service_may_gc(Unit *u) {
3065         Service *s = SERVICE(u);
3066
3067         assert(s);
3068
3069         /* Never clean up services that still have a process around, even if the service is formally dead. Note that
3070          * unit_may_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
3071          * have moved outside of the cgroup. */
3072
3073         if (main_pid_good(s) > 0 ||
3074             control_pid_good(s) > 0)
3075                 return false;
3076
3077         return true;
3078 }
3079
3080 static int service_retry_pid_file(Service *s) {
3081         int r;
3082
3083         assert(s->pid_file);
3084         assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
3085
3086         r = service_load_pid_file(s, false);
3087         if (r < 0)
3088                 return r;
3089
3090         service_unwatch_pid_file(s);
3091
3092         service_enter_running(s, SERVICE_SUCCESS);
3093         return 0;
3094 }
3095
3096 static int service_watch_pid_file(Service *s) {
3097         int r;
3098
3099         log_unit_debug(UNIT(s), "Setting watch for PID file %s", s->pid_file_pathspec->path);
3100
3101         r = path_spec_watch(s->pid_file_pathspec, service_dispatch_inotify_io);
3102         if (r < 0)
3103                 goto fail;
3104
3105         /* the pidfile might have appeared just before we set the watch */
3106         log_unit_debug(UNIT(s), "Trying to read PID file %s in case it changed", s->pid_file_pathspec->path);
3107         service_retry_pid_file(s);
3108
3109         return 0;
3110 fail:
3111         log_unit_error_errno(UNIT(s), r, "Failed to set a watch for PID file %s: %m", s->pid_file_pathspec->path);
3112         service_unwatch_pid_file(s);
3113         return r;
3114 }
3115
3116 static int service_demand_pid_file(Service *s) {
3117         PathSpec *ps;
3118
3119         assert(s->pid_file);
3120         assert(!s->pid_file_pathspec);
3121
3122         ps = new0(PathSpec, 1);
3123         if (!ps)
3124                 return -ENOMEM;
3125
3126         ps->unit = UNIT(s);
3127         ps->path = strdup(s->pid_file);
3128         if (!ps->path) {
3129                 free(ps);
3130                 return -ENOMEM;
3131         }
3132
3133         path_simplify(ps->path, false);
3134
3135         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
3136          * keep their PID file open all the time. */
3137         ps->type = PATH_MODIFIED;
3138         ps->inotify_fd = -1;
3139
3140         s->pid_file_pathspec = ps;
3141
3142         return service_watch_pid_file(s);
3143 }
3144
3145 static int service_dispatch_inotify_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
3146         PathSpec *p = userdata;
3147         Service *s;
3148
3149         assert(p);
3150
3151         s = SERVICE(p->unit);
3152
3153         assert(s);
3154         assert(fd >= 0);
3155         assert(IN_SET(s->state, SERVICE_START, SERVICE_START_POST));
3156         assert(s->pid_file_pathspec);
3157         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
3158
3159         log_unit_debug(UNIT(s), "inotify event");
3160
3161         if (path_spec_fd_event(p, events) < 0)
3162                 goto fail;
3163
3164         if (service_retry_pid_file(s) == 0)
3165                 return 0;
3166
3167         if (service_watch_pid_file(s) < 0)
3168                 goto fail;
3169
3170         return 0;
3171
3172 fail:
3173         service_unwatch_pid_file(s);
3174         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3175         return 0;
3176 }
3177
3178 static int service_dispatch_exec_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
3179         Service *s = SERVICE(userdata);
3180
3181         assert(s);
3182
3183         log_unit_debug(UNIT(s), "got exec-fd event");
3184
3185         /* If Type=exec is set, we'll consider a service started successfully the instant we invoked execve()
3186          * successfully for it. We implement this through a pipe() towards the child, which the kernel automatically
3187          * closes for us due to O_CLOEXEC on execve() in the child, which then triggers EOF on the pipe in the
3188          * parent. We need to be careful however, as there are other reasons that we might cause the child's side of
3189          * the pipe to be closed (for example, a simple exit()). To deal with that we'll ignore EOFs on the pipe unless
3190          * the child signalled us first that it is about to call the execve(). It does so by sending us a simple
3191          * non-zero byte via the pipe. We also provide the child with a way to inform us in case execve() failed: if it
3192          * sends a zero byte we'll ignore POLLHUP on the fd again. */
3193
3194         for (;;) {
3195                 uint8_t x;
3196                 ssize_t n;
3197
3198                 n = read(fd, &x, sizeof(x));
3199                 if (n < 0) {
3200                         if (errno == EAGAIN) /* O_NONBLOCK in effect → everything queued has now been processed. */
3201                                 return 0;
3202
3203                         return log_unit_error_errno(UNIT(s), errno, "Failed to read from exec_fd: %m");
3204                 }
3205                 if (n == 0) { /* EOF → the event we are waiting for */
3206
3207                         s->exec_fd_event_source = sd_event_source_unref(s->exec_fd_event_source);
3208
3209                         if (s->exec_fd_hot) { /* Did the child tell us to expect EOF now? */
3210                                 log_unit_debug(UNIT(s), "Got EOF on exec-fd");
3211
3212                                 s->exec_fd_hot = false;
3213
3214                                 /* Nice! This is what we have been waiting for. Transition to next state. */
3215                                 if (s->type == SERVICE_EXEC && s->state == SERVICE_START)
3216                                         service_enter_start_post(s);
3217                         } else
3218                                 log_unit_debug(UNIT(s), "Got EOF on exec-fd while it was disabled, ignoring.");
3219
3220                         return 0;
3221                 }
3222
3223                 /* A byte was read → this turns on/off the exec fd logic */
3224                 assert(n == sizeof(x));
3225                 s->exec_fd_hot = x;
3226         }
3227
3228         return 0;
3229 }
3230
3231 static void service_notify_cgroup_empty_event(Unit *u) {
3232         Service *s = SERVICE(u);
3233
3234         assert(u);
3235
3236         log_unit_debug(u, "Control group is empty.");
3237
3238         switch (s->state) {
3239
3240                 /* Waiting for SIGCHLD is usually more interesting,
3241                  * because it includes return codes/signals. Which is
3242                  * why we ignore the cgroup events for most cases,
3243                  * except when we don't know pid which to expect the
3244                  * SIGCHLD for. */
3245
3246         case SERVICE_START:
3247                 if (s->type == SERVICE_NOTIFY &&
3248                     main_pid_good(s) == 0 &&
3249                     control_pid_good(s) == 0) {
3250                         /* No chance of getting a ready notification anymore */
3251                         service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
3252                         break;
3253                 }
3254
3255                 _fallthrough_;
3256         case SERVICE_START_POST:
3257                 if (s->pid_file_pathspec &&
3258                     main_pid_good(s) == 0 &&
3259                     control_pid_good(s) == 0) {
3260
3261                         /* Give up hoping for the daemon to write its PID file */
3262                         log_unit_warning(u, "Daemon never wrote its PID file. Failing.");
3263
3264                         service_unwatch_pid_file(s);
3265                         if (s->state == SERVICE_START)
3266                                 service_enter_stop_post(s, SERVICE_FAILURE_PROTOCOL);
3267                         else
3268                                 service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
3269                 }
3270                 break;
3271
3272         case SERVICE_RUNNING:
3273                 /* service_enter_running() will figure out what to do */
3274                 service_enter_running(s, SERVICE_SUCCESS);
3275                 break;
3276
3277         case SERVICE_STOP_WATCHDOG:
3278         case SERVICE_STOP_SIGTERM:
3279         case SERVICE_STOP_SIGKILL:
3280
3281                 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3282                         service_enter_stop_post(s, SERVICE_SUCCESS);
3283
3284                 break;
3285
3286         case SERVICE_STOP_POST:
3287         case SERVICE_FINAL_SIGTERM:
3288         case SERVICE_FINAL_SIGKILL:
3289                 if (main_pid_good(s) <= 0 && control_pid_good(s) <= 0)
3290                         service_enter_dead(s, SERVICE_SUCCESS, true);
3291
3292                 break;
3293
3294         default:
3295                 ;
3296         }
3297 }
3298
3299 static void service_notify_cgroup_oom_event(Unit *u) {
3300         Service *s = SERVICE(u);
3301
3302         log_unit_debug(u, "Process of control group was killed by the OOM killer.");
3303
3304         if (s->oom_policy == OOM_CONTINUE)
3305                 return;
3306
3307         switch (s->state) {
3308
3309         case SERVICE_CONDITION:
3310         case SERVICE_START_PRE:
3311         case SERVICE_START:
3312         case SERVICE_START_POST:
3313         case SERVICE_STOP:
3314                 if (s->oom_policy == OOM_STOP)
3315                         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_OOM_KILL);
3316                 else if (s->oom_policy == OOM_KILL)
3317                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_OOM_KILL);
3318
3319                 break;
3320
3321         case SERVICE_EXITED:
3322         case SERVICE_RUNNING:
3323                 if (s->oom_policy == OOM_STOP)
3324                         service_enter_stop(s, SERVICE_FAILURE_OOM_KILL);
3325                 else if (s->oom_policy == OOM_KILL)
3326                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_OOM_KILL);
3327
3328                 break;
3329
3330         case SERVICE_STOP_WATCHDOG:
3331         case SERVICE_STOP_SIGTERM:
3332                 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_OOM_KILL);
3333                 break;
3334
3335         case SERVICE_STOP_SIGKILL:
3336         case SERVICE_FINAL_SIGKILL:
3337                 if (s->result == SERVICE_SUCCESS)
3338                         s->result = SERVICE_FAILURE_OOM_KILL;
3339                 break;
3340
3341         case SERVICE_STOP_POST:
3342         case SERVICE_FINAL_SIGTERM:
3343                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_OOM_KILL);
3344                 break;
3345
3346         default:
3347                 ;
3348         }
3349 }
3350
3351 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
3352         bool notify_dbus = true;
3353         Service *s = SERVICE(u);
3354         ServiceResult f;
3355         ExitClean clean_mode;
3356
3357         assert(s);
3358         assert(pid >= 0);
3359
3360         /* Oneshot services and non-SERVICE_EXEC_START commands should not be
3361          * considered daemons as they are typically not long running. */
3362         if (s->type == SERVICE_ONESHOT || (s->control_pid == pid && s->control_command_id != SERVICE_EXEC_START))
3363                 clean_mode = EXIT_CLEAN_COMMAND;
3364         else
3365                 clean_mode = EXIT_CLEAN_DAEMON;
3366
3367         if (is_clean_exit(code, status, clean_mode, &s->success_status))
3368                 f = SERVICE_SUCCESS;
3369         else if (code == CLD_EXITED)
3370                 f = SERVICE_FAILURE_EXIT_CODE;
3371         else if (code == CLD_KILLED)
3372                 f = SERVICE_FAILURE_SIGNAL;
3373         else if (code == CLD_DUMPED)
3374                 f = SERVICE_FAILURE_CORE_DUMP;
3375         else
3376                 assert_not_reached("Unknown code");
3377
3378         if (s->main_pid == pid) {
3379                 /* Forking services may occasionally move to a new PID.
3380                  * As long as they update the PID file before exiting the old
3381                  * PID, they're fine. */
3382                 if (service_load_pid_file(s, false) > 0)
3383                         return;
3384
3385                 s->main_pid = 0;
3386                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
3387
3388                 if (s->main_command) {
3389                         /* If this is not a forking service than the
3390                          * main process got started and hence we copy
3391                          * the exit status so that it is recorded both
3392                          * as main and as control process exit
3393                          * status */
3394
3395                         s->main_command->exec_status = s->main_exec_status;
3396
3397                         if (s->main_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3398                                 f = SERVICE_SUCCESS;
3399                 } else if (s->exec_command[SERVICE_EXEC_START]) {
3400
3401                         /* If this is a forked process, then we should
3402                          * ignore the return value if this was
3403                          * configured for the starter process */
3404
3405                         if (s->exec_command[SERVICE_EXEC_START]->flags & EXEC_COMMAND_IGNORE_FAILURE)
3406                                 f = SERVICE_SUCCESS;
3407                 }
3408
3409                 unit_log_process_exit(
3410                                 u,
3411                                 "Main process",
3412                                 service_exec_command_to_string(SERVICE_EXEC_START),
3413                                 f == SERVICE_SUCCESS,
3414                                 code, status);
3415
3416                 if (s->result == SERVICE_SUCCESS)
3417                         s->result = f;
3418
3419                 if (s->main_command &&
3420                     s->main_command->command_next &&
3421                     s->type == SERVICE_ONESHOT &&
3422                     f == SERVICE_SUCCESS) {
3423
3424                         /* There is another command to *
3425                          * execute, so let's do that. */
3426
3427                         log_unit_debug(u, "Running next main command for state %s.", service_state_to_string(s->state));
3428                         service_run_next_main(s);
3429
3430                 } else {
3431
3432                         /* The service exited, so the service is officially
3433                          * gone. */
3434                         s->main_command = NULL;
3435
3436                         switch (s->state) {
3437
3438                         case SERVICE_START_POST:
3439                         case SERVICE_RELOAD:
3440                         case SERVICE_STOP:
3441                                 /* Need to wait until the operation is
3442                                  * done */
3443                                 break;
3444
3445                         case SERVICE_START:
3446                                 if (s->type == SERVICE_ONESHOT) {
3447                                         /* This was our main goal, so let's go on */
3448                                         if (f == SERVICE_SUCCESS)
3449                                                 service_enter_start_post(s);
3450                                         else
3451                                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3452                                         break;
3453                                 } else if (s->type == SERVICE_NOTIFY) {
3454                                         /* Only enter running through a notification, so that the
3455                                          * SERVICE_START state signifies that no ready notification
3456                                          * has been received */
3457                                         if (f != SERVICE_SUCCESS)
3458                                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3459                                         else if (!s->remain_after_exit || s->notify_access == NOTIFY_MAIN)
3460                                                 /* The service has never been and will never be active */
3461                                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3462                                         break;
3463                                 }
3464
3465                                 _fallthrough_;
3466                         case SERVICE_RUNNING:
3467                                 service_enter_running(s, f);
3468                                 break;
3469
3470                         case SERVICE_STOP_WATCHDOG:
3471                         case SERVICE_STOP_SIGTERM:
3472                         case SERVICE_STOP_SIGKILL:
3473
3474                                 if (control_pid_good(s) <= 0)
3475                                         service_enter_stop_post(s, f);
3476
3477                                 /* If there is still a control process, wait for that first */
3478                                 break;
3479
3480                         case SERVICE_STOP_POST:
3481                         case SERVICE_FINAL_SIGTERM:
3482                         case SERVICE_FINAL_SIGKILL:
3483
3484                                 if (control_pid_good(s) <= 0)
3485                                         service_enter_dead(s, f, true);
3486                                 break;
3487
3488                         default:
3489                                 assert_not_reached("Uh, main process died at wrong time.");
3490                         }
3491                 }
3492
3493         } else if (s->control_pid == pid) {
3494                 s->control_pid = 0;
3495
3496                 /* ExecCondition= calls that exit with (0, 254] should invoke skip-like behavior instead of failing */
3497                 if (f == SERVICE_FAILURE_EXIT_CODE && s->state == SERVICE_CONDITION && status < 255)
3498                         f = SERVICE_SKIP_CONDITION;
3499
3500                 if (s->control_command) {
3501                         exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
3502
3503                         if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3504                                 f = SERVICE_SUCCESS;
3505                 }
3506
3507                 unit_log_process_exit(
3508                                 u,
3509                                 "Control process",
3510                                 service_exec_command_to_string(s->control_command_id),
3511                                 f == SERVICE_SUCCESS,
3512                                 code, status);
3513
3514                 if (s->state != SERVICE_RELOAD && s->result == SERVICE_SUCCESS)
3515                         s->result = f;
3516
3517                 if (s->control_command &&
3518                     s->control_command->command_next &&
3519                     f == SERVICE_SUCCESS) {
3520
3521                         /* There is another command to *
3522                          * execute, so let's do that. */
3523
3524                         log_unit_debug(u, "Running next control command for state %s.", service_state_to_string(s->state));
3525                         service_run_next_control(s);
3526
3527                 } else {
3528                         /* No further commands for this step, so let's
3529                          * figure out what to do next */
3530
3531                         s->control_command = NULL;
3532                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3533
3534                         log_unit_debug(u, "Got final SIGCHLD for state %s.", service_state_to_string(s->state));
3535
3536                         switch (s->state) {
3537
3538                         case SERVICE_CONDITION:
3539                                 if (f == SERVICE_SUCCESS)
3540                                         service_enter_start_pre(s);
3541                                 else
3542                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3543                                 break;
3544
3545                         case SERVICE_START_PRE:
3546                                 if (f == SERVICE_SUCCESS)
3547                                         service_enter_start(s);
3548                                 else
3549                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3550                                 break;
3551
3552                         case SERVICE_START:
3553                                 if (s->type != SERVICE_FORKING)
3554                                         /* Maybe spurious event due to a reload that changed the type? */
3555                                         break;
3556
3557                                 if (f != SERVICE_SUCCESS) {
3558                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3559                                         break;
3560                                 }
3561
3562                                 if (s->pid_file) {
3563                                         bool has_start_post;
3564                                         int r;
3565
3566                                         /* Let's try to load the pid file here if we can.
3567                                          * The PID file might actually be created by a START_POST
3568                                          * script. In that case don't worry if the loading fails. */
3569
3570                                         has_start_post = s->exec_command[SERVICE_EXEC_START_POST];
3571                                         r = service_load_pid_file(s, !has_start_post);
3572                                         if (!has_start_post && r < 0) {
3573                                                 r = service_demand_pid_file(s);
3574                                                 if (r < 0 || cgroup_good(s) == 0)
3575                                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_PROTOCOL);
3576                                                 break;
3577                                         }
3578                                 } else
3579                                         service_search_main_pid(s);
3580
3581                                 service_enter_start_post(s);
3582                                 break;
3583
3584                         case SERVICE_START_POST:
3585                                 if (f != SERVICE_SUCCESS) {
3586                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3587                                         break;
3588                                 }
3589
3590                                 if (s->pid_file) {
3591                                         int r;
3592
3593                                         r = service_load_pid_file(s, true);
3594                                         if (r < 0) {
3595                                                 r = service_demand_pid_file(s);
3596                                                 if (r < 0 || cgroup_good(s) == 0)
3597                                                         service_enter_stop(s, SERVICE_FAILURE_PROTOCOL);
3598                                                 break;
3599                                         }
3600                                 } else
3601                                         service_search_main_pid(s);
3602
3603                                 service_enter_running(s, SERVICE_SUCCESS);
3604                                 break;
3605
3606                         case SERVICE_RELOAD:
3607                                 if (f == SERVICE_SUCCESS)
3608                                         if (service_load_pid_file(s, true) < 0)
3609                                                 service_search_main_pid(s);
3610
3611                                 s->reload_result = f;
3612                                 service_enter_running(s, SERVICE_SUCCESS);
3613                                 break;
3614
3615                         case SERVICE_STOP:
3616                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3617                                 break;
3618
3619                         case SERVICE_STOP_WATCHDOG:
3620                         case SERVICE_STOP_SIGTERM:
3621                         case SERVICE_STOP_SIGKILL:
3622                                 if (main_pid_good(s) <= 0)
3623                                         service_enter_stop_post(s, f);
3624
3625                                 /* If there is still a service process around, wait until
3626                                  * that one quit, too */
3627                                 break;
3628
3629                         case SERVICE_STOP_POST:
3630                         case SERVICE_FINAL_SIGTERM:
3631                         case SERVICE_FINAL_SIGKILL:
3632                                 if (main_pid_good(s) <= 0)
3633                                         service_enter_dead(s, f, true);
3634                                 break;
3635
3636                         case SERVICE_CLEANING:
3637
3638                                 if (s->clean_result == SERVICE_SUCCESS)
3639                                         s->clean_result = f;
3640
3641                                 service_enter_dead(s, SERVICE_SUCCESS, false);
3642                                 break;
3643
3644                         default:
3645                                 assert_not_reached("Uh, control process died at wrong time.");
3646                         }
3647                 }
3648         } else /* Neither control nor main PID? If so, don't notify about anything */
3649                 notify_dbus = false;
3650
3651         /* Notify clients about changed exit status */
3652         if (notify_dbus)
3653                 unit_add_to_dbus_queue(u);
3654
3655         /* We watch the main/control process otherwise we can't retrieve the unit they
3656          * belong to with cgroupv1. But if they are not our direct child, we won't get a
3657          * SIGCHLD for them. Therefore we need to look for others to watch so we can
3658          * detect when the cgroup becomes empty. Note that the control process is always
3659          * our child so it's pointless to watch all other processes. */
3660         if (!control_pid_good(s))
3661                 if (!s->main_pid_known || s->main_pid_alien)
3662                         (void) unit_enqueue_rewatch_pids(u);
3663 }
3664
3665 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3666         Service *s = SERVICE(userdata);
3667
3668         assert(s);
3669         assert(source == s->timer_event_source);
3670
3671         switch (s->state) {
3672
3673         case SERVICE_CONDITION:
3674         case SERVICE_START_PRE:
3675         case SERVICE_START:
3676                 log_unit_warning(UNIT(s), "%s operation timed out. Terminating.", service_state_to_string(s->state));
3677                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3678                 break;
3679
3680         case SERVICE_START_POST:
3681                 log_unit_warning(UNIT(s), "Start-post operation timed out. Stopping.");
3682                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3683                 break;
3684
3685         case SERVICE_RUNNING:
3686                 log_unit_warning(UNIT(s), "Service reached runtime time limit. Stopping.");
3687                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3688                 break;
3689
3690         case SERVICE_RELOAD:
3691                 log_unit_warning(UNIT(s), "Reload operation timed out. Killing reload process.");
3692                 service_kill_control_process(s);
3693                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3694                 service_enter_running(s, SERVICE_SUCCESS);
3695                 break;
3696
3697         case SERVICE_STOP:
3698                 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
3699                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3700                 break;
3701
3702         case SERVICE_STOP_WATCHDOG:
3703                 log_unit_warning(UNIT(s), "State 'stop-watchdog' timed out. Terminating.");
3704                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3705                 break;
3706
3707         case SERVICE_STOP_SIGTERM:
3708                 if (s->kill_context.send_sigkill) {
3709                         log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Killing.");
3710                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3711                 } else {
3712                         log_unit_warning(UNIT(s), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3713                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3714                 }
3715
3716                 break;
3717
3718         case SERVICE_STOP_SIGKILL:
3719                 /* Uh, we sent a SIGKILL and it is still not gone?
3720                  * Must be something we cannot kill, so let's just be
3721                  * weirded out and continue */
3722
3723                 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
3724                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3725                 break;
3726
3727         case SERVICE_STOP_POST:
3728                 log_unit_warning(UNIT(s), "State 'stop-post' timed out. Terminating.");
3729                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3730                 break;
3731
3732         case SERVICE_FINAL_SIGTERM:
3733                 if (s->kill_context.send_sigkill) {
3734                         log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Killing.");
3735                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3736                 } else {
3737                         log_unit_warning(UNIT(s), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3738                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3739                 }
3740
3741                 break;
3742
3743         case SERVICE_FINAL_SIGKILL:
3744                 log_unit_warning(UNIT(s), "Processes still around after final SIGKILL. Entering failed mode.");
3745                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3746                 break;
3747
3748         case SERVICE_AUTO_RESTART:
3749                 if (s->restart_usec > 0) {
3750                         char buf_restart[FORMAT_TIMESPAN_MAX];
3751                         log_unit_info(UNIT(s),
3752                                       "Service RestartSec=%s expired, scheduling restart.",
3753                                       format_timespan(buf_restart, sizeof buf_restart, s->restart_usec, USEC_PER_SEC));
3754                 } else
3755                         log_unit_info(UNIT(s),
3756                                       "Service has no hold-off time (RestartSec=0), scheduling restart.");
3757
3758                 service_enter_restart(s);
3759                 break;
3760
3761         case SERVICE_CLEANING:
3762                 log_unit_warning(UNIT(s), "Cleaning timed out. killing.");
3763
3764                 if (s->clean_result == SERVICE_SUCCESS)
3765                         s->clean_result = SERVICE_FAILURE_TIMEOUT;
3766
3767                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, 0);
3768                 break;
3769
3770         default:
3771                 assert_not_reached("Timeout at wrong time.");
3772         }
3773
3774         return 0;
3775 }
3776
3777 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3778         Service *s = SERVICE(userdata);
3779         char t[FORMAT_TIMESPAN_MAX];
3780         usec_t watchdog_usec;
3781
3782         assert(s);
3783         assert(source == s->watchdog_event_source);
3784
3785         watchdog_usec = service_get_watchdog_usec(s);
3786
3787         if (UNIT(s)->manager->service_watchdogs) {
3788                 log_unit_error(UNIT(s), "Watchdog timeout (limit %s)!",
3789                                format_timespan(t, sizeof(t), watchdog_usec, 1));
3790
3791                 service_enter_signal(s, SERVICE_STOP_WATCHDOG, SERVICE_FAILURE_WATCHDOG);
3792         } else
3793                 log_unit_warning(UNIT(s), "Watchdog disabled! Ignoring watchdog timeout (limit %s)!",
3794                                  format_timespan(t, sizeof(t), watchdog_usec, 1));
3795
3796         return 0;
3797 }
3798
3799 static bool service_notify_message_authorized(Service *s, pid_t pid, char **tags, FDSet *fds) {
3800         assert(s);
3801
3802         if (s->notify_access == NOTIFY_NONE) {
3803                 log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception is disabled.", pid);
3804                 return false;
3805         }
3806
3807         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3808                 if (s->main_pid != 0)
3809                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, pid, s->main_pid);
3810                 else
3811                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", pid);
3812
3813                 return false;
3814         }
3815
3816         if (s->notify_access == NOTIFY_EXEC && pid != s->main_pid && pid != s->control_pid) {
3817                 if (s->main_pid != 0 && s->control_pid != 0)
3818                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT" and control PID "PID_FMT,
3819                                          pid, s->main_pid, s->control_pid);
3820                 else if (s->main_pid != 0)
3821                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, pid, s->main_pid);
3822                 else if (s->control_pid != 0)
3823                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for control PID "PID_FMT, pid, s->control_pid);
3824                 else
3825                         log_unit_warning(UNIT(s), "Got notification message from PID "PID_FMT", but reception only permitted for main PID and control PID which are currently not known", pid);
3826
3827                 return false;
3828         }
3829
3830         return true;
3831 }
3832
3833 static void service_force_watchdog(Service *s) {
3834         if (!UNIT(s)->manager->service_watchdogs)
3835                 return;
3836
3837         log_unit_error(UNIT(s), "Watchdog request (last status: %s)!",
3838                        s->status_text ? s->status_text : "<unset>");
3839
3840         service_enter_signal(s, SERVICE_STOP_WATCHDOG, SERVICE_FAILURE_WATCHDOG);
3841 }
3842
3843 static void service_notify_message(
3844                 Unit *u,
3845                 const struct ucred *ucred,
3846                 char **tags,
3847                 FDSet *fds) {
3848
3849         Service *s = SERVICE(u);
3850         bool notify_dbus = false;
3851         const char *e;
3852         char **i;
3853         int r;
3854
3855         assert(u);
3856         assert(ucred);
3857
3858         if (!service_notify_message_authorized(SERVICE(u), ucred->pid, tags, fds))
3859                 return;
3860
3861         if (DEBUG_LOGGING) {
3862                 _cleanup_free_ char *cc = NULL;
3863
3864                 cc = strv_join(tags, ", ");
3865                 log_unit_debug(u, "Got notification message from PID "PID_FMT" (%s)", ucred->pid, isempty(cc) ? "n/a" : cc);
3866         }
3867
3868         /* Interpret MAINPID= */
3869         e = strv_find_startswith(tags, "MAINPID=");
3870         if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
3871                 pid_t new_main_pid;
3872
3873                 if (parse_pid(e, &new_main_pid) < 0)
3874                         log_unit_warning(u, "Failed to parse MAINPID= field in notification message, ignoring: %s", e);
3875                 else if (!s->main_pid_known || new_main_pid != s->main_pid) {
3876
3877                         r = service_is_suitable_main_pid(s, new_main_pid, LOG_WARNING);
3878                         if (r == 0) {
3879                                 /* The new main PID is a bit suspicious, which is OK if the sender is privileged. */
3880
3881                                 if (ucred->uid == 0) {
3882                                         log_unit_debug(u, "New main PID "PID_FMT" does not belong to service, but we'll accept it as the request to change it came from a privileged process.", new_main_pid);
3883                                         r = 1;
3884                                 } else
3885                                         log_unit_debug(u, "New main PID "PID_FMT" does not belong to service, refusing.", new_main_pid);
3886                         }
3887                         if (r > 0) {
3888                                 service_set_main_pid(s, new_main_pid);
3889
3890                                 r = unit_watch_pid(UNIT(s), new_main_pid, false);
3891                                 if (r < 0)
3892                                         log_unit_warning_errno(UNIT(s), r, "Failed to watch new main PID "PID_FMT" for service: %m", new_main_pid);
3893
3894                                 notify_dbus = true;
3895                         }
3896                 }
3897         }
3898
3899         /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3900         STRV_FOREACH_BACKWARDS(i, tags) {
3901
3902                 if (streq(*i, "READY=1")) {
3903                         s->notify_state = NOTIFY_READY;
3904
3905                         /* Type=notify services inform us about completed
3906                          * initialization with READY=1 */
3907                         if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
3908                                 service_enter_start_post(s);
3909
3910                         /* Sending READY=1 while we are reloading informs us
3911                          * that the reloading is complete */
3912                         if (s->state == SERVICE_RELOAD && s->control_pid == 0)
3913                                 service_enter_running(s, SERVICE_SUCCESS);
3914
3915                         notify_dbus = true;
3916                         break;
3917
3918                 } else if (streq(*i, "RELOADING=1")) {
3919                         s->notify_state = NOTIFY_RELOADING;
3920
3921                         if (s->state == SERVICE_RUNNING)
3922                                 service_enter_reload_by_notify(s);
3923
3924                         notify_dbus = true;
3925                         break;
3926
3927                 } else if (streq(*i, "STOPPING=1")) {
3928                         s->notify_state = NOTIFY_STOPPING;
3929
3930                         if (s->state == SERVICE_RUNNING)
3931                                 service_enter_stop_by_notify(s);
3932
3933                         notify_dbus = true;
3934                         break;
3935                 }
3936         }
3937
3938         /* Interpret STATUS= */
3939         e = strv_find_startswith(tags, "STATUS=");
3940         if (e) {
3941                 _cleanup_free_ char *t = NULL;
3942
3943                 if (!isempty(e)) {
3944                         /* Note that this size limit check is mostly paranoia: since the datagram size we are willing
3945                          * to process is already limited to NOTIFY_BUFFER_MAX, this limit here should never be hit. */
3946                         if (strlen(e) > STATUS_TEXT_MAX)
3947                                 log_unit_warning(u, "Status message overly long (%zu > %u), ignoring.", strlen(e), STATUS_TEXT_MAX);
3948                         else if (!utf8_is_valid(e))
3949                                 log_unit_warning(u, "Status message in notification message is not UTF-8 clean, ignoring.");
3950                         else {
3951                                 t = strdup(e);
3952                                 if (!t)
3953                                         log_oom();
3954                         }
3955                 }
3956
3957                 if (!streq_ptr(s->status_text, t)) {
3958                         free_and_replace(s->status_text, t);
3959                         notify_dbus = true;
3960                 }
3961         }
3962
3963         /* Interpret ERRNO= */
3964         e = strv_find_startswith(tags, "ERRNO=");
3965         if (e) {
3966                 int status_errno;
3967
3968                 status_errno = parse_errno(e);
3969                 if (status_errno < 0)
3970                         log_unit_warning_errno(u, status_errno,
3971                                                "Failed to parse ERRNO= field value '%s' in notification message: %m", e);
3972                 else if (s->status_errno != status_errno) {
3973                         s->status_errno = status_errno;
3974                         notify_dbus = true;
3975                 }
3976         }
3977
3978         /* Interpret EXTEND_TIMEOUT= */
3979         e = strv_find_startswith(tags, "EXTEND_TIMEOUT_USEC=");
3980         if (e) {
3981                 usec_t extend_timeout_usec;
3982                 if (safe_atou64(e, &extend_timeout_usec) < 0)
3983                         log_unit_warning(u, "Failed to parse EXTEND_TIMEOUT_USEC=%s", e);
3984                 else
3985                         service_extend_timeout(s, extend_timeout_usec);
3986         }
3987
3988         /* Interpret WATCHDOG= */
3989         e = strv_find_startswith(tags, "WATCHDOG=");
3990         if (e) {
3991                 if (streq(e, "1"))
3992                         service_reset_watchdog(s);
3993                 else if (streq(e, "trigger"))
3994                         service_force_watchdog(s);
3995                 else
3996                         log_unit_warning(u, "Passed WATCHDOG= field is invalid, ignoring.");
3997         }
3998
3999         e = strv_find_startswith(tags, "WATCHDOG_USEC=");
4000         if (e) {
4001                 usec_t watchdog_override_usec;
4002                 if (safe_atou64(e, &watchdog_override_usec) < 0)
4003                         log_unit_warning(u, "Failed to parse WATCHDOG_USEC=%s", e);
4004                 else
4005                         service_override_watchdog_timeout(s, watchdog_override_usec);
4006         }
4007
4008         /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
4009          * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
4010          * fds, but optional when pushing in new fds, for compatibility reasons. */
4011         if (strv_find(tags, "FDSTOREREMOVE=1")) {
4012                 const char *name;
4013
4014                 name = strv_find_startswith(tags, "FDNAME=");
4015                 if (!name || !fdname_is_valid(name))
4016                         log_unit_warning(u, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
4017                 else
4018                         service_remove_fd_store(s, name);
4019
4020         } else if (strv_find(tags, "FDSTORE=1")) {
4021                 const char *name;
4022
4023                 name = strv_find_startswith(tags, "FDNAME=");
4024                 if (name && !fdname_is_valid(name)) {
4025                         log_unit_warning(u, "Passed FDNAME= name is invalid, ignoring.");
4026                         name = NULL;
4027                 }
4028
4029                 (void) service_add_fd_store_set(s, fds, name);
4030         }
4031
4032         /* Notify clients about changed status or main pid */
4033         if (notify_dbus)
4034                 unit_add_to_dbus_queue(u);
4035 }
4036
4037 static int service_get_timeout(Unit *u, usec_t *timeout) {
4038         Service *s = SERVICE(u);
4039         uint64_t t;
4040         int r;
4041
4042         if (!s->timer_event_source)
4043                 return 0;
4044
4045         r = sd_event_source_get_time(s->timer_event_source, &t);
4046         if (r < 0)
4047                 return r;
4048         if (t == USEC_INFINITY)
4049                 return 0;
4050
4051         *timeout = t;
4052         return 1;
4053 }
4054
4055 static void service_bus_name_owner_change(
4056                 Unit *u,
4057                 const char *old_owner,
4058                 const char *new_owner) {
4059
4060         Service *s = SERVICE(u);
4061         int r;
4062
4063         assert(s);
4064
4065         assert(old_owner || new_owner);
4066
4067         if (old_owner && new_owner)
4068                 log_unit_debug(u, "D-Bus name %s changed owner from %s to %s", s->bus_name, old_owner, new_owner);
4069         else if (old_owner)
4070                 log_unit_debug(u, "D-Bus name %s no longer registered by %s", s->bus_name, old_owner);
4071         else
4072                 log_unit_debug(u, "D-Bus name %s now registered by %s", s->bus_name, new_owner);
4073
4074         s->bus_name_good = !!new_owner;
4075
4076         /* Track the current owner, so we can reconstruct changes after a daemon reload */
4077         r = free_and_strdup(&s->bus_name_owner, new_owner);
4078         if (r < 0) {
4079                 log_unit_error_errno(u, r, "Unable to set new bus name owner %s: %m", new_owner);
4080                 return;
4081         }
4082
4083         if (s->type == SERVICE_DBUS) {
4084
4085                 /* service_enter_running() will figure out what to
4086                  * do */
4087                 if (s->state == SERVICE_RUNNING)
4088                         service_enter_running(s, SERVICE_SUCCESS);
4089                 else if (s->state == SERVICE_START && new_owner)
4090                         service_enter_start_post(s);
4091
4092         } else if (new_owner &&
4093                    s->main_pid <= 0 &&
4094                    IN_SET(s->state,
4095                           SERVICE_START,
4096                           SERVICE_START_POST,
4097                           SERVICE_RUNNING,
4098                           SERVICE_RELOAD)) {
4099
4100                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
4101                 pid_t pid;
4102
4103                 /* Try to acquire PID from bus service */
4104
4105                 r = sd_bus_get_name_creds(u->manager->api_bus, s->bus_name, SD_BUS_CREDS_PID, &creds);
4106                 if (r >= 0)
4107                         r = sd_bus_creds_get_pid(creds, &pid);
4108                 if (r >= 0) {
4109                         log_unit_debug(u, "D-Bus name %s is now owned by process " PID_FMT, s->bus_name, pid);
4110
4111                         service_set_main_pid(s, pid);
4112                         unit_watch_pid(UNIT(s), pid, false);
4113                 }
4114         }
4115 }
4116
4117 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
4118         _cleanup_free_ char *peer = NULL;
4119         int r;
4120
4121         assert(s);
4122         assert(fd >= 0);
4123
4124         /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
4125          * to be configured. We take ownership of the passed fd on success. */
4126
4127         if (UNIT(s)->load_state != UNIT_LOADED)
4128                 return -EINVAL;
4129
4130         if (s->socket_fd >= 0)
4131                 return -EBUSY;
4132
4133         if (s->state != SERVICE_DEAD)
4134                 return -EAGAIN;
4135
4136         if (getpeername_pretty(fd, true, &peer) >= 0) {
4137
4138                 if (UNIT(s)->description) {
4139                         _cleanup_free_ char *a;
4140
4141                         a = strjoin(UNIT(s)->description, " (", peer, ")");
4142                         if (!a)
4143                                 return -ENOMEM;
4144
4145                         r = unit_set_description(UNIT(s), a);
4146                 }  else
4147                         r = unit_set_description(UNIT(s), peer);
4148
4149                 if (r < 0)
4150                         return r;
4151         }
4152
4153         r = unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false, UNIT_DEPENDENCY_IMPLICIT);
4154         if (r < 0)
4155                 return r;
4156
4157         s->socket_fd = fd;
4158         s->socket_fd_selinux_context_net = selinux_context_net;
4159
4160         unit_ref_set(&s->accept_socket, UNIT(s), UNIT(sock));
4161         return 0;
4162 }
4163
4164 static void service_reset_failed(Unit *u) {
4165         Service *s = SERVICE(u);
4166
4167         assert(s);
4168
4169         if (s->state == SERVICE_FAILED)
4170                 service_set_state(s, SERVICE_DEAD);
4171
4172         s->result = SERVICE_SUCCESS;
4173         s->reload_result = SERVICE_SUCCESS;
4174         s->clean_result = SERVICE_SUCCESS;
4175         s->n_restarts = 0;
4176         s->flush_n_restarts = false;
4177 }
4178
4179 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
4180         Service *s = SERVICE(u);
4181
4182         assert(s);
4183
4184         return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
4185 }
4186
4187 static int service_main_pid(Unit *u) {
4188         Service *s = SERVICE(u);
4189
4190         assert(s);
4191
4192         return s->main_pid;
4193 }
4194
4195 static int service_control_pid(Unit *u) {
4196         Service *s = SERVICE(u);
4197
4198         assert(s);
4199
4200         return s->control_pid;
4201 }
4202
4203 static bool service_needs_console(Unit *u) {
4204         Service *s = SERVICE(u);
4205
4206         assert(s);
4207
4208         /* We provide our own implementation of this here, instead of relying of the generic implementation
4209          * unit_needs_console() provides, since we want to return false if we are in SERVICE_EXITED state. */
4210
4211         if (!exec_context_may_touch_console(&s->exec_context))
4212                 return false;
4213
4214         return IN_SET(s->state,
4215                       SERVICE_CONDITION,
4216                       SERVICE_START_PRE,
4217                       SERVICE_START,
4218                       SERVICE_START_POST,
4219                       SERVICE_RUNNING,
4220                       SERVICE_RELOAD,
4221                       SERVICE_STOP,
4222                       SERVICE_STOP_WATCHDOG,
4223                       SERVICE_STOP_SIGTERM,
4224                       SERVICE_STOP_SIGKILL,
4225                       SERVICE_STOP_POST,
4226                       SERVICE_FINAL_SIGTERM,
4227                       SERVICE_FINAL_SIGKILL);
4228 }
4229
4230 static int service_exit_status(Unit *u) {
4231         Service *s = SERVICE(u);
4232
4233         assert(u);
4234
4235         if (s->main_exec_status.pid <= 0 ||
4236             !dual_timestamp_is_set(&s->main_exec_status.exit_timestamp))
4237                 return -ENODATA;
4238
4239         if (s->main_exec_status.code != CLD_EXITED)
4240                 return -EBADE;
4241
4242         return s->main_exec_status.status;
4243 }
4244
4245 static int service_clean(Unit *u, ExecCleanMask mask) {
4246         _cleanup_strv_free_ char **l = NULL;
4247         Service *s = SERVICE(u);
4248         int r;
4249
4250         assert(s);
4251         assert(mask != 0);
4252
4253         if (s->state != SERVICE_DEAD)
4254                 return -EBUSY;
4255
4256         r = exec_context_get_clean_directories(&s->exec_context, u->manager->prefix, mask, &l);
4257         if (r < 0)
4258                 return r;
4259
4260         if (strv_isempty(l))
4261                 return -EUNATCH;
4262
4263         service_unwatch_control_pid(s);
4264         s->clean_result = SERVICE_SUCCESS;
4265         s->control_command = NULL;
4266         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
4267
4268         r = service_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->exec_context.timeout_clean_usec));
4269         if (r < 0)
4270                 goto fail;
4271
4272         r = unit_fork_and_watch_rm_rf(u, l, &s->control_pid);
4273         if (r < 0)
4274                 goto fail;
4275
4276         service_set_state(s, SERVICE_CLEANING);
4277
4278         return 0;
4279
4280 fail:
4281         log_unit_warning_errno(u, r, "Failed to initiate cleaning: %m");
4282         s->clean_result = SERVICE_FAILURE_RESOURCES;
4283         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
4284         return r;
4285 }
4286
4287 static int service_can_clean(Unit *u, ExecCleanMask *ret) {
4288         Service *s = SERVICE(u);
4289
4290         assert(s);
4291
4292         return exec_context_get_clean_mask(&s->exec_context, ret);
4293 }
4294
4295 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
4296         [SERVICE_RESTART_NO] = "no",
4297         [SERVICE_RESTART_ON_SUCCESS] = "on-success",
4298         [SERVICE_RESTART_ON_FAILURE] = "on-failure",
4299         [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
4300         [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
4301         [SERVICE_RESTART_ON_ABORT] = "on-abort",
4302         [SERVICE_RESTART_ALWAYS] = "always",
4303 };
4304
4305 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
4306
4307 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
4308         [SERVICE_SIMPLE] = "simple",
4309         [SERVICE_FORKING] = "forking",
4310         [SERVICE_ONESHOT] = "oneshot",
4311         [SERVICE_DBUS] = "dbus",
4312         [SERVICE_NOTIFY] = "notify",
4313         [SERVICE_IDLE] = "idle",
4314         [SERVICE_EXEC] = "exec",
4315 };
4316
4317 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
4318
4319 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
4320         [SERVICE_EXEC_CONDITION] = "ExecCondition",
4321         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
4322         [SERVICE_EXEC_START] = "ExecStart",
4323         [SERVICE_EXEC_START_POST] = "ExecStartPost",
4324         [SERVICE_EXEC_RELOAD] = "ExecReload",
4325         [SERVICE_EXEC_STOP] = "ExecStop",
4326         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
4327 };
4328
4329 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
4330
4331 static const char* const service_exec_ex_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
4332         [SERVICE_EXEC_CONDITION] = "ExecConditionEx",
4333         [SERVICE_EXEC_START_PRE] = "ExecStartPreEx",
4334         [SERVICE_EXEC_START] = "ExecStartEx",
4335         [SERVICE_EXEC_START_POST] = "ExecStartPostEx",
4336         [SERVICE_EXEC_RELOAD] = "ExecReloadEx",
4337         [SERVICE_EXEC_STOP] = "ExecStopEx",
4338         [SERVICE_EXEC_STOP_POST] = "ExecStopPostEx",
4339 };
4340
4341 DEFINE_STRING_TABLE_LOOKUP(service_exec_ex_command, ServiceExecCommand);
4342
4343 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
4344         [NOTIFY_UNKNOWN] = "unknown",
4345         [NOTIFY_READY] = "ready",
4346         [NOTIFY_RELOADING] = "reloading",
4347         [NOTIFY_STOPPING] = "stopping",
4348 };
4349
4350 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
4351
4352 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
4353         [SERVICE_SUCCESS] = "success",
4354         [SERVICE_FAILURE_RESOURCES] = "resources",
4355         [SERVICE_FAILURE_PROTOCOL] = "protocol",
4356         [SERVICE_FAILURE_TIMEOUT] = "timeout",
4357         [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
4358         [SERVICE_FAILURE_SIGNAL] = "signal",
4359         [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
4360         [SERVICE_FAILURE_WATCHDOG] = "watchdog",
4361         [SERVICE_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
4362         [SERVICE_FAILURE_OOM_KILL] = "oom-kill",
4363         [SERVICE_SKIP_CONDITION] = "exec-condition",
4364 };
4365
4366 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
4367
4368 const UnitVTable service_vtable = {
4369         .object_size = sizeof(Service),
4370         .exec_context_offset = offsetof(Service, exec_context),
4371         .cgroup_context_offset = offsetof(Service, cgroup_context),
4372         .kill_context_offset = offsetof(Service, kill_context),
4373         .exec_runtime_offset = offsetof(Service, exec_runtime),
4374         .dynamic_creds_offset = offsetof(Service, dynamic_creds),
4375
4376         .sections =
4377                 "Unit\0"
4378                 "Service\0"
4379                 "Install\0",
4380         .private_section = "Service",
4381
4382         .can_transient = true,
4383         .can_delegate = true,
4384
4385         .init = service_init,
4386         .done = service_done,
4387         .load = service_load,
4388         .release_resources = service_release_resources,
4389
4390         .coldplug = service_coldplug,
4391
4392         .dump = service_dump,
4393
4394         .start = service_start,
4395         .stop = service_stop,
4396         .reload = service_reload,
4397
4398         .can_reload = service_can_reload,
4399
4400         .kill = service_kill,
4401         .clean = service_clean,
4402         .can_clean = service_can_clean,
4403
4404         .serialize = service_serialize,
4405         .deserialize_item = service_deserialize_item,
4406
4407         .active_state = service_active_state,
4408         .sub_state_to_string = service_sub_state_to_string,
4409
4410         .will_restart = service_will_restart,
4411
4412         .may_gc = service_may_gc,
4413
4414         .sigchld_event = service_sigchld_event,
4415
4416         .reset_failed = service_reset_failed,
4417
4418         .notify_cgroup_empty = service_notify_cgroup_empty_event,
4419         .notify_cgroup_oom = service_notify_cgroup_oom_event,
4420         .notify_message = service_notify_message,
4421
4422         .main_pid = service_main_pid,
4423         .control_pid = service_control_pid,
4424
4425         .bus_name_owner_change = service_bus_name_owner_change,
4426
4427         .bus_vtable = bus_service_vtable,
4428         .bus_set_property = bus_service_set_property,
4429         .bus_commit_properties = bus_service_commit_properties,
4430
4431         .get_timeout = service_get_timeout,
4432         .needs_console = service_needs_console,
4433         .exit_status = service_exit_status,
4434
4435         .status_message_formats = {
4436                 .starting_stopping = {
4437                         [0] = "Starting %s...",
4438                         [1] = "Stopping %s...",
4439                 },
4440                 .finished_start_job = {
4441                         [JOB_DONE]       = "Started %s.",
4442                         [JOB_FAILED]     = "Failed to start %s.",
4443                         [JOB_SKIPPED]    = "Skipped %s.",
4444                 },
4445                 .finished_stop_job = {
4446                         [JOB_DONE]       = "Stopped %s.",
4447                         [JOB_FAILED]     = "Stopped (with error) %s.",
4448                 },
4449         },
4450 };