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