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