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