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