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