src/core/service.c

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