src/core/service.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <signal.h>
  24 #include <dirent.h>
  25 #include <unistd.h>
  26 #include <sys/reboot.h>
  27
  28 #include "manager.h"
  29 #include "unit.h"
  30 #include "service.h"
  31 #include "load-fragment.h"
  32 #include "load-dropin.h"
  33 #include "log.h"
  34 #include "strv.h"
  35 #include "unit-name.h"
  36 #include "unit-printf.h"
  37 #include "dbus-service.h"
  38 #include "special.h"
  39 #include "exit-status.h"
  40 #include "def.h"
  41 #include "path-util.h"
  42 #include "util.h"
  43 #include "utf8.h"
  44 #include "env-util.h"
  45 #include "fileio.h"
  46 #include "bus-error.h"
  47 #include "bus-util.h"
  48
  49 #ifdef HAVE_SYSV_COMPAT
  50
  51 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
  52
  53 typedef enum RunlevelType {
  54         RUNLEVEL_UP,
  55         RUNLEVEL_DOWN
  56 } RunlevelType;
  57
  58 static const struct {
  59         const char *path;
  60         const char *target;
  61         const RunlevelType type;
  62 } rcnd_table[] = {
  63         /* Standard SysV runlevels for start-up */
  64         { "rc1.d",  SPECIAL_RESCUE_TARGET,    RUNLEVEL_UP },
  65         { "rc2.d",  SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
  66         { "rc3.d",  SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
  67         { "rc4.d",  SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
  68         { "rc5.d",  SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
  69
  70         /* Standard SysV runlevels for shutdown */
  71         { "rc0.d",  SPECIAL_POWEROFF_TARGET,  RUNLEVEL_DOWN },
  72         { "rc6.d",  SPECIAL_REBOOT_TARGET,    RUNLEVEL_DOWN }
  73
  74         /* Note that the order here matters, as we read the
  75            directories in this order, and we want to make sure that
  76            sysv_start_priority is known when we first load the
  77            unit. And that value we only know from S links. Hence
  78            UP must be read before DOWN */
  79 };
  80
  81 #define RUNLEVELS_UP "12345"
  82 #endif
  83
  84 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
  85         [SERVICE_DEAD] = UNIT_INACTIVE,
  86         [SERVICE_START_PRE] = UNIT_ACTIVATING,
  87         [SERVICE_START] = UNIT_ACTIVATING,
  88         [SERVICE_START_POST] = UNIT_ACTIVATING,
  89         [SERVICE_RUNNING] = UNIT_ACTIVE,
  90         [SERVICE_EXITED] = UNIT_ACTIVE,
  91         [SERVICE_RELOAD] = UNIT_RELOADING,
  92         [SERVICE_STOP] = UNIT_DEACTIVATING,
  93         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
  94         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
  95         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
  96         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  97         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  98         [SERVICE_FAILED] = UNIT_FAILED,
  99         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
 100 };
 101
 102 /* For Type=idle we never want to delay any other jobs, hence we
 103  * consider idle jobs active as soon as we start working on them */
 104 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
 105         [SERVICE_DEAD] = UNIT_INACTIVE,
 106         [SERVICE_START_PRE] = UNIT_ACTIVE,
 107         [SERVICE_START] = UNIT_ACTIVE,
 108         [SERVICE_START_POST] = UNIT_ACTIVE,
 109         [SERVICE_RUNNING] = UNIT_ACTIVE,
 110         [SERVICE_EXITED] = UNIT_ACTIVE,
 111         [SERVICE_RELOAD] = UNIT_RELOADING,
 112         [SERVICE_STOP] = UNIT_DEACTIVATING,
 113         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
 114         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
 115         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
 116         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
 117         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
 118         [SERVICE_FAILED] = UNIT_FAILED,
 119         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
 120 };
 121
 122 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
 123 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
 124 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
 125
 126 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
 127
 128 static void service_init(Unit *u) {
 129         Service *s = SERVICE(u);
 130
 131         assert(u);
 132         assert(u->load_state == UNIT_STUB);
 133
 134         s->timeout_start_usec = u->manager->default_timeout_start_usec;
 135         s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
 136         s->restart_usec = u->manager->default_restart_usec;
 137         s->type = _SERVICE_TYPE_INVALID;
 138
 139 #ifdef HAVE_SYSV_COMPAT
 140         s->sysv_start_priority = -1;
 141         s->sysv_start_priority_from_rcnd = -1;
 142 #endif
 143         s->socket_fd = -1;
 144         s->guess_main_pid = true;
 145
 146         RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
 147
 148         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
 149 }
 150
 151 static void service_unwatch_control_pid(Service *s) {
 152         assert(s);
 153
 154         if (s->control_pid <= 0)
 155                 return;
 156
 157         unit_unwatch_pid(UNIT(s), s->control_pid);
 158         s->control_pid = 0;
 159 }
 160
 161 static void service_unwatch_main_pid(Service *s) {
 162         assert(s);
 163
 164         if (s->main_pid <= 0)
 165                 return;
 166
 167         unit_unwatch_pid(UNIT(s), s->main_pid);
 168         s->main_pid = 0;
 169 }
 170
 171 static void service_unwatch_pid_file(Service *s) {
 172         if (!s->pid_file_pathspec)
 173                 return;
 174
 175         log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
 176                        UNIT(s)->id, s->pid_file_pathspec->path);
 177         path_spec_unwatch(s->pid_file_pathspec);
 178         path_spec_done(s->pid_file_pathspec);
 179         free(s->pid_file_pathspec);
 180         s->pid_file_pathspec = NULL;
 181 }
 182
 183 static int service_set_main_pid(Service *s, pid_t pid) {
 184         pid_t ppid;
 185
 186         assert(s);
 187
 188         if (pid <= 1)
 189                 return -EINVAL;
 190
 191         if (pid == getpid())
 192                 return -EINVAL;
 193
 194         if (s->main_pid == pid && s->main_pid_known)
 195                 return 0;
 196
 197         if (s->main_pid != pid) {
 198                 service_unwatch_main_pid(s);
 199                 exec_status_start(&s->main_exec_status, pid);
 200         }
 201
 202         s->main_pid = pid;
 203         s->main_pid_known = true;
 204
 205         if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
 206                 log_warning_unit(UNIT(s)->id,
 207                                  "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.",
 208                                  UNIT(s)->id, pid);
 209
 210                 s->main_pid_alien = true;
 211         } else
 212                 s->main_pid_alien = false;
 213
 214         return 0;
 215 }
 216
 217 static void service_close_socket_fd(Service *s) {
 218         assert(s);
 219
 220         if (s->socket_fd < 0)
 221                 return;
 222
 223         s->socket_fd = safe_close(s->socket_fd);
 224 }
 225
 226 static void service_connection_unref(Service *s) {
 227         assert(s);
 228
 229         if (!UNIT_ISSET(s->accept_socket))
 230                 return;
 231
 232         socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
 233         unit_ref_unset(&s->accept_socket);
 234 }
 235
 236 static void service_stop_watchdog(Service *s) {
 237         assert(s);
 238
 239         s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
 240         s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
 241 }
 242
 243 static void service_start_watchdog(Service *s) {
 244         int r;
 245
 246         assert(s);
 247
 248         if (s->watchdog_usec <= 0)
 249                 return;
 250
 251         if (s->watchdog_event_source) {
 252                 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
 253                 if (r < 0) {
 254                         log_warning_unit(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
 255                         return;
 256                 }
 257
 258                 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
 259         } else {
 260                 r = sd_event_add_monotonic(UNIT(s)->manager->event, &s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec, 0, service_dispatch_watchdog, s);
 261                 if (r < 0) {
 262                         log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
 263                         return;
 264                 }
 265
 266                 /* Let's process everything else which might be a sign
 267                  * of living before we consider a service died. */
 268                 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
 269         }
 270
 271         if (r < 0)
 272                 log_warning_unit(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
 273 }
 274
 275 static void service_reset_watchdog(Service *s) {
 276         assert(s);
 277
 278         dual_timestamp_get(&s->watchdog_timestamp);
 279         service_start_watchdog(s);
 280 }
 281
 282 static void service_done(Unit *u) {
 283         Service *s = SERVICE(u);
 284
 285         assert(s);
 286
 287         free(s->pid_file);
 288         s->pid_file = NULL;
 289
 290 #ifdef HAVE_SYSV_COMPAT
 291         free(s->sysv_runlevels);
 292         s->sysv_runlevels = NULL;
 293 #endif
 294
 295         free(s->status_text);
 296         s->status_text = NULL;
 297
 298         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
 299         exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
 300         s->control_command = NULL;
 301         s->main_command = NULL;
 302
 303         set_free(s->restart_ignore_status.code);
 304         s->restart_ignore_status.code = NULL;
 305         set_free(s->restart_ignore_status.signal);
 306         s->restart_ignore_status.signal = NULL;
 307
 308         set_free(s->success_status.code);
 309         s->success_status.code = NULL;
 310         set_free(s->success_status.signal);
 311         s->success_status.signal = NULL;
 312
 313         /* This will leak a process, but at least no memory or any of
 314          * our resources */
 315         service_unwatch_main_pid(s);
 316         service_unwatch_control_pid(s);
 317         service_unwatch_pid_file(s);
 318
 319         if (s->bus_name)  {
 320                 unit_unwatch_bus_name(u, s->bus_name);
 321                 free(s->bus_name);
 322                 s->bus_name = NULL;
 323         }
 324
 325         service_close_socket_fd(s);
 326         service_connection_unref(s);
 327
 328         unit_ref_unset(&s->accept_socket);
 329
 330         service_stop_watchdog(s);
 331
 332         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 333 }
 334
 335 static int service_arm_timer(Service *s, usec_t usec) {
 336         int r;
 337
 338         assert(s);
 339
 340         if (s->timer_event_source) {
 341                 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
 342                 if (r < 0)
 343                         return r;
 344
 345                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 346         }
 347
 348         return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + usec, 0, service_dispatch_timer, s);
 349 }
 350
 351 #ifdef HAVE_SYSV_COMPAT
 352 static char *sysv_translate_name(const char *name) {
 353         char *r;
 354
 355         r = new(char, strlen(name) + strlen(".service") + 1);
 356         if (!r)
 357                 return NULL;
 358
 359         if (endswith(name, ".sh"))
 360                 /* Drop .sh suffix */
 361                 strcpy(stpcpy(r, name) - 3, ".service");
 362         else
 363                 /* Normal init script name */
 364                 strcpy(stpcpy(r, name), ".service");
 365
 366         return r;
 367 }
 368
 369 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
 370
 371         /* We silently ignore the $ prefix here. According to the LSB
 372          * spec it simply indicates whether something is a
 373          * standardized name or a distribution-specific one. Since we
 374          * just follow what already exists and do not introduce new
 375          * uses or names we don't care who introduced a new name. */
 376
 377         static const char * const table[] = {
 378                 /* LSB defined facilities */
 379                 "local_fs",             NULL,
 380                 "network",              SPECIAL_NETWORK_TARGET,
 381                 "named",                SPECIAL_NSS_LOOKUP_TARGET,
 382                 "portmap",              SPECIAL_RPCBIND_TARGET,
 383                 "remote_fs",            SPECIAL_REMOTE_FS_TARGET,
 384                 "syslog",               NULL,
 385                 "time",                 SPECIAL_TIME_SYNC_TARGET,
 386         };
 387
 388         unsigned i;
 389         char *r;
 390         const char *n;
 391
 392         assert(name);
 393         assert(_r);
 394
 395         n = *name == '$' ? name + 1 : name;
 396
 397         for (i = 0; i < ELEMENTSOF(table); i += 2) {
 398
 399                 if (!streq(table[i], n))
 400                         continue;
 401
 402                 if (!table[i+1])
 403                         return 0;
 404
 405                 r = strdup(table[i+1]);
 406                 if (!r)
 407                         return log_oom();
 408
 409                 goto finish;
 410         }
 411
 412         /* If we don't know this name, fallback heuristics to figure
 413          * out whether something is a target or a service alias. */
 414
 415         if (*name == '$') {
 416                 if (!unit_prefix_is_valid(n))
 417                         return -EINVAL;
 418
 419                 /* Facilities starting with $ are most likely targets */
 420                 r = unit_name_build(n, NULL, ".target");
 421         } else if (filename && streq(name, filename))
 422                 /* Names equaling the file name of the services are redundant */
 423                 return 0;
 424         else
 425                 /* Everything else we assume to be normal service names */
 426                 r = sysv_translate_name(n);
 427
 428         if (!r)
 429                 return -ENOMEM;
 430
 431 finish:
 432         *_r = r;
 433
 434         return 1;
 435 }
 436
 437 static int sysv_fix_order(Service *s) {
 438         Unit *other;
 439         int r;
 440
 441         assert(s);
 442
 443         if (s->sysv_start_priority < 0)
 444                 return 0;
 445
 446         /* For each pair of services where at least one lacks a LSB
 447          * header, we use the start priority value to order things. */
 448
 449         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
 450                 Service *t;
 451                 UnitDependency d;
 452                 bool special_s, special_t;
 453
 454                 t = SERVICE(other);
 455
 456                 if (s == t)
 457                         continue;
 458
 459                 if (UNIT(t)->load_state != UNIT_LOADED)
 460                         continue;
 461
 462                 if (t->sysv_start_priority < 0)
 463                         continue;
 464
 465                 /* If both units have modern headers we don't care
 466                  * about the priorities */
 467                 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
 468                     (UNIT(t)->fragment_path || t->sysv_has_lsb))
 469                         continue;
 470
 471                 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
 472                 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
 473
 474                 if (special_t && !special_s)
 475                         d = UNIT_AFTER;
 476                 else if (special_s && !special_t)
 477                         d = UNIT_BEFORE;
 478                 else if (t->sysv_start_priority < s->sysv_start_priority)
 479                         d = UNIT_AFTER;
 480                 else if (t->sysv_start_priority > s->sysv_start_priority)
 481                         d = UNIT_BEFORE;
 482                 else
 483                         continue;
 484
 485                 /* FIXME: Maybe we should compare the name here lexicographically? */
 486
 487                 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
 488                         return r;
 489         }
 490
 491         return 0;
 492 }
 493
 494 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
 495         ExecCommand *c;
 496
 497         if (!(c = new0(ExecCommand, 1)))
 498                 return NULL;
 499
 500         if (!(c->path = strdup(path))) {
 501                 free(c);
 502                 return NULL;
 503         }
 504
 505         if (!(c->argv = strv_new(path, arg1, NULL))) {
 506                 free(c->path);
 507                 free(c);
 508                 return NULL;
 509         }
 510
 511         return c;
 512 }
 513
 514 static int sysv_exec_commands(Service *s, const bool supports_reload) {
 515         ExecCommand *c;
 516
 517         assert(s);
 518         assert(s->is_sysv);
 519         assert(UNIT(s)->source_path);
 520
 521         c = exec_command_new(UNIT(s)->source_path, "start");
 522         if (!c)
 523                 return -ENOMEM;
 524         exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
 525
 526         c = exec_command_new(UNIT(s)->source_path, "stop");
 527         if (!c)
 528                 return -ENOMEM;
 529         exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
 530
 531         if (supports_reload) {
 532                 c = exec_command_new(UNIT(s)->source_path, "reload");
 533                 if (!c)
 534                         return -ENOMEM;
 535                 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
 536         }
 537
 538         return 0;
 539 }
 540
 541 static bool usage_contains_reload(const char *line) {
 542         return (strcasestr(line, "{reload|") ||
 543                 strcasestr(line, "{reload}") ||
 544                 strcasestr(line, "{reload\"") ||
 545                 strcasestr(line, "|reload|") ||
 546                 strcasestr(line, "|reload}") ||
 547                 strcasestr(line, "|reload\""));
 548 }
 549
 550 static int service_load_sysv_path(Service *s, const char *path) {
 551         FILE *f;
 552         Unit *u;
 553         unsigned line = 0;
 554         int r;
 555         enum {
 556                 NORMAL,
 557                 DESCRIPTION,
 558                 LSB,
 559                 LSB_DESCRIPTION,
 560                 USAGE_CONTINUATION
 561         } state = NORMAL;
 562         char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
 563         struct stat st;
 564         bool supports_reload = false;
 565
 566         assert(s);
 567         assert(path);
 568
 569         u = UNIT(s);
 570
 571         f = fopen(path, "re");
 572         if (!f) {
 573                 r = errno == ENOENT ? 0 : -errno;
 574                 goto finish;
 575         }
 576
 577         if (fstat(fileno(f), &st) < 0) {
 578                 r = -errno;
 579                 goto finish;
 580         }
 581
 582         free(u->source_path);
 583         u->source_path = strdup(path);
 584         if (!u->source_path) {
 585                 r = -ENOMEM;
 586                 goto finish;
 587         }
 588         u->source_mtime = timespec_load(&st.st_mtim);
 589
 590         if (null_or_empty(&st)) {
 591                 u->load_state = UNIT_MASKED;
 592                 r = 0;
 593                 goto finish;
 594         }
 595
 596         s->is_sysv = true;
 597
 598         while (!feof(f)) {
 599                 char l[LINE_MAX], *t;
 600
 601                 if (!fgets(l, sizeof(l), f)) {
 602                         if (feof(f))
 603                                 break;
 604
 605                         r = -errno;
 606                         log_error_unit(u->id,
 607                                        "Failed to read configuration file '%s': %s",
 608                                        path, strerror(-r));
 609                         goto finish;
 610                 }
 611
 612                 line++;
 613
 614                 t = strstrip(l);
 615                 if (*t != '#') {
 616                         /* Try to figure out whether this init script supports
 617                          * the reload operation. This heuristic looks for
 618                          * "Usage" lines which include the reload option. */
 619                         if ( state == USAGE_CONTINUATION ||
 620                             (state == NORMAL && strcasestr(t, "usage"))) {
 621                                 if (usage_contains_reload(t)) {
 622                                         supports_reload = true;
 623                                         state = NORMAL;
 624                                 } else if (t[strlen(t)-1] == '\\')
 625                                         state = USAGE_CONTINUATION;
 626                                 else
 627                                         state = NORMAL;
 628                         }
 629
 630                         continue;
 631                 }
 632
 633                 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
 634                         state = LSB;
 635                         s->sysv_has_lsb = true;
 636                         continue;
 637                 }
 638
 639                 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
 640                         state = NORMAL;
 641                         continue;
 642                 }
 643
 644                 t++;
 645                 t += strspn(t, WHITESPACE);
 646
 647                 if (state == NORMAL) {
 648
 649                         /* Try to parse Red Hat style chkconfig headers */
 650
 651                         if (startswith_no_case(t, "chkconfig:")) {
 652                                 int start_priority;
 653                                 char runlevels[16], *k;
 654
 655                                 state = NORMAL;
 656
 657                                 if (sscanf(t+10, "%15s %i %*i",
 658                                            runlevels,
 659                                            &start_priority) != 2) {
 660
 661                                         log_warning_unit(u->id,
 662                                                          "[%s:%u] Failed to parse chkconfig line. Ignoring.",
 663                                                          path, line);
 664                                         continue;
 665                                 }
 666
 667                                 /* A start priority gathered from the
 668                                  * symlink farms is preferred over the
 669                                  * data from the LSB header. */
 670                                 if (start_priority < 0 || start_priority > 99)
 671                                         log_warning_unit(u->id,
 672                                                          "[%s:%u] Start priority out of range. Ignoring.",
 673                                                          path, line);
 674                                 else
 675                                         s->sysv_start_priority = start_priority;
 676
 677                                 char_array_0(runlevels);
 678                                 k = delete_chars(runlevels, WHITESPACE "-");
 679
 680                                 if (k[0]) {
 681                                         char *d;
 682
 683                                         if (!(d = strdup(k))) {
 684                                                 r = -ENOMEM;
 685                                                 goto finish;
 686                                         }
 687
 688                                         free(s->sysv_runlevels);
 689                                         s->sysv_runlevels = d;
 690                                 }
 691
 692                         } else if (startswith_no_case(t, "description:")) {
 693
 694                                 size_t k = strlen(t);
 695                                 char *d;
 696                                 const char *j;
 697
 698                                 if (t[k-1] == '\\') {
 699                                         state = DESCRIPTION;
 700                                         t[k-1] = 0;
 701                                 }
 702
 703                                 if ((j = strstrip(t+12)) && *j) {
 704                                         if (!(d = strdup(j))) {
 705                                                 r = -ENOMEM;
 706                                                 goto finish;
 707                                         }
 708                                 } else
 709                                         d = NULL;
 710
 711                                 free(chkconfig_description);
 712                                 chkconfig_description = d;
 713
 714                         } else if (startswith_no_case(t, "pidfile:")) {
 715
 716                                 char *fn;
 717
 718                                 state = NORMAL;
 719
 720                                 fn = strstrip(t+8);
 721                                 if (!path_is_absolute(fn)) {
 722                                         log_warning_unit(u->id,
 723                                                          "[%s:%u] PID file not absolute. Ignoring.",
 724                                                          path, line);
 725                                         continue;
 726                                 }
 727
 728                                 if (!(fn = strdup(fn))) {
 729                                         r = -ENOMEM;
 730                                         goto finish;
 731                                 }
 732
 733                                 free(s->pid_file);
 734                                 s->pid_file = fn;
 735                         }
 736
 737                 } else if (state == DESCRIPTION) {
 738
 739                         /* Try to parse Red Hat style description
 740                          * continuation */
 741
 742                         size_t k = strlen(t);
 743                         char *j;
 744
 745                         if (t[k-1] == '\\')
 746                                 t[k-1] = 0;
 747                         else
 748                                 state = NORMAL;
 749
 750                         if ((j = strstrip(t)) && *j) {
 751                                 char *d = NULL;
 752
 753                                 if (chkconfig_description)
 754                                         d = strjoin(chkconfig_description, " ", j, NULL);
 755                                 else
 756                                         d = strdup(j);
 757
 758                                 if (!d) {
 759                                         r = -ENOMEM;
 760                                         goto finish;
 761                                 }
 762
 763                                 free(chkconfig_description);
 764                                 chkconfig_description = d;
 765                         }
 766
 767                 } else if (state == LSB || state == LSB_DESCRIPTION) {
 768
 769                         if (startswith_no_case(t, "Provides:")) {
 770                                 char *i, *w;
 771                                 size_t z;
 772
 773                                 state = LSB;
 774
 775                                 FOREACH_WORD_QUOTED(w, z, t+9, i) {
 776                                         char *n, *m;
 777
 778                                         if (!(n = strndup(w, z))) {
 779                                                 r = -ENOMEM;
 780                                                 goto finish;
 781                                         }
 782
 783                                         r = sysv_translate_facility(n, basename(path), &m);
 784                                         free(n);
 785
 786                                         if (r < 0)
 787                                                 goto finish;
 788
 789                                         if (r == 0)
 790                                                 continue;
 791
 792                                         if (unit_name_to_type(m) == UNIT_SERVICE)
 793                                                 r = unit_merge_by_name(u, m);
 794                                         else
 795                                                 /* NB: SysV targets
 796                                                  * which are provided
 797                                                  * by a service are
 798                                                  * pulled in by the
 799                                                  * services, as an
 800                                                  * indication that the
 801                                                  * generic service is
 802                                                  * now available. This
 803                                                  * is strictly
 804                                                  * one-way. The
 805                                                  * targets do NOT pull
 806                                                  * in the SysV
 807                                                  * services! */
 808                                                 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
 809
 810                                         if (r < 0)
 811                                                 log_error_unit(u->id,
 812                                                                "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
 813                                                                path, line, m, strerror(-r));
 814
 815                                         free(m);
 816                                 }
 817
 818                         } else if (startswith_no_case(t, "Required-Start:") ||
 819                                    startswith_no_case(t, "Should-Start:") ||
 820                                    startswith_no_case(t, "X-Start-Before:") ||
 821                                    startswith_no_case(t, "X-Start-After:")) {
 822                                 char *i, *w;
 823                                 size_t z;
 824
 825                                 state = LSB;
 826
 827                                 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
 828                                         char *n, *m;
 829
 830                                         if (!(n = strndup(w, z))) {
 831                                                 r = -ENOMEM;
 832                                                 goto finish;
 833                                         }
 834
 835                                         r = sysv_translate_facility(n, basename(path), &m);
 836                                         if (r < 0) {
 837                                                 log_error_unit(u->id,
 838                                                                "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
 839                                                                path, line, n, strerror(-r));
 840                                                 free(n);
 841                                                 continue;
 842                                         }
 843
 844                                         free(n);
 845
 846                                         if (r == 0)
 847                                                 continue;
 848
 849                                         r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
 850
 851                                         if (r < 0)
 852                                                 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
 853                                                                path, line, m, strerror(-r));
 854
 855                                         free(m);
 856                                 }
 857                         } else if (startswith_no_case(t, "Default-Start:")) {
 858                                 char *k, *d;
 859
 860                                 state = LSB;
 861
 862                                 k = delete_chars(t+14, WHITESPACE "-");
 863
 864                                 if (k[0] != 0) {
 865                                         if (!(d = strdup(k))) {
 866                                                 r = -ENOMEM;
 867                                                 goto finish;
 868                                         }
 869
 870                                         free(s->sysv_runlevels);
 871                                         s->sysv_runlevels = d;
 872                                 }
 873
 874                         } else if (startswith_no_case(t, "Description:")) {
 875                                 char *d, *j;
 876
 877                                 state = LSB_DESCRIPTION;
 878
 879                                 if ((j = strstrip(t+12)) && *j) {
 880                                         if (!(d = strdup(j))) {
 881                                                 r = -ENOMEM;
 882                                                 goto finish;
 883                                         }
 884                                 } else
 885                                         d = NULL;
 886
 887                                 free(long_description);
 888                                 long_description = d;
 889
 890                         } else if (startswith_no_case(t, "Short-Description:")) {
 891                                 char *d, *j;
 892
 893                                 state = LSB;
 894
 895                                 if ((j = strstrip(t+18)) && *j) {
 896                                         if (!(d = strdup(j))) {
 897                                                 r = -ENOMEM;
 898                                                 goto finish;
 899                                         }
 900                                 } else
 901                                         d = NULL;
 902
 903                                 free(short_description);
 904                                 short_description = d;
 905
 906                         } else if (state == LSB_DESCRIPTION) {
 907
 908                                 if (startswith(l, "#\t") || startswith(l, "#  ")) {
 909                                         char *j;
 910
 911                                         if ((j = strstrip(t)) && *j) {
 912                                                 char *d = NULL;
 913
 914                                                 if (long_description)
 915                                                         d = strjoin(long_description, " ", t, NULL);
 916                                                 else
 917                                                         d = strdup(j);
 918
 919                                                 if (!d) {
 920                                                         r = -ENOMEM;
 921                                                         goto finish;
 922                                                 }
 923
 924                                                 free(long_description);
 925                                                 long_description = d;
 926                                         }
 927
 928                                 } else
 929                                         state = LSB;
 930                         }
 931                 }
 932         }
 933
 934         if ((r = sysv_exec_commands(s, supports_reload)) < 0)
 935                 goto finish;
 936
 937         if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
 938                 /* If there a runlevels configured for this service
 939                  * but none of the standard ones, then we assume this
 940                  * is some special kind of service (which might be
 941                  * needed for early boot) and don't create any links
 942                  * to it. */
 943
 944                 UNIT(s)->default_dependencies = false;
 945
 946                 /* Don't timeout special services during boot (like fsck) */
 947                 s->timeout_start_usec = 0;
 948                 s->timeout_stop_usec = 0;
 949         } else {
 950                 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
 951                 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
 952         }
 953
 954         /* Special setting for all SysV services */
 955         s->type = SERVICE_FORKING;
 956         s->remain_after_exit = !s->pid_file;
 957         s->guess_main_pid = false;
 958         s->restart = SERVICE_RESTART_NO;
 959         s->exec_context.ignore_sigpipe = false;
 960         s->kill_context.kill_mode = KILL_PROCESS;
 961
 962         /* We use the long description only if
 963          * no short description is set. */
 964
 965         if (short_description)
 966                 description = short_description;
 967         else if (chkconfig_description)
 968                 description = chkconfig_description;
 969         else if (long_description)
 970                 description = long_description;
 971         else
 972                 description = NULL;
 973
 974         if (description) {
 975                 char *d;
 976
 977                 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
 978                         r = -ENOMEM;
 979                         goto finish;
 980                 }
 981
 982                 u->description = d;
 983         }
 984
 985         /* The priority that has been set in /etc/rcN.d/ hierarchies
 986          * takes precedence over what is stored as default in the LSB
 987          * header */
 988         if (s->sysv_start_priority_from_rcnd >= 0)
 989                 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
 990
 991         u->load_state = UNIT_LOADED;
 992         r = 0;
 993
 994 finish:
 995
 996         if (f)
 997                 fclose(f);
 998
 999         free(short_description);
1000         free(long_description);
1001         free(chkconfig_description);
1002
1003         return r;
1004 }
1005
1006 static int service_load_sysv_name(Service *s, const char *name) {
1007         char **p;
1008
1009         assert(s);
1010         assert(name);
1011
1012         /* For SysV services we strip the *.sh suffixes. */
1013         if (endswith(name, ".sh.service"))
1014                 return -ENOENT;
1015
1016         STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
1017                 char *path;
1018                 int r;
1019
1020                 path = strjoin(*p, "/", name, NULL);
1021                 if (!path)
1022                         return -ENOMEM;
1023
1024                 assert(endswith(path, ".service"));
1025                 path[strlen(path)-8] = 0;
1026
1027                 r = service_load_sysv_path(s, path);
1028
1029                 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1030                         /* Try *.sh source'able init scripts */
1031                         strcat(path, ".sh");
1032                         r = service_load_sysv_path(s, path);
1033                 }
1034                 free(path);
1035
1036                 if (r < 0)
1037                         return r;
1038
1039                 if (UNIT(s)->load_state != UNIT_STUB)
1040                         break;
1041         }
1042
1043         return 0;
1044 }
1045
1046 static int service_load_sysv(Service *s) {
1047         const char *t;
1048         Iterator i;
1049         int r;
1050
1051         assert(s);
1052
1053         /* Load service data from SysV init scripts, preferably with
1054          * LSB headers ... */
1055
1056         if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1057                 return 0;
1058
1059         if ((t = UNIT(s)->id))
1060                 if ((r = service_load_sysv_name(s, t)) < 0)
1061                         return r;
1062
1063         if (UNIT(s)->load_state == UNIT_STUB)
1064                 SET_FOREACH(t, UNIT(s)->names, i) {
1065                         if (t == UNIT(s)->id)
1066                                 continue;
1067
1068                         if ((r = service_load_sysv_name(s, t)) < 0)
1069                                 return r;
1070
1071                         if (UNIT(s)->load_state != UNIT_STUB)
1072                                 break;
1073                 }
1074
1075         return 0;
1076 }
1077 #endif
1078
1079 static int service_verify(Service *s) {
1080         assert(s);
1081
1082         if (UNIT(s)->load_state != UNIT_LOADED)
1083                 return 0;
1084
1085         if (!s->exec_command[SERVICE_EXEC_START]) {
1086                 log_error_unit(UNIT(s)->id, "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1087                 return -EINVAL;
1088         }
1089
1090         if (s->type != SERVICE_ONESHOT &&
1091             s->exec_command[SERVICE_EXEC_START]->command_next) {
1092                 log_error_unit(UNIT(s)->id, "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1093                 return -EINVAL;
1094         }
1095
1096         if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1097                 log_error_unit(UNIT(s)->id, "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1098                 return -EINVAL;
1099         }
1100
1101         if (s->type == SERVICE_DBUS && !s->bus_name) {
1102                 log_error_unit(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1103                 return -EINVAL;
1104         }
1105
1106         if (s->bus_name && s->type != SERVICE_DBUS)
1107                 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1108
1109         if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
1110                 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
1111                 return -EINVAL;
1112         }
1113
1114         return 0;
1115 }
1116
1117 static int service_add_default_dependencies(Service *s) {
1118         int r;
1119
1120         assert(s);
1121
1122         /* Add a number of automatic dependencies useful for the
1123          * majority of services. */
1124
1125         /* First, pull in base system */
1126         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1127                                               SPECIAL_BASIC_TARGET, NULL, true);
1128         if (r < 0)
1129                 return r;
1130
1131         /* Second, activate normal shutdown */
1132         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1133                                               SPECIAL_SHUTDOWN_TARGET, NULL, true);
1134         return r;
1135 }
1136
1137 static void service_fix_output(Service *s) {
1138         assert(s);
1139
1140         /* If nothing has been explicitly configured, patch default
1141          * output in. If input is socket/tty we avoid this however,
1142          * since in that case we want output to default to the same
1143          * place as we read input from. */
1144
1145         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1146             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1147             s->exec_context.std_input == EXEC_INPUT_NULL)
1148                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1149
1150         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1151             s->exec_context.std_input == EXEC_INPUT_NULL)
1152                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1153 }
1154
1155 static int service_load(Unit *u) {
1156         int r;
1157         Service *s = SERVICE(u);
1158
1159         assert(s);
1160
1161         /* Load a .service file */
1162         r = unit_load_fragment(u);
1163         if (r < 0)
1164                 return r;
1165
1166 #ifdef HAVE_SYSV_COMPAT
1167         /* Load a classic init script as a fallback, if we couldn't find anything */
1168         if (u->load_state == UNIT_STUB) {
1169                 r = service_load_sysv(s);
1170                 if (r < 0)
1171                         return r;
1172         }
1173 #endif
1174
1175         /* Still nothing found? Then let's give up */
1176         if (u->load_state == UNIT_STUB)
1177                 return -ENOENT;
1178
1179         /* This is a new unit? Then let's add in some extras */
1180         if (u->load_state == UNIT_LOADED) {
1181
1182                 /* We were able to load something, then let's add in
1183                  * the dropin directories. */
1184                 r = unit_load_dropin(u);
1185                 if (r < 0)
1186                         return r;
1187
1188                 if (s->type == _SERVICE_TYPE_INVALID)
1189                         s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1190
1191                 /* Oneshot services have disabled start timeout by default */
1192                 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1193                         s->timeout_start_usec = 0;
1194
1195                 service_fix_output(s);
1196
1197                 r = unit_patch_contexts(u);
1198                 if (r < 0)
1199                         return r;
1200
1201                 r = unit_add_exec_dependencies(u, &s->exec_context);
1202                 if (r < 0)
1203                         return r;
1204
1205                 r = unit_add_default_slice(u, &s->cgroup_context);
1206                 if (r < 0)
1207                         return r;
1208
1209 #ifdef HAVE_SYSV_COMPAT
1210                 r = sysv_fix_order(s);
1211                 if (r < 0)
1212                         return r;
1213 #endif
1214
1215                 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1216                         s->notify_access = NOTIFY_MAIN;
1217
1218                 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1219                         s->notify_access = NOTIFY_MAIN;
1220
1221                 if (s->bus_name) {
1222                         r = unit_watch_bus_name(u, s->bus_name);
1223                         if (r < 0)
1224                                 return r;
1225                 }
1226
1227                 if (u->default_dependencies) {
1228                         r = service_add_default_dependencies(s);
1229                         if (r < 0)
1230                                 return r;
1231                 }
1232         }
1233
1234         return service_verify(s);
1235 }
1236
1237 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1238
1239         ServiceExecCommand c;
1240         Service *s = SERVICE(u);
1241         const char *prefix2;
1242         _cleanup_free_ char *p2 = NULL;
1243
1244         assert(s);
1245
1246         p2 = strappend(prefix, "\t");
1247         prefix2 = p2 ? p2 : prefix;
1248
1249         fprintf(f,
1250                 "%sService State: %s\n"
1251                 "%sResult: %s\n"
1252                 "%sReload Result: %s\n"
1253                 "%sPermissionsStartOnly: %s\n"
1254                 "%sRootDirectoryStartOnly: %s\n"
1255                 "%sRemainAfterExit: %s\n"
1256                 "%sGuessMainPID: %s\n"
1257                 "%sType: %s\n"
1258                 "%sRestart: %s\n"
1259                 "%sNotifyAccess: %s\n",
1260                 prefix, service_state_to_string(s->state),
1261                 prefix, service_result_to_string(s->result),
1262                 prefix, service_result_to_string(s->reload_result),
1263                 prefix, yes_no(s->permissions_start_only),
1264                 prefix, yes_no(s->root_directory_start_only),
1265                 prefix, yes_no(s->remain_after_exit),
1266                 prefix, yes_no(s->guess_main_pid),
1267                 prefix, service_type_to_string(s->type),
1268                 prefix, service_restart_to_string(s->restart),
1269                 prefix, notify_access_to_string(s->notify_access));
1270
1271         if (s->control_pid > 0)
1272                 fprintf(f,
1273                         "%sControl PID: "PID_FMT"\n",
1274                         prefix, s->control_pid);
1275
1276         if (s->main_pid > 0)
1277                 fprintf(f,
1278                         "%sMain PID: "PID_FMT"\n"
1279                         "%sMain PID Known: %s\n"
1280                         "%sMain PID Alien: %s\n",
1281                         prefix, s->main_pid,
1282                         prefix, yes_no(s->main_pid_known),
1283                         prefix, yes_no(s->main_pid_alien));
1284
1285         if (s->pid_file)
1286                 fprintf(f,
1287                         "%sPIDFile: %s\n",
1288                         prefix, s->pid_file);
1289
1290         if (s->bus_name)
1291                 fprintf(f,
1292                         "%sBusName: %s\n"
1293                         "%sBus Name Good: %s\n",
1294                         prefix, s->bus_name,
1295                         prefix, yes_no(s->bus_name_good));
1296
1297         kill_context_dump(&s->kill_context, f, prefix);
1298         exec_context_dump(&s->exec_context, f, prefix);
1299
1300         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1301
1302                 if (!s->exec_command[c])
1303                         continue;
1304
1305                 fprintf(f, "%s-> %s:\n",
1306                         prefix, service_exec_command_to_string(c));
1307
1308                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1309         }
1310
1311 #ifdef HAVE_SYSV_COMPAT
1312         if (s->is_sysv)
1313                 fprintf(f,
1314                         "%sSysV Init Script has LSB Header: %s\n"
1315                         "%sSysVEnabled: %s\n",
1316                         prefix, yes_no(s->sysv_has_lsb),
1317                         prefix, yes_no(s->sysv_enabled));
1318
1319         if (s->sysv_start_priority >= 0)
1320                 fprintf(f,
1321                         "%sSysVStartPriority: %i\n",
1322                         prefix, s->sysv_start_priority);
1323
1324         if (s->sysv_runlevels)
1325                 fprintf(f, "%sSysVRunLevels: %s\n",
1326                         prefix, s->sysv_runlevels);
1327 #endif
1328
1329         if (s->status_text)
1330                 fprintf(f, "%sStatus Text: %s\n",
1331                         prefix, s->status_text);
1332 }
1333
1334 static int service_load_pid_file(Service *s, bool may_warn) {
1335         _cleanup_free_ char *k = NULL;
1336         int r;
1337         pid_t pid;
1338
1339         assert(s);
1340
1341         if (!s->pid_file)
1342                 return -ENOENT;
1343
1344         r = read_one_line_file(s->pid_file, &k);
1345         if (r < 0) {
1346                 if (may_warn)
1347                         log_info_unit(UNIT(s)->id,
1348                                       "PID file %s not readable (yet?) after %s.",
1349                                       s->pid_file, service_state_to_string(s->state));
1350                 return r;
1351         }
1352
1353         r = parse_pid(k, &pid);
1354         if (r < 0) {
1355                 if (may_warn)
1356                         log_info_unit(UNIT(s)->id,
1357                                       "Failed to read PID from file %s: %s",
1358                                       s->pid_file, strerror(-r));
1359                 return r;
1360         }
1361
1362         if (!pid_is_alive(pid)) {
1363                 if (may_warn)
1364                         log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
1365
1366                 return -ESRCH;
1367         }
1368
1369         if (s->main_pid_known) {
1370                 if (pid == s->main_pid)
1371                         return 0;
1372
1373                 log_debug_unit(UNIT(s)->id,
1374                                "Main PID changing: "PID_FMT" -> "PID_FMT,
1375                                s->main_pid, pid);
1376                 service_unwatch_main_pid(s);
1377                 s->main_pid_known = false;
1378         } else
1379                 log_debug_unit(UNIT(s)->id,
1380                                "Main PID loaded: "PID_FMT, pid);
1381
1382         r = service_set_main_pid(s, pid);
1383         if (r < 0)
1384                 return r;
1385
1386         r = unit_watch_pid(UNIT(s), pid);
1387         if (r < 0) {
1388                 /* FIXME: we need to do something here */
1389                 log_warning_unit(UNIT(s)->id,
1390                                  "Failed to watch PID "PID_FMT" from service %s",
1391                                  pid, UNIT(s)->id);
1392                 return r;
1393         }
1394
1395         return 0;
1396 }
1397
1398 static int service_search_main_pid(Service *s) {
1399         pid_t pid;
1400         int r;
1401
1402         assert(s);
1403
1404         /* If we know it anyway, don't ever fallback to unreliable
1405          * heuristics */
1406         if (s->main_pid_known)
1407                 return 0;
1408
1409         if (!s->guess_main_pid)
1410                 return 0;
1411
1412         assert(s->main_pid <= 0);
1413
1414         pid = unit_search_main_pid(UNIT(s));
1415         if (pid <= 0)
1416                 return -ENOENT;
1417
1418         log_debug_unit(UNIT(s)->id,
1419                        "Main PID guessed: "PID_FMT, pid);
1420         r = service_set_main_pid(s, pid);
1421         if (r < 0)
1422                 return r;
1423
1424         r = unit_watch_pid(UNIT(s), pid);
1425         if (r < 0)
1426                 /* FIXME: we need to do something here */
1427                 log_warning_unit(UNIT(s)->id,
1428                                  "Failed to watch PID "PID_FMT" from service %s",
1429                                  pid, UNIT(s)->id);
1430         return r;
1431 }
1432
1433 static void service_set_state(Service *s, ServiceState state) {
1434         ServiceState old_state;
1435         const UnitActiveState *table;
1436
1437         assert(s);
1438
1439         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1440
1441         old_state = s->state;
1442         s->state = state;
1443
1444         service_unwatch_pid_file(s);
1445
1446         if (!IN_SET(state,
1447                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1448                     SERVICE_RELOAD,
1449                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1450                     SERVICE_STOP_POST,
1451                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1452                     SERVICE_AUTO_RESTART))
1453                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1454
1455         if (!IN_SET(state,
1456                     SERVICE_START, SERVICE_START_POST,
1457                     SERVICE_RUNNING, SERVICE_RELOAD,
1458                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1459                     SERVICE_STOP_POST,
1460                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1461                 service_unwatch_main_pid(s);
1462                 s->main_command = NULL;
1463         }
1464
1465         if (!IN_SET(state,
1466                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1467                     SERVICE_RELOAD,
1468                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1469                     SERVICE_STOP_POST,
1470                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1471                 service_unwatch_control_pid(s);
1472                 s->control_command = NULL;
1473                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1474         }
1475
1476         if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1477                 unit_unwatch_all_pids(UNIT(s));
1478
1479         if (!IN_SET(state,
1480                     SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1481                     SERVICE_RUNNING, SERVICE_RELOAD,
1482                     SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1483                     SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1484             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1485                 service_close_socket_fd(s);
1486                 service_connection_unref(s);
1487         }
1488
1489         if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1490                 service_stop_watchdog(s);
1491
1492         /* For the inactive states unit_notify() will trim the cgroup,
1493          * but for exit we have to do that ourselves... */
1494         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1495                 unit_destroy_cgroup(UNIT(s));
1496
1497         /* For remain_after_exit services, let's see if we can "release" the
1498          * hold on the console, since unit_notify() only does that in case of
1499          * change of state */
1500         if (state == SERVICE_EXITED && s->remain_after_exit &&
1501             UNIT(s)->manager->n_on_console > 0) {
1502                 ExecContext *ec = unit_get_exec_context(UNIT(s));
1503                 if (ec && exec_context_may_touch_console(ec)) {
1504                         Manager *m = UNIT(s)->manager;
1505
1506                         m->n_on_console --;
1507                         if (m->n_on_console == 0)
1508                                 /* unset no_console_output flag, since the console is free */
1509                                 m->no_console_output = false;
1510                 }
1511         }
1512
1513         if (old_state != state)
1514                 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1515
1516         unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1517         s->reload_result = SERVICE_SUCCESS;
1518 }
1519
1520 static int service_coldplug(Unit *u) {
1521         Service *s = SERVICE(u);
1522         int r;
1523
1524         assert(s);
1525         assert(s->state == SERVICE_DEAD);
1526
1527         if (s->deserialized_state != s->state) {
1528
1529                 if (IN_SET(s->deserialized_state,
1530                            SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1531                            SERVICE_RELOAD,
1532                            SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1533                            SERVICE_STOP_POST,
1534                            SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1535
1536                         usec_t k;
1537
1538                         k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
1539
1540                         /* For the start/stop timeouts 0 means off */
1541                         if (k > 0) {
1542                                 r = service_arm_timer(s, k);
1543                                 if (r < 0)
1544                                         return r;
1545                         }
1546                 }
1547
1548                 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
1549
1550                         /* The restart timeouts 0 means immediately */
1551                         r = service_arm_timer(s, s->restart_usec);
1552                         if (r < 0)
1553                                 return r;
1554                 }
1555
1556                 if (pid_is_unwaited(s->main_pid) &&
1557                     ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
1558                      IN_SET(s->deserialized_state,
1559                             SERVICE_START, SERVICE_START_POST,
1560                             SERVICE_RUNNING, SERVICE_RELOAD,
1561                             SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1562                             SERVICE_STOP_POST,
1563                             SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1564                         r = unit_watch_pid(UNIT(s), s->main_pid);
1565                         if (r < 0)
1566                                 return r;
1567                 }
1568
1569                 if (pid_is_unwaited(s->control_pid) &&
1570                     IN_SET(s->deserialized_state,
1571                            SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1572                            SERVICE_RELOAD,
1573                            SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1574                            SERVICE_STOP_POST,
1575                            SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1576                         r = unit_watch_pid(UNIT(s), s->control_pid);
1577                         if (r < 0)
1578                                 return r;
1579                 }
1580
1581                 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1582                         unit_watch_all_pids(UNIT(s));
1583
1584                 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1585                         service_start_watchdog(s);
1586
1587                 service_set_state(s, s->deserialized_state);
1588         }
1589
1590         return 0;
1591 }
1592
1593 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1594         Iterator i;
1595         int r;
1596         int *rfds = NULL;
1597         unsigned rn_fds = 0;
1598         Unit *u;
1599
1600         assert(s);
1601         assert(fds);
1602         assert(n_fds);
1603
1604         if (s->socket_fd >= 0)
1605                 return 0;
1606
1607         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1608                 int *cfds;
1609                 unsigned cn_fds;
1610                 Socket *sock;
1611
1612                 if (u->type != UNIT_SOCKET)
1613                         continue;
1614
1615                 sock = SOCKET(u);
1616
1617                 r = socket_collect_fds(sock, &cfds, &cn_fds);
1618                 if (r < 0)
1619                         goto fail;
1620
1621                 if (!cfds)
1622                         continue;
1623
1624                 if (!rfds) {
1625                         rfds = cfds;
1626                         rn_fds = cn_fds;
1627                 } else {
1628                         int *t;
1629
1630                         t = new(int, rn_fds+cn_fds);
1631                         if (!t) {
1632                                 free(cfds);
1633                                 r = -ENOMEM;
1634                                 goto fail;
1635                         }
1636
1637                         memcpy(t, rfds, rn_fds * sizeof(int));
1638                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1639                         free(rfds);
1640                         free(cfds);
1641
1642                         rfds = t;
1643                         rn_fds = rn_fds+cn_fds;
1644                 }
1645         }
1646
1647         *fds = rfds;
1648         *n_fds = rn_fds;
1649
1650         return 0;
1651
1652 fail:
1653         free(rfds);
1654
1655         return r;
1656 }
1657
1658 static int service_spawn(
1659                 Service *s,
1660                 ExecCommand *c,
1661                 bool timeout,
1662                 bool pass_fds,
1663                 bool apply_permissions,
1664                 bool apply_chroot,
1665                 bool apply_tty_stdin,
1666                 bool set_notify_socket,
1667                 bool is_control,
1668                 pid_t *_pid) {
1669
1670         pid_t pid;
1671         int r;
1672         int *fds = NULL;
1673         _cleanup_free_ int *fdsbuf = NULL;
1674         unsigned n_fds = 0, n_env = 0;
1675         _cleanup_strv_free_ char
1676                 **argv = NULL, **final_env = NULL, **our_env = NULL;
1677         const char *path;
1678
1679         assert(s);
1680         assert(c);
1681         assert(_pid);
1682
1683         unit_realize_cgroup(UNIT(s));
1684
1685         r = unit_setup_exec_runtime(UNIT(s));
1686         if (r < 0)
1687                 goto fail;
1688
1689         if (pass_fds ||
1690             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1691             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1692             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1693
1694                 if (s->socket_fd >= 0) {
1695                         fds = &s->socket_fd;
1696                         n_fds = 1;
1697                 } else {
1698                         r = service_collect_fds(s, &fdsbuf, &n_fds);
1699                         if (r < 0)
1700                                 goto fail;
1701
1702                         fds = fdsbuf;
1703                 }
1704         }
1705
1706         if (timeout && s->timeout_start_usec > 0) {
1707                 r = service_arm_timer(s, s->timeout_start_usec);
1708                 if (r < 0)
1709                         goto fail;
1710         } else
1711                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1712
1713         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1714         if (r < 0)
1715                 goto fail;
1716
1717         our_env = new0(char*, 4);
1718         if (!our_env) {
1719                 r = -ENOMEM;
1720                 goto fail;
1721         }
1722
1723         if (set_notify_socket)
1724                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1725                         r = -ENOMEM;
1726                         goto fail;
1727                 }
1728
1729         if (s->main_pid > 0)
1730                 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1731                         r = -ENOMEM;
1732                         goto fail;
1733                 }
1734
1735         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1736                 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1737                         r = -ENOMEM;
1738                         goto fail;
1739                 }
1740
1741         final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1742         if (!final_env) {
1743                 r = -ENOMEM;
1744                 goto fail;
1745         }
1746
1747         if (is_control && UNIT(s)->cgroup_path) {
1748                 path = strappenda(UNIT(s)->cgroup_path, "/control");
1749                 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1750         } else
1751                 path = UNIT(s)->cgroup_path;
1752
1753         r = exec_spawn(c,
1754                        argv,
1755                        &s->exec_context,
1756                        fds, n_fds,
1757                        final_env,
1758                        apply_permissions,
1759                        apply_chroot,
1760                        apply_tty_stdin,
1761                        UNIT(s)->manager->confirm_spawn,
1762                        UNIT(s)->manager->cgroup_supported,
1763                        path,
1764                        manager_get_runtime_prefix(UNIT(s)->manager),
1765                        UNIT(s)->id,
1766                        s->watchdog_usec,
1767                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1768                        s->exec_runtime,
1769                        &pid);
1770         if (r < 0)
1771                 goto fail;
1772
1773         r = unit_watch_pid(UNIT(s), pid);
1774         if (r < 0)
1775                 /* FIXME: we need to do something here */
1776                 goto fail;
1777
1778         *_pid = pid;
1779
1780         return 0;
1781
1782 fail:
1783         if (timeout)
1784                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1785
1786         return r;
1787 }
1788
1789 static int main_pid_good(Service *s) {
1790         assert(s);
1791
1792         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1793          * don't know */
1794
1795         /* If we know the pid file, then lets just check if it is
1796          * still valid */
1797         if (s->main_pid_known) {
1798
1799                 /* If it's an alien child let's check if it is still
1800                  * alive ... */
1801                 if (s->main_pid_alien && s->main_pid > 0)
1802                         return pid_is_alive(s->main_pid);
1803
1804                 /* .. otherwise assume we'll get a SIGCHLD for it,
1805                  * which we really should wait for to collect exit
1806                  * status and code */
1807                 return s->main_pid > 0;
1808         }
1809
1810         /* We don't know the pid */
1811         return -EAGAIN;
1812 }
1813
1814 _pure_ static int control_pid_good(Service *s) {
1815         assert(s);
1816
1817         return s->control_pid > 0;
1818 }
1819
1820 static int cgroup_good(Service *s) {
1821         int r;
1822
1823         assert(s);
1824
1825         if (!UNIT(s)->cgroup_path)
1826                 return 0;
1827
1828         r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1829         if (r < 0)
1830                 return r;
1831
1832         return !r;
1833 }
1834
1835 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1836         int r;
1837         assert(s);
1838
1839         if (f != SERVICE_SUCCESS)
1840                 s->result = f;
1841
1842         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1843
1844         if (allow_restart &&
1845             !s->forbid_restart &&
1846             (s->restart == SERVICE_RESTART_ALWAYS ||
1847              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1848              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1849              (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1850              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1851                                                          s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1852             (s->result != SERVICE_FAILURE_EXIT_CODE ||
1853              !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1854             (s->result != SERVICE_FAILURE_SIGNAL ||
1855              !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1856
1857                 r = service_arm_timer(s, s->restart_usec);
1858                 if (r < 0)
1859                         goto fail;
1860
1861                 service_set_state(s, SERVICE_AUTO_RESTART);
1862         }
1863
1864         s->forbid_restart = false;
1865
1866         /* We want fresh tmpdirs in case service is started again immediately */
1867         exec_runtime_destroy(s->exec_runtime);
1868         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1869
1870         /* Also, remove the runtime directory in */
1871         exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1872
1873         /* Try to delete the pid file. At this point it will be
1874          * out-of-date, and some software might be confused by it, so
1875          * let's remove it. */
1876         if (s->pid_file)
1877                 unlink_noerrno(s->pid_file);
1878
1879         return;
1880
1881 fail:
1882         log_warning_unit(UNIT(s)->id,
1883                          "%s failed to run install restart timer: %s",
1884                          UNIT(s)->id, strerror(-r));
1885         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1886 }
1887
1888 static void service_enter_stop_post(Service *s, ServiceResult f) {
1889         int r;
1890         assert(s);
1891
1892         if (f != SERVICE_SUCCESS)
1893                 s->result = f;
1894
1895         service_unwatch_control_pid(s);
1896         unit_watch_all_pids(UNIT(s));
1897
1898         s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1899         if (s->control_command) {
1900                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1901
1902                 r = service_spawn(s,
1903                                   s->control_command,
1904                                   true,
1905                                   false,
1906                                   !s->permissions_start_only,
1907                                   !s->root_directory_start_only,
1908                                   true,
1909                                   false,
1910                                   true,
1911                                   &s->control_pid);
1912                 if (r < 0)
1913                         goto fail;
1914
1915                 service_set_state(s, SERVICE_STOP_POST);
1916         } else
1917                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1918
1919         return;
1920
1921 fail:
1922         log_warning_unit(UNIT(s)->id,
1923                          "%s failed to run 'stop-post' task: %s",
1924                          UNIT(s)->id, strerror(-r));
1925         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1926 }
1927
1928 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1929         int r;
1930
1931         assert(s);
1932
1933         if (f != SERVICE_SUCCESS)
1934                 s->result = f;
1935
1936         unit_watch_all_pids(UNIT(s));
1937
1938         r = unit_kill_context(
1939                         UNIT(s),
1940                         &s->kill_context,
1941                         state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1942                         s->main_pid,
1943                         s->control_pid,
1944                         s->main_pid_alien);
1945
1946         if (r < 0)
1947                 goto fail;
1948
1949         if (r > 0) {
1950                 if (s->timeout_stop_usec > 0) {
1951                         r = service_arm_timer(s, s->timeout_stop_usec);
1952                         if (r < 0)
1953                                 goto fail;
1954                 }
1955
1956                 service_set_state(s, state);
1957         } else if (state == SERVICE_STOP_SIGTERM)
1958                 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1959         else if (state == SERVICE_STOP_SIGKILL)
1960                 service_enter_stop_post(s, SERVICE_SUCCESS);
1961         else if (state == SERVICE_FINAL_SIGTERM)
1962                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1963         else
1964                 service_enter_dead(s, SERVICE_SUCCESS, true);
1965
1966         return;
1967
1968 fail:
1969         log_warning_unit(UNIT(s)->id,
1970                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1971
1972         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1973                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1974         else
1975                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1976 }
1977
1978 static void service_enter_stop(Service *s, ServiceResult f) {
1979         int r;
1980
1981         assert(s);
1982
1983         if (f != SERVICE_SUCCESS)
1984                 s->result = f;
1985
1986         service_unwatch_control_pid(s);
1987         unit_watch_all_pids(UNIT(s));
1988
1989         s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1990         if (s->control_command) {
1991                 s->control_command_id = SERVICE_EXEC_STOP;
1992
1993                 r = service_spawn(s,
1994                                   s->control_command,
1995                                   true,
1996                                   false,
1997                                   !s->permissions_start_only,
1998                                   !s->root_directory_start_only,
1999                                   false,
2000                                   false,
2001                                   true,
2002                                   &s->control_pid);
2003                 if (r < 0)
2004                         goto fail;
2005
2006                 service_set_state(s, SERVICE_STOP);
2007         } else
2008                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2009
2010         return;
2011
2012 fail:
2013         log_warning_unit(UNIT(s)->id,
2014                          "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2015         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2016 }
2017
2018 static void service_enter_running(Service *s, ServiceResult f) {
2019         int main_pid_ok, cgroup_ok;
2020         assert(s);
2021
2022         if (f != SERVICE_SUCCESS)
2023                 s->result = f;
2024
2025         main_pid_ok = main_pid_good(s);
2026         cgroup_ok = cgroup_good(s);
2027
2028         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2029             (s->bus_name_good || s->type != SERVICE_DBUS))
2030                 service_set_state(s, SERVICE_RUNNING);
2031         else if (s->remain_after_exit)
2032                 service_set_state(s, SERVICE_EXITED);
2033         else
2034                 service_enter_stop(s, SERVICE_SUCCESS);
2035 }
2036
2037 static void service_enter_start_post(Service *s) {
2038         int r;
2039         assert(s);
2040
2041         service_unwatch_control_pid(s);
2042         service_reset_watchdog(s);
2043
2044         s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2045         if (s->control_command) {
2046                 s->control_command_id = SERVICE_EXEC_START_POST;
2047
2048                 r = service_spawn(s,
2049                                   s->control_command,
2050                                   true,
2051                                   false,
2052                                   !s->permissions_start_only,
2053                                   !s->root_directory_start_only,
2054                                   false,
2055                                   false,
2056                                   true,
2057                                   &s->control_pid);
2058                 if (r < 0)
2059                         goto fail;
2060
2061                 service_set_state(s, SERVICE_START_POST);
2062         } else
2063                 service_enter_running(s, SERVICE_SUCCESS);
2064
2065         return;
2066
2067 fail:
2068         log_warning_unit(UNIT(s)->id,
2069                          "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2070         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2071 }
2072
2073 static void service_kill_control_processes(Service *s) {
2074         char *p;
2075
2076         if (!UNIT(s)->cgroup_path)
2077                 return;
2078
2079         p = strappenda(UNIT(s)->cgroup_path, "/control");
2080         cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2081 }
2082
2083 static void service_enter_start(Service *s) {
2084         ExecCommand *c;
2085         pid_t pid;
2086         int r;
2087
2088         assert(s);
2089
2090         assert(s->exec_command[SERVICE_EXEC_START]);
2091         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2092
2093         service_unwatch_control_pid(s);
2094         service_unwatch_main_pid(s);
2095
2096         /* We want to ensure that nobody leaks processes from
2097          * START_PRE here, so let's go on a killing spree, People
2098          * should not spawn long running processes from START_PRE. */
2099         service_kill_control_processes(s);
2100
2101         if (s->type == SERVICE_FORKING) {
2102                 s->control_command_id = SERVICE_EXEC_START;
2103                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2104
2105                 s->main_command = NULL;
2106         } else {
2107                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2108                 s->control_command = NULL;
2109
2110                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2111         }
2112
2113         r = service_spawn(s,
2114                           c,
2115                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2116                             s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2117                           true,
2118                           true,
2119                           true,
2120                           true,
2121                           s->notify_access != NOTIFY_NONE,
2122                           false,
2123                           &pid);
2124         if (r < 0)
2125                 goto fail;
2126
2127         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2128                 /* For simple services we immediately start
2129                  * the START_POST binaries. */
2130
2131                 service_set_main_pid(s, pid);
2132                 service_enter_start_post(s);
2133
2134         } else  if (s->type == SERVICE_FORKING) {
2135
2136                 /* For forking services we wait until the start
2137                  * process exited. */
2138
2139                 s->control_pid = pid;
2140                 service_set_state(s, SERVICE_START);
2141
2142         } else if (s->type == SERVICE_ONESHOT ||
2143                    s->type == SERVICE_DBUS ||
2144                    s->type == SERVICE_NOTIFY) {
2145
2146                 /* For oneshot services we wait until the start
2147                  * process exited, too, but it is our main process. */
2148
2149                 /* For D-Bus services we know the main pid right away,
2150                  * but wait for the bus name to appear on the
2151                  * bus. Notify services are similar. */
2152
2153                 service_set_main_pid(s, pid);
2154                 service_set_state(s, SERVICE_START);
2155         } else
2156                 assert_not_reached("Unknown service type");
2157
2158         return;
2159
2160 fail:
2161         log_warning_unit(UNIT(s)->id,
2162                          "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2163         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2164 }
2165
2166 static void service_enter_start_pre(Service *s) {
2167         int r;
2168
2169         assert(s);
2170
2171         service_unwatch_control_pid(s);
2172
2173         s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2174         if (s->control_command) {
2175                 /* Before we start anything, let's clear up what might
2176                  * be left from previous runs. */
2177                 service_kill_control_processes(s);
2178
2179                 s->control_command_id = SERVICE_EXEC_START_PRE;
2180
2181                 r = service_spawn(s,
2182                                   s->control_command,
2183                                   true,
2184                                   false,
2185                                   !s->permissions_start_only,
2186                                   !s->root_directory_start_only,
2187                                   true,
2188                                   false,
2189                                   true,
2190                                   &s->control_pid);
2191                 if (r < 0)
2192                         goto fail;
2193
2194                 service_set_state(s, SERVICE_START_PRE);
2195         } else
2196                 service_enter_start(s);
2197
2198         return;
2199
2200 fail:
2201         log_warning_unit(UNIT(s)->id,
2202                          "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2203         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2204 }
2205
2206 static void service_enter_restart(Service *s) {
2207         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2208         int r;
2209
2210         assert(s);
2211
2212         if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2213                 /* Don't restart things if we are going down anyway */
2214                 log_info_unit(UNIT(s)->id,
2215                               "Stop job pending for unit, delaying automatic restart.");
2216
2217                 r = service_arm_timer(s, s->restart_usec);
2218                 if (r < 0)
2219                         goto fail;
2220
2221                 return;
2222         }
2223
2224         /* Any units that are bound to this service must also be
2225          * restarted. We use JOB_RESTART (instead of the more obvious
2226          * JOB_START) here so that those dependency jobs will be added
2227          * as well. */
2228         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2229         if (r < 0)
2230                 goto fail;
2231
2232         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2233          * it will be canceled as part of the service_stop() call that
2234          * is executed as part of JOB_RESTART. */
2235
2236         log_debug_unit(UNIT(s)->id,
2237                        "%s scheduled restart job.", UNIT(s)->id);
2238         return;
2239
2240 fail:
2241         log_warning_unit(UNIT(s)->id,
2242                          "%s failed to schedule restart job: %s",
2243                          UNIT(s)->id, bus_error_message(&error, -r));
2244         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2245 }
2246
2247 static void service_enter_reload(Service *s) {
2248         int r;
2249
2250         assert(s);
2251
2252         service_unwatch_control_pid(s);
2253
2254         s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2255         if (s->control_command) {
2256                 s->control_command_id = SERVICE_EXEC_RELOAD;
2257
2258                 r = service_spawn(s,
2259                                   s->control_command,
2260                                   true,
2261                                   false,
2262                                   !s->permissions_start_only,
2263                                   !s->root_directory_start_only,
2264                                   false,
2265                                   false,
2266                                   true,
2267                                   &s->control_pid);
2268                 if (r < 0)
2269                         goto fail;
2270
2271                 service_set_state(s, SERVICE_RELOAD);
2272         } else
2273                 service_enter_running(s, SERVICE_SUCCESS);
2274
2275         return;
2276
2277 fail:
2278         log_warning_unit(UNIT(s)->id,
2279                          "%s failed to run 'reload' task: %s",
2280                          UNIT(s)->id, strerror(-r));
2281         s->reload_result = SERVICE_FAILURE_RESOURCES;
2282         service_enter_running(s, SERVICE_SUCCESS);
2283 }
2284
2285 static void service_run_next_control(Service *s) {
2286         int r;
2287
2288         assert(s);
2289         assert(s->control_command);
2290         assert(s->control_command->command_next);
2291
2292         assert(s->control_command_id != SERVICE_EXEC_START);
2293
2294         s->control_command = s->control_command->command_next;
2295         service_unwatch_control_pid(s);
2296
2297         r = service_spawn(s,
2298                           s->control_command,
2299                           true,
2300                           false,
2301                           !s->permissions_start_only,
2302                           !s->root_directory_start_only,
2303                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2304                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2305                           false,
2306                           true,
2307                           &s->control_pid);
2308         if (r < 0)
2309                 goto fail;
2310
2311         return;
2312
2313 fail:
2314         log_warning_unit(UNIT(s)->id,
2315                          "%s failed to run next control task: %s",
2316                          UNIT(s)->id, strerror(-r));
2317
2318         if (s->state == SERVICE_START_PRE)
2319                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2320         else if (s->state == SERVICE_STOP)
2321                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2322         else if (s->state == SERVICE_STOP_POST)
2323                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2324         else if (s->state == SERVICE_RELOAD) {
2325                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2326                 service_enter_running(s, SERVICE_SUCCESS);
2327         } else
2328                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2329 }
2330
2331 static void service_run_next_main(Service *s) {
2332         pid_t pid;
2333         int r;
2334
2335         assert(s);
2336         assert(s->main_command);
2337         assert(s->main_command->command_next);
2338         assert(s->type == SERVICE_ONESHOT);
2339
2340         s->main_command = s->main_command->command_next;
2341         service_unwatch_main_pid(s);
2342
2343         r = service_spawn(s,
2344                           s->main_command,
2345                           true,
2346                           true,
2347                           true,
2348                           true,
2349                           true,
2350                           s->notify_access != NOTIFY_NONE,
2351                           false,
2352                           &pid);
2353         if (r < 0)
2354                 goto fail;
2355
2356         service_set_main_pid(s, pid);
2357
2358         return;
2359
2360 fail:
2361         log_warning_unit(UNIT(s)->id,
2362                          "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2363         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2364 }
2365
2366 static int service_start_limit_test(Service *s) {
2367         assert(s);
2368
2369         if (ratelimit_test(&s->start_limit))
2370                 return 0;
2371
2372         switch (s->start_limit_action) {
2373
2374         case SERVICE_START_LIMIT_NONE:
2375                 log_warning_unit(UNIT(s)->id,
2376                                  "%s start request repeated too quickly, refusing to start.",
2377                                  UNIT(s)->id);
2378                 break;
2379
2380         case SERVICE_START_LIMIT_REBOOT: {
2381                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2382                 int r;
2383
2384                 log_warning_unit(UNIT(s)->id,
2385                                  "%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2386
2387                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2388                                             SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2389                                             true, &error, NULL);
2390                 if (r < 0)
2391                         log_error_unit(UNIT(s)->id,
2392                                        "Failed to reboot: %s.", bus_error_message(&error, r));
2393
2394                 break;
2395         }
2396
2397         case SERVICE_START_LIMIT_REBOOT_FORCE:
2398                 log_warning_unit(UNIT(s)->id,
2399                                  "%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2400                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2401                 break;
2402
2403         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2404                 log_warning_unit(UNIT(s)->id,
2405                                  "%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2406                 sync();
2407                 reboot(RB_AUTOBOOT);
2408                 break;
2409
2410         default:
2411                 log_error_unit(UNIT(s)->id,
2412                                "start limit action=%i", s->start_limit_action);
2413                 assert_not_reached("Unknown StartLimitAction.");
2414         }
2415
2416         return -ECANCELED;
2417 }
2418
2419 static int service_start(Unit *u) {
2420         Service *s = SERVICE(u);
2421         int r;
2422
2423         assert(s);
2424
2425         /* We cannot fulfill this request right now, try again later
2426          * please! */
2427         if (s->state == SERVICE_STOP ||
2428             s->state == SERVICE_STOP_SIGTERM ||
2429             s->state == SERVICE_STOP_SIGKILL ||
2430             s->state == SERVICE_STOP_POST ||
2431             s->state == SERVICE_FINAL_SIGTERM ||
2432             s->state == SERVICE_FINAL_SIGKILL)
2433                 return -EAGAIN;
2434
2435         /* Already on it! */
2436         if (s->state == SERVICE_START_PRE ||
2437             s->state == SERVICE_START ||
2438             s->state == SERVICE_START_POST)
2439                 return 0;
2440
2441         /* A service that will be restarted must be stopped first to
2442          * trigger BindsTo and/or OnFailure dependencies. If a user
2443          * does not want to wait for the holdoff time to elapse, the
2444          * service should be manually restarted, not started. We
2445          * simply return EAGAIN here, so that any start jobs stay
2446          * queued, and assume that the auto restart timer will
2447          * eventually trigger the restart. */
2448         if (s->state == SERVICE_AUTO_RESTART)
2449                 return -EAGAIN;
2450
2451         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2452
2453         /* Make sure we don't enter a busy loop of some kind. */
2454         r = service_start_limit_test(s);
2455         if (r < 0) {
2456                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2457                 return r;
2458         }
2459
2460         s->result = SERVICE_SUCCESS;
2461         s->reload_result = SERVICE_SUCCESS;
2462         s->main_pid_known = false;
2463         s->main_pid_alien = false;
2464         s->forbid_restart = false;
2465
2466         service_enter_start_pre(s);
2467         return 0;
2468 }
2469
2470 static int service_stop(Unit *u) {
2471         Service *s = SERVICE(u);
2472
2473         assert(s);
2474
2475         /* Don't create restart jobs from here. */
2476         s->forbid_restart = true;
2477
2478         /* Already on it */
2479         if (s->state == SERVICE_STOP ||
2480             s->state == SERVICE_STOP_SIGTERM ||
2481             s->state == SERVICE_STOP_SIGKILL ||
2482             s->state == SERVICE_STOP_POST ||
2483             s->state == SERVICE_FINAL_SIGTERM ||
2484             s->state == SERVICE_FINAL_SIGKILL)
2485                 return 0;
2486
2487         /* A restart will be scheduled or is in progress. */
2488         if (s->state == SERVICE_AUTO_RESTART) {
2489                 service_set_state(s, SERVICE_DEAD);
2490                 return 0;
2491         }
2492
2493         /* If there's already something running we go directly into
2494          * kill mode. */
2495         if (s->state == SERVICE_START_PRE ||
2496             s->state == SERVICE_START ||
2497             s->state == SERVICE_START_POST ||
2498             s->state == SERVICE_RELOAD) {
2499                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2500                 return 0;
2501         }
2502
2503         assert(s->state == SERVICE_RUNNING ||
2504                s->state == SERVICE_EXITED);
2505
2506         service_enter_stop(s, SERVICE_SUCCESS);
2507         return 0;
2508 }
2509
2510 static int service_reload(Unit *u) {
2511         Service *s = SERVICE(u);
2512
2513         assert(s);
2514
2515         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2516
2517         service_enter_reload(s);
2518         return 0;
2519 }
2520
2521 _pure_ static bool service_can_reload(Unit *u) {
2522         Service *s = SERVICE(u);
2523
2524         assert(s);
2525
2526         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2527 }
2528
2529 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2530         Service *s = SERVICE(u);
2531
2532         assert(u);
2533         assert(f);
2534         assert(fds);
2535
2536         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2537         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2538         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2539
2540         if (s->control_pid > 0)
2541                 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
2542                                            s->control_pid);
2543
2544         if (s->main_pid_known && s->main_pid > 0)
2545                 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2546
2547         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2548
2549         if (s->status_text)
2550                 unit_serialize_item(u, f, "status-text", s->status_text);
2551
2552         /* FIXME: There's a minor uncleanliness here: if there are
2553          * multiple commands attached here, we will start from the
2554          * first one again */
2555         if (s->control_command_id >= 0)
2556                 unit_serialize_item(u, f, "control-command",
2557                                     service_exec_command_to_string(s->control_command_id));
2558
2559         if (s->socket_fd >= 0) {
2560                 int copy;
2561
2562                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2563                         return copy;
2564
2565                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2566         }
2567
2568         if (s->main_exec_status.pid > 0) {
2569                 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2570                                            s->main_exec_status.pid);
2571                 dual_timestamp_serialize(f, "main-exec-status-start",
2572                                          &s->main_exec_status.start_timestamp);
2573                 dual_timestamp_serialize(f, "main-exec-status-exit",
2574                                          &s->main_exec_status.exit_timestamp);
2575
2576                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2577                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2578                                                    s->main_exec_status.code);
2579                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2580                                                    s->main_exec_status.status);
2581                 }
2582         }
2583         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2584                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2585
2586         if (s->forbid_restart)
2587                 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2588
2589         return 0;
2590 }
2591
2592 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2593         Service *s = SERVICE(u);
2594
2595         assert(u);
2596         assert(key);
2597         assert(value);
2598         assert(fds);
2599
2600         if (streq(key, "state")) {
2601                 ServiceState state;
2602
2603                 state = service_state_from_string(value);
2604                 if (state < 0)
2605                         log_debug_unit(u->id, "Failed to parse state value %s", value);
2606                 else
2607                         s->deserialized_state = state;
2608         } else if (streq(key, "result")) {
2609                 ServiceResult f;
2610
2611                 f = service_result_from_string(value);
2612                 if (f < 0)
2613                         log_debug_unit(u->id, "Failed to parse result value %s", value);
2614                 else if (f != SERVICE_SUCCESS)
2615                         s->result = f;
2616
2617         } else if (streq(key, "reload-result")) {
2618                 ServiceResult f;
2619
2620                 f = service_result_from_string(value);
2621                 if (f < 0)
2622                         log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2623                 else if (f != SERVICE_SUCCESS)
2624                         s->reload_result = f;
2625
2626         } else if (streq(key, "control-pid")) {
2627                 pid_t pid;
2628
2629                 if (parse_pid(value, &pid) < 0)
2630                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2631                 else
2632                         s->control_pid = pid;
2633         } else if (streq(key, "main-pid")) {
2634                 pid_t pid;
2635
2636                 if (parse_pid(value, &pid) < 0)
2637                         log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2638                 else {
2639                         service_set_main_pid(s, pid);
2640                         unit_watch_pid(UNIT(s), pid);
2641                 }
2642         } else if (streq(key, "main-pid-known")) {
2643                 int b;
2644
2645                 b = parse_boolean(value);
2646                 if (b < 0)
2647                         log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2648                 else
2649                         s->main_pid_known = b;
2650         } else if (streq(key, "status-text")) {
2651                 char *t;
2652
2653                 t = strdup(value);
2654                 if (!t)
2655                         log_oom();
2656                 else {
2657                         free(s->status_text);
2658                         s->status_text = t;
2659                 }
2660
2661         } else if (streq(key, "control-command")) {
2662                 ServiceExecCommand id;
2663
2664                 id = service_exec_command_from_string(value);
2665                 if (id < 0)
2666                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2667                 else {
2668                         s->control_command_id = id;
2669                         s->control_command = s->exec_command[id];
2670                 }
2671         } else if (streq(key, "socket-fd")) {
2672                 int fd;
2673
2674                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2675                         log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2676                 else {
2677
2678                         safe_close(s->socket_fd);
2679                         s->socket_fd = fdset_remove(fds, fd);
2680                 }
2681         } else if (streq(key, "main-exec-status-pid")) {
2682                 pid_t pid;
2683
2684                 if (parse_pid(value, &pid) < 0)
2685                         log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2686                 else
2687                         s->main_exec_status.pid = pid;
2688         } else if (streq(key, "main-exec-status-code")) {
2689                 int i;
2690
2691                 if (safe_atoi(value, &i) < 0)
2692                         log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2693                 else
2694                         s->main_exec_status.code = i;
2695         } else if (streq(key, "main-exec-status-status")) {
2696                 int i;
2697
2698                 if (safe_atoi(value, &i) < 0)
2699                         log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2700                 else
2701                         s->main_exec_status.status = i;
2702         } else if (streq(key, "main-exec-status-start"))
2703                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2704         else if (streq(key, "main-exec-status-exit"))
2705                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2706         else if (streq(key, "watchdog-timestamp"))
2707                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2708         else if (streq(key, "forbid-restart")) {
2709                 int b;
2710
2711                 b = parse_boolean(value);
2712                 if (b < 0)
2713                         log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2714                 else
2715                         s->forbid_restart = b;
2716         } else
2717                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2718
2719         return 0;
2720 }
2721
2722 _pure_ static UnitActiveState service_active_state(Unit *u) {
2723         const UnitActiveState *table;
2724
2725         assert(u);
2726
2727         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2728
2729         return table[SERVICE(u)->state];
2730 }
2731
2732 static const char *service_sub_state_to_string(Unit *u) {
2733         assert(u);
2734
2735         return service_state_to_string(SERVICE(u)->state);
2736 }
2737
2738 static bool service_check_gc(Unit *u) {
2739         Service *s = SERVICE(u);
2740
2741         assert(s);
2742
2743         /* Never clean up services that still have a process around,
2744          * even if the service is formally dead. */
2745         if (cgroup_good(s) > 0 ||
2746             main_pid_good(s) > 0 ||
2747             control_pid_good(s) > 0)
2748                 return true;
2749
2750 #ifdef HAVE_SYSV_COMPAT
2751         if (s->is_sysv)
2752                 return true;
2753 #endif
2754
2755         return false;
2756 }
2757
2758 _pure_ static bool service_check_snapshot(Unit *u) {
2759         Service *s = SERVICE(u);
2760
2761         assert(s);
2762
2763         return (s->socket_fd < 0);
2764 }
2765
2766 static int service_retry_pid_file(Service *s) {
2767         int r;
2768
2769         assert(s->pid_file);
2770         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2771
2772         r = service_load_pid_file(s, false);
2773         if (r < 0)
2774                 return r;
2775
2776         service_unwatch_pid_file(s);
2777
2778         service_enter_running(s, SERVICE_SUCCESS);
2779         return 0;
2780 }
2781
2782 static int service_watch_pid_file(Service *s) {
2783         int r;
2784
2785         log_debug_unit(UNIT(s)->id,
2786                        "Setting watch for %s's PID file %s",
2787                        UNIT(s)->id, s->pid_file_pathspec->path);
2788         r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2789         if (r < 0)
2790                 goto fail;
2791
2792         /* the pidfile might have appeared just before we set the watch */
2793         log_debug_unit(UNIT(s)->id,
2794                        "Trying to read %s's PID file %s in case it changed",
2795                        UNIT(s)->id, s->pid_file_pathspec->path);
2796         service_retry_pid_file(s);
2797
2798         return 0;
2799 fail:
2800         log_error_unit(UNIT(s)->id,
2801                        "Failed to set a watch for %s's PID file %s: %s",
2802                        UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2803         service_unwatch_pid_file(s);
2804         return r;
2805 }
2806
2807 static int service_demand_pid_file(Service *s) {
2808         PathSpec *ps;
2809
2810         assert(s->pid_file);
2811         assert(!s->pid_file_pathspec);
2812
2813         ps = new0(PathSpec, 1);
2814         if (!ps)
2815                 return -ENOMEM;
2816
2817         ps->unit = UNIT(s);
2818         ps->path = strdup(s->pid_file);
2819         if (!ps->path) {
2820                 free(ps);
2821                 return -ENOMEM;
2822         }
2823
2824         path_kill_slashes(ps->path);
2825
2826         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2827          * keep their PID file open all the time. */
2828         ps->type = PATH_MODIFIED;
2829         ps->inotify_fd = -1;
2830
2831         s->pid_file_pathspec = ps;
2832
2833         return service_watch_pid_file(s);
2834 }
2835
2836 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2837         PathSpec *p = userdata;
2838         Service *s;
2839
2840         assert(p);
2841
2842         s = SERVICE(p->unit);
2843
2844         assert(s);
2845         assert(fd >= 0);
2846         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2847         assert(s->pid_file_pathspec);
2848         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2849
2850         log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2851
2852         if (path_spec_fd_event(p, events) < 0)
2853                 goto fail;
2854
2855         if (service_retry_pid_file(s) == 0)
2856                 return 0;
2857
2858         if (service_watch_pid_file(s) < 0)
2859                 goto fail;
2860
2861         return 0;
2862
2863 fail:
2864         service_unwatch_pid_file(s);
2865         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2866         return 0;
2867 }
2868
2869 static void service_notify_cgroup_empty_event(Unit *u) {
2870         Service *s = SERVICE(u);
2871
2872         assert(u);
2873
2874         log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2875
2876         switch (s->state) {
2877
2878                 /* Waiting for SIGCHLD is usually more interesting,
2879                  * because it includes return codes/signals. Which is
2880                  * why we ignore the cgroup events for most cases,
2881                  * except when we don't know pid which to expect the
2882                  * SIGCHLD for. */
2883
2884         case SERVICE_START:
2885         case SERVICE_START_POST:
2886                 /* If we were hoping for the daemon to write its PID file,
2887                  * we can give up now. */
2888                 if (s->pid_file_pathspec) {
2889                         log_warning_unit(u->id,
2890                                          "%s never wrote its PID file. Failing.", UNIT(s)->id);
2891                         service_unwatch_pid_file(s);
2892                         if (s->state == SERVICE_START)
2893                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2894                         else
2895                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2896                 }
2897                 break;
2898
2899         case SERVICE_RUNNING:
2900                 /* service_enter_running() will figure out what to do */
2901                 service_enter_running(s, SERVICE_SUCCESS);
2902                 break;
2903
2904         case SERVICE_STOP_SIGTERM:
2905         case SERVICE_STOP_SIGKILL:
2906
2907                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2908                         service_enter_stop_post(s, SERVICE_SUCCESS);
2909
2910                 break;
2911
2912         case SERVICE_STOP_POST:
2913         case SERVICE_FINAL_SIGTERM:
2914         case SERVICE_FINAL_SIGKILL:
2915                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2916                         service_enter_dead(s, SERVICE_SUCCESS, true);
2917
2918                 break;
2919
2920         default:
2921                 ;
2922         }
2923 }
2924
2925 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2926         Service *s = SERVICE(u);
2927         ServiceResult f;
2928
2929         assert(s);
2930         assert(pid >= 0);
2931
2932         if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2933                                      is_clean_exit_lsb(code, status, &s->success_status))
2934                 f = SERVICE_SUCCESS;
2935         else if (code == CLD_EXITED)
2936                 f = SERVICE_FAILURE_EXIT_CODE;
2937         else if (code == CLD_KILLED)
2938                 f = SERVICE_FAILURE_SIGNAL;
2939         else if (code == CLD_DUMPED)
2940                 f = SERVICE_FAILURE_CORE_DUMP;
2941         else
2942                 assert_not_reached("Unknown code");
2943
2944         if (s->main_pid == pid) {
2945                 /* Forking services may occasionally move to a new PID.
2946                  * As long as they update the PID file before exiting the old
2947                  * PID, they're fine. */
2948                 if (service_load_pid_file(s, false) == 0)
2949                         return;
2950
2951                 s->main_pid = 0;
2952                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2953
2954                 if (s->main_command) {
2955                         /* If this is not a forking service than the
2956                          * main process got started and hence we copy
2957                          * the exit status so that it is recorded both
2958                          * as main and as control process exit
2959                          * status */
2960
2961                         s->main_command->exec_status = s->main_exec_status;
2962
2963                         if (s->main_command->ignore)
2964                                 f = SERVICE_SUCCESS;
2965                 } else if (s->exec_command[SERVICE_EXEC_START]) {
2966
2967                         /* If this is a forked process, then we should
2968                          * ignore the return value if this was
2969                          * configured for the starter process */
2970
2971                         if (s->exec_command[SERVICE_EXEC_START]->ignore)
2972                                 f = SERVICE_SUCCESS;
2973                 }
2974
2975                 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2976                            u->id,
2977                            "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2978                                   u->id, sigchld_code_to_string(code), status,
2979                                   strna(code == CLD_EXITED
2980                                         ? exit_status_to_string(status, EXIT_STATUS_FULL)
2981                                         : signal_to_string(status)),
2982                            "EXIT_CODE=%s", sigchld_code_to_string(code),
2983                            "EXIT_STATUS=%i", status,
2984                            NULL);
2985
2986                 if (f != SERVICE_SUCCESS)
2987                         s->result = f;
2988
2989                 if (s->main_command &&
2990                     s->main_command->command_next &&
2991                     f == SERVICE_SUCCESS) {
2992
2993                         /* There is another command to *
2994                          * execute, so let's do that. */
2995
2996                         log_debug_unit(u->id,
2997                                        "%s running next main command for state %s",
2998                                        u->id, service_state_to_string(s->state));
2999                         service_run_next_main(s);
3000
3001                 } else {
3002
3003                         /* The service exited, so the service is officially
3004                          * gone. */
3005                         s->main_command = NULL;
3006
3007                         switch (s->state) {
3008
3009                         case SERVICE_START_POST:
3010                         case SERVICE_RELOAD:
3011                         case SERVICE_STOP:
3012                                 /* Need to wait until the operation is
3013                                  * done */
3014                                 break;
3015
3016                         case SERVICE_START:
3017                                 if (s->type == SERVICE_ONESHOT) {
3018                                         /* This was our main goal, so let's go on */
3019                                         if (f == SERVICE_SUCCESS)
3020                                                 service_enter_start_post(s);
3021                                         else
3022                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3023                                         break;
3024                                 }
3025
3026                                 /* Fall through */
3027
3028                         case SERVICE_RUNNING:
3029                                 service_enter_running(s, f);
3030                                 break;
3031
3032                         case SERVICE_STOP_SIGTERM:
3033                         case SERVICE_STOP_SIGKILL:
3034
3035                                 if (!control_pid_good(s))
3036                                         service_enter_stop_post(s, f);
3037
3038                                 /* If there is still a control process, wait for that first */
3039                                 break;
3040
3041                         case SERVICE_STOP_POST:
3042                         case SERVICE_FINAL_SIGTERM:
3043                         case SERVICE_FINAL_SIGKILL:
3044
3045                                 if (!control_pid_good(s))
3046                                         service_enter_dead(s, f, true);
3047                                 break;
3048
3049                         default:
3050                                 assert_not_reached("Uh, main process died at wrong time.");
3051                         }
3052                 }
3053
3054         } else if (s->control_pid == pid) {
3055                 s->control_pid = 0;
3056
3057                 if (s->control_command) {
3058                         exec_status_exit(&s->control_command->exec_status,
3059                                          &s->exec_context, pid, code, status);
3060
3061                         if (s->control_command->ignore)
3062                                 f = SERVICE_SUCCESS;
3063                 }
3064
3065                 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3066                               "%s: control process exited, code=%s status=%i",
3067                               u->id, sigchld_code_to_string(code), status);
3068
3069                 if (f != SERVICE_SUCCESS)
3070                         s->result = f;
3071
3072                 /* Immediately get rid of the cgroup, so that the
3073                  * kernel doesn't delay the cgroup empty messages for
3074                  * the service cgroup any longer than necessary */
3075                 service_kill_control_processes(s);
3076
3077                 if (s->control_command &&
3078                     s->control_command->command_next &&
3079                     f == SERVICE_SUCCESS) {
3080
3081                         /* There is another command to *
3082                          * execute, so let's do that. */
3083
3084                         log_debug_unit(u->id,
3085                                        "%s running next control command for state %s",
3086                                        u->id, service_state_to_string(s->state));
3087                         service_run_next_control(s);
3088
3089                 } else {
3090                         /* No further commands for this step, so let's
3091                          * figure out what to do next */
3092
3093                         s->control_command = NULL;
3094                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3095
3096                         log_debug_unit(u->id,
3097                                        "%s got final SIGCHLD for state %s",
3098                                        u->id, service_state_to_string(s->state));
3099
3100                         switch (s->state) {
3101
3102                         case SERVICE_START_PRE:
3103                                 if (f == SERVICE_SUCCESS)
3104                                         service_enter_start(s);
3105                                 else
3106                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3107                                 break;
3108
3109                         case SERVICE_START:
3110                                 if (s->type != SERVICE_FORKING)
3111                                         /* Maybe spurious event due to a reload that changed the type? */
3112                                         break;
3113
3114                                 if (f != SERVICE_SUCCESS) {
3115                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3116                                         break;
3117                                 }
3118
3119                                 if (s->pid_file) {
3120                                         bool has_start_post;
3121                                         int r;
3122
3123                                         /* Let's try to load the pid file here if we can.
3124                                          * The PID file might actually be created by a START_POST
3125                                          * script. In that case don't worry if the loading fails. */
3126
3127                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3128                                         r = service_load_pid_file(s, !has_start_post);
3129                                         if (!has_start_post && r < 0) {
3130                                                 r = service_demand_pid_file(s);
3131                                                 if (r < 0 || !cgroup_good(s))
3132                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3133                                                 break;
3134                                         }
3135                                 } else
3136                                         service_search_main_pid(s);
3137
3138                                 service_enter_start_post(s);
3139                                 break;
3140
3141                         case SERVICE_START_POST:
3142                                 if (f != SERVICE_SUCCESS) {
3143                                         service_enter_stop(s, f);
3144                                         break;
3145                                 }
3146
3147                                 if (s->pid_file) {
3148                                         int r;
3149
3150                                         r = service_load_pid_file(s, true);
3151                                         if (r < 0) {
3152                                                 r = service_demand_pid_file(s);
3153                                                 if (r < 0 || !cgroup_good(s))
3154                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3155                                                 break;
3156                                         }
3157                                 } else
3158                                         service_search_main_pid(s);
3159
3160                                 service_enter_running(s, SERVICE_SUCCESS);
3161                                 break;
3162
3163                         case SERVICE_RELOAD:
3164                                 if (f == SERVICE_SUCCESS) {
3165                                         service_load_pid_file(s, true);
3166                                         service_search_main_pid(s);
3167                                 }
3168
3169                                 s->reload_result = f;
3170                                 service_enter_running(s, SERVICE_SUCCESS);
3171                                 break;
3172
3173                         case SERVICE_STOP:
3174                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3175                                 break;
3176
3177                         case SERVICE_STOP_SIGTERM:
3178                         case SERVICE_STOP_SIGKILL:
3179                                 if (main_pid_good(s) <= 0)
3180                                         service_enter_stop_post(s, f);
3181
3182                                 /* If there is still a service
3183                                  * process around, wait until
3184                                  * that one quit, too */
3185                                 break;
3186
3187                         case SERVICE_STOP_POST:
3188                         case SERVICE_FINAL_SIGTERM:
3189                         case SERVICE_FINAL_SIGKILL:
3190                                 if (main_pid_good(s) <= 0)
3191                                         service_enter_dead(s, f, true);
3192                                 break;
3193
3194                         default:
3195                                 assert_not_reached("Uh, control process died at wrong time.");
3196                         }
3197                 }
3198         }
3199
3200         /* Notify clients about changed exit status */
3201         unit_add_to_dbus_queue(u);
3202
3203         /* We got one SIGCHLD for the service, let's watch all
3204          * processes that are now running of the service, and watch
3205          * that. Among the PIDs we then watch will be children
3206          * reassigned to us, which hopefully allows us to identify
3207          * when all children are gone */
3208         unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
3209         unit_watch_all_pids(u);
3210
3211         /* If the PID set is empty now, then let's finish this off */
3212         if (set_isempty(u->pids))
3213                 service_notify_cgroup_empty_event(u);
3214 }
3215
3216 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3217         Service *s = SERVICE(userdata);
3218
3219         assert(s);
3220         assert(source == s->timer_event_source);
3221
3222         switch (s->state) {
3223
3224         case SERVICE_START_PRE:
3225         case SERVICE_START:
3226                 log_warning_unit(UNIT(s)->id,
3227                                  "%s %s operation timed out. Terminating.",
3228                                  UNIT(s)->id,
3229                                  s->state == SERVICE_START ? "start" : "start-pre");
3230                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3231                 break;
3232
3233         case SERVICE_START_POST:
3234                 log_warning_unit(UNIT(s)->id,
3235                                  "%s start-post operation timed out. Stopping.", UNIT(s)->id);
3236                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3237                 break;
3238
3239         case SERVICE_RELOAD:
3240                 log_warning_unit(UNIT(s)->id,
3241                                  "%s reload operation timed out. Stopping.", UNIT(s)->id);
3242                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3243                 service_enter_running(s, SERVICE_SUCCESS);
3244                 break;
3245
3246         case SERVICE_STOP:
3247                 log_warning_unit(UNIT(s)->id,
3248                                  "%s stopping timed out. Terminating.", UNIT(s)->id);
3249                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3250                 break;
3251
3252         case SERVICE_STOP_SIGTERM:
3253                 if (s->kill_context.send_sigkill) {
3254                         log_warning_unit(UNIT(s)->id,
3255                                          "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
3256                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3257                 } else {
3258                         log_warning_unit(UNIT(s)->id,
3259                                          "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
3260                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3261                 }
3262
3263                 break;
3264
3265         case SERVICE_STOP_SIGKILL:
3266                 /* Uh, we sent a SIGKILL and it is still not gone?
3267                  * Must be something we cannot kill, so let's just be
3268                  * weirded out and continue */
3269
3270                 log_warning_unit(UNIT(s)->id,
3271                                  "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
3272                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3273                 break;
3274
3275         case SERVICE_STOP_POST:
3276                 log_warning_unit(UNIT(s)->id,
3277                                  "%s stop-post timed out. Terminating.", UNIT(s)->id);
3278                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3279                 break;
3280
3281         case SERVICE_FINAL_SIGTERM:
3282                 if (s->kill_context.send_sigkill) {
3283                         log_warning_unit(UNIT(s)->id,
3284                                          "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
3285                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3286                 } else {
3287                         log_warning_unit(UNIT(s)->id,
3288                                          "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
3289                                          UNIT(s)->id);
3290                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3291                 }
3292
3293                 break;
3294
3295         case SERVICE_FINAL_SIGKILL:
3296                 log_warning_unit(UNIT(s)->id,
3297                                  "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
3298                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3299                 break;
3300
3301         case SERVICE_AUTO_RESTART:
3302                 log_info_unit(UNIT(s)->id,
3303                               s->restart_usec > 0 ?
3304                               "%s holdoff time over, scheduling restart." :
3305                               "%s has no holdoff time, scheduling restart.",
3306                               UNIT(s)->id);
3307                 service_enter_restart(s);
3308                 break;
3309
3310         default:
3311                 assert_not_reached("Timeout at wrong time.");
3312         }
3313
3314         return 0;
3315 }
3316
3317 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3318         Service *s = SERVICE(userdata);
3319
3320         assert(s);
3321         assert(source == s->watchdog_event_source);
3322
3323         log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
3324         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
3325
3326         return 0;
3327 }
3328
3329 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3330         Service *s = SERVICE(u);
3331         const char *e;
3332         bool notify_dbus = false;
3333
3334         assert(u);
3335
3336         log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
3337                        u->id, pid, tags && *tags ? tags[0] : "(empty)");
3338
3339         if (s->notify_access == NOTIFY_NONE) {
3340                 log_warning_unit(u->id,
3341                                  "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
3342                                  u->id, pid);
3343                 return;
3344         }
3345
3346         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3347
3348                 if (s->main_pid != 0)
3349                         log_warning_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
3350                 else
3351                         log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
3352                 return;
3353         }
3354
3355         /* Interpret MAINPID= */
3356         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3357             (s->state == SERVICE_START ||
3358              s->state == SERVICE_START_POST ||
3359              s->state == SERVICE_RUNNING ||
3360              s->state == SERVICE_RELOAD)) {
3361
3362                 if (parse_pid(e + 8, &pid) < 0)
3363                         log_warning_unit(u->id, "Failed to parse notification message %s", e);
3364                 else {
3365                         log_debug_unit(u->id, "%s: got %s", u->id, e);
3366                         service_set_main_pid(s, pid);
3367                         unit_watch_pid(UNIT(s), pid);
3368                         notify_dbus = true;
3369                 }
3370         }
3371
3372         /* Interpret READY= */
3373         if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
3374                 log_debug_unit(u->id, "%s: got READY=1", u->id);
3375                 service_enter_start_post(s);
3376                 notify_dbus = true;
3377         }
3378
3379         /* Interpret STATUS= */
3380         e = strv_find_prefix(tags, "STATUS=");
3381         if (e) {
3382                 char *t;
3383
3384                 if (e[7]) {
3385                         if (!utf8_is_valid(e+7)) {
3386                                 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
3387                                 return;
3388                         }
3389
3390                         log_debug_unit(u->id, "%s: got %s", u->id, e);
3391
3392                         t = strdup(e+7);
3393                         if (!t) {
3394                                 log_oom();
3395                                 return;
3396                         }
3397
3398                 } else
3399                         t = NULL;
3400
3401                 if (!streq_ptr(s->status_text, t)) {
3402                         free(s->status_text);
3403                         s->status_text = t;
3404                         notify_dbus = true;
3405                 } else
3406                         free(t);
3407         }
3408
3409         /* Interpret WATCHDOG= */
3410         if (strv_find(tags, "WATCHDOG=1")) {
3411                 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
3412                 service_reset_watchdog(s);
3413         }
3414
3415         /* Notify clients about changed status or main pid */
3416         if (notify_dbus)
3417                 unit_add_to_dbus_queue(u);
3418 }
3419
3420 static int service_get_timeout(Unit *u, uint64_t *timeout) {
3421         Service *s = SERVICE(u);
3422         int r;
3423
3424         if (!s->timer_event_source)
3425                 return 0;
3426
3427         r = sd_event_source_get_time(s->timer_event_source, timeout);
3428         if (r < 0)
3429                 return r;
3430
3431         return 1;
3432 }
3433
3434 #ifdef HAVE_SYSV_COMPAT
3435
3436 static int service_enumerate(Manager *m) {
3437         char **p;
3438         unsigned i;
3439         _cleanup_closedir_ DIR *d = NULL;
3440         _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3441         Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3442         _cleanup_set_free_ Set *shutdown_services = NULL;
3443         Unit *service;
3444         Iterator j;
3445         int r;
3446
3447         assert(m);
3448
3449         if (m->running_as != SYSTEMD_SYSTEM)
3450                 return 0;
3451
3452         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3453                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3454                         struct dirent *de;
3455
3456                         free(path);
3457                         path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3458                         if (!path) {
3459                                 r = -ENOMEM;
3460                                 goto finish;
3461                         }
3462
3463                         if (d)
3464                                 closedir(d);
3465
3466                         d = opendir(path);
3467                         if (!d) {
3468                                 if (errno != ENOENT)
3469                                         log_warning("opendir(%s) failed: %m", path);
3470
3471                                 continue;
3472                         }
3473
3474                         while ((de = readdir(d))) {
3475                                 int a, b;
3476
3477                                 if (ignore_file(de->d_name))
3478                                         continue;
3479
3480                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3481                                         continue;
3482
3483                                 if (strlen(de->d_name) < 4)
3484                                         continue;
3485
3486                                 a = undecchar(de->d_name[1]);
3487                                 b = undecchar(de->d_name[2]);
3488
3489                                 if (a < 0 || b < 0)
3490                                         continue;
3491
3492                                 free(fpath);
3493                                 fpath = strjoin(path, "/", de->d_name, NULL);
3494                                 if (!fpath) {
3495                                         r = -ENOMEM;
3496                                         goto finish;
3497                                 }
3498
3499                                 if (access(fpath, X_OK) < 0) {
3500
3501                                         if (errno != ENOENT)
3502                                                 log_warning("access() failed on %s: %m", fpath);
3503
3504                                         continue;
3505                                 }
3506
3507                                 free(name);
3508                                 name = sysv_translate_name(de->d_name + 3);
3509                                 if (!name) {
3510                                         r = log_oom();
3511                                         goto finish;
3512                                 }
3513
3514                                 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3515                                 if (r < 0) {
3516                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3517                                         continue;
3518                                 }
3519
3520                                 if (de->d_name[0] == 'S')  {
3521
3522                                         if (rcnd_table[i].type == RUNLEVEL_UP) {
3523                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3524                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3525
3526                                                 SERVICE(service)->sysv_enabled = true;
3527                                         }
3528
3529                                         r = set_ensure_allocated(&runlevel_services[i],
3530                                                                  trivial_hash_func, trivial_compare_func);
3531                                         if (r < 0)
3532                                                 goto finish;
3533
3534                                         r = set_put(runlevel_services[i], service);
3535                                         if (r < 0)
3536                                                 goto finish;
3537
3538                                 } else if (de->d_name[0] == 'K' &&
3539                                            (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3540
3541                                         r = set_ensure_allocated(&shutdown_services,
3542                                                                  trivial_hash_func, trivial_compare_func);
3543                                         if (r < 0)
3544                                                 goto finish;
3545
3546                                         r = set_put(shutdown_services, service);
3547                                         if (r < 0)
3548                                                 goto finish;
3549                                 }
3550                         }
3551                 }
3552
3553         /* Now we loaded all stubs and are aware of the lowest
3554         start-up priority for all services, not let's actually load
3555         the services, this will also tell us which services are
3556         actually native now */
3557         manager_dispatch_load_queue(m);
3558
3559         /* If this is a native service, rely on native ways to pull in
3560          * a service, don't pull it in via sysv rcN.d links. */
3561         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3562                 SET_FOREACH(service, runlevel_services[i], j) {
3563                         service = unit_follow_merge(service);
3564
3565                         if (service->fragment_path)
3566                                 continue;
3567
3568                         r = unit_add_two_dependencies_by_name_inverse(
3569                                 service, UNIT_AFTER, UNIT_WANTS,
3570                                 rcnd_table[i].target, NULL, true);
3571                         if (r < 0)
3572                                 goto finish;
3573                 }
3574
3575         /* We honour K links only for halt/reboot. For the normal
3576          * runlevels we assume the stop jobs will be implicitly added
3577          * by the core logic. Also, we don't really distinguish here
3578          * between the runlevels 0 and 6 and just add them to the
3579          * special shutdown target. */
3580         SET_FOREACH(service, shutdown_services, j) {
3581                 service = unit_follow_merge(service);
3582
3583                 if (service->fragment_path)
3584                         continue;
3585
3586                 r = unit_add_two_dependencies_by_name(
3587                         service, UNIT_BEFORE, UNIT_CONFLICTS,
3588                         SPECIAL_SHUTDOWN_TARGET, NULL, true);
3589                 if (r < 0)
3590                         goto finish;
3591         }
3592
3593         r = 0;
3594
3595 finish:
3596
3597         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3598                 set_free(runlevel_services[i]);
3599
3600         return r;
3601 }
3602 #endif
3603
3604 static void service_bus_name_owner_change(
3605                 Unit *u,
3606                 const char *name,
3607                 const char *old_owner,
3608                 const char *new_owner) {
3609
3610         Service *s = SERVICE(u);
3611         int r;
3612
3613         assert(s);
3614         assert(name);
3615
3616         assert(streq(s->bus_name, name));
3617         assert(old_owner || new_owner);
3618
3619         if (old_owner && new_owner)
3620                 log_debug_unit(u->id,
3621                                "%s's D-Bus name %s changed owner from %s to %s",
3622                                u->id, name, old_owner, new_owner);
3623         else if (old_owner)
3624                 log_debug_unit(u->id,
3625                                "%s's D-Bus name %s no longer registered by %s",
3626                                u->id, name, old_owner);
3627         else
3628                 log_debug_unit(u->id,
3629                                "%s's D-Bus name %s now registered by %s",
3630                                u->id, name, new_owner);
3631
3632         s->bus_name_good = !!new_owner;
3633
3634         if (s->type == SERVICE_DBUS) {
3635
3636                 /* service_enter_running() will figure out what to
3637                  * do */
3638                 if (s->state == SERVICE_RUNNING)
3639                         service_enter_running(s, SERVICE_SUCCESS);
3640                 else if (s->state == SERVICE_START && new_owner)
3641                         service_enter_start_post(s);
3642
3643         } else if (new_owner &&
3644                    s->main_pid <= 0 &&
3645                    (s->state == SERVICE_START ||
3646                     s->state == SERVICE_START_POST ||
3647                     s->state == SERVICE_RUNNING ||
3648                     s->state == SERVICE_RELOAD)) {
3649
3650                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
3651                 pid_t pid;
3652
3653                 /* Try to acquire PID from bus service */
3654
3655                 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3656                 if (r >= 0)
3657                         r = sd_bus_creds_get_pid(creds, &pid);
3658                 if (r >= 0) {
3659                         log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3660
3661                         service_set_main_pid(s, pid);
3662                         unit_watch_pid(UNIT(s), pid);
3663                 }
3664         }
3665 }
3666
3667 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3668         _cleanup_free_ char *peer = NULL;
3669         int r;
3670
3671         assert(s);
3672         assert(fd >= 0);
3673
3674         /* This is called by the socket code when instantiating a new
3675          * service for a stream socket and the socket needs to be
3676          * configured. */
3677
3678         if (UNIT(s)->load_state != UNIT_LOADED)
3679                 return -EINVAL;
3680
3681         if (s->socket_fd >= 0)
3682                 return -EBUSY;
3683
3684         if (s->state != SERVICE_DEAD)
3685                 return -EAGAIN;
3686
3687         if (getpeername_pretty(fd, &peer) >= 0) {
3688
3689                 if (UNIT(s)->description) {
3690                         _cleanup_free_ char *a;
3691
3692                         a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3693                         if (!a)
3694                                 return -ENOMEM;
3695
3696                         r = unit_set_description(UNIT(s), a);
3697                 }  else
3698                         r = unit_set_description(UNIT(s), peer);
3699
3700                 if (r < 0)
3701                         return r;
3702         }
3703
3704         s->socket_fd = fd;
3705
3706         unit_ref_set(&s->accept_socket, UNIT(sock));
3707
3708         return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3709 }
3710
3711 static void service_reset_failed(Unit *u) {
3712         Service *s = SERVICE(u);
3713
3714         assert(s);
3715
3716         if (s->state == SERVICE_FAILED)
3717                 service_set_state(s, SERVICE_DEAD);
3718
3719         s->result = SERVICE_SUCCESS;
3720         s->reload_result = SERVICE_SUCCESS;
3721
3722         RATELIMIT_RESET(s->start_limit);
3723 }
3724
3725 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3726         Service *s = SERVICE(u);
3727
3728         return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3729 }
3730
3731 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3732         [SERVICE_DEAD] = "dead",
3733         [SERVICE_START_PRE] = "start-pre",
3734         [SERVICE_START] = "start",
3735         [SERVICE_START_POST] = "start-post",
3736         [SERVICE_RUNNING] = "running",
3737         [SERVICE_EXITED] = "exited",
3738         [SERVICE_RELOAD] = "reload",
3739         [SERVICE_STOP] = "stop",
3740         [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3741         [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3742         [SERVICE_STOP_POST] = "stop-post",
3743         [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3744         [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3745         [SERVICE_FAILED] = "failed",
3746         [SERVICE_AUTO_RESTART] = "auto-restart",
3747 };
3748
3749 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3750
3751 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3752         [SERVICE_RESTART_NO] = "no",
3753         [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3754         [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3755         [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3756         [SERVICE_RESTART_ON_ABORT] = "on-abort",
3757         [SERVICE_RESTART_ALWAYS] = "always"
3758 };
3759
3760 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3761
3762 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3763         [SERVICE_SIMPLE] = "simple",
3764         [SERVICE_FORKING] = "forking",
3765         [SERVICE_ONESHOT] = "oneshot",
3766         [SERVICE_DBUS] = "dbus",
3767         [SERVICE_NOTIFY] = "notify",
3768         [SERVICE_IDLE] = "idle"
3769 };
3770
3771 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3772
3773 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3774         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3775         [SERVICE_EXEC_START] = "ExecStart",
3776         [SERVICE_EXEC_START_POST] = "ExecStartPost",
3777         [SERVICE_EXEC_RELOAD] = "ExecReload",
3778         [SERVICE_EXEC_STOP] = "ExecStop",
3779         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3780 };
3781
3782 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3783
3784 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3785         [NOTIFY_NONE] = "none",
3786         [NOTIFY_MAIN] = "main",
3787         [NOTIFY_ALL] = "all"
3788 };
3789
3790 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3791
3792 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3793         [SERVICE_SUCCESS] = "success",
3794         [SERVICE_FAILURE_RESOURCES] = "resources",
3795         [SERVICE_FAILURE_TIMEOUT] = "timeout",
3796         [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3797         [SERVICE_FAILURE_SIGNAL] = "signal",
3798         [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3799         [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3800         [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3801 };
3802
3803 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3804
3805 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3806         [SERVICE_START_LIMIT_NONE] = "none",
3807         [SERVICE_START_LIMIT_REBOOT] = "reboot",
3808         [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3809         [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3810 };
3811 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3812
3813 const UnitVTable service_vtable = {
3814         .object_size = sizeof(Service),
3815         .exec_context_offset = offsetof(Service, exec_context),
3816         .cgroup_context_offset = offsetof(Service, cgroup_context),
3817         .kill_context_offset = offsetof(Service, kill_context),
3818         .exec_runtime_offset = offsetof(Service, exec_runtime),
3819
3820         .sections =
3821                 "Unit\0"
3822                 "Service\0"
3823                 "Install\0",
3824         .private_section = "Service",
3825
3826         .init = service_init,
3827         .done = service_done,
3828         .load = service_load,
3829
3830         .coldplug = service_coldplug,
3831
3832         .dump = service_dump,
3833
3834         .start = service_start,
3835         .stop = service_stop,
3836         .reload = service_reload,
3837
3838         .can_reload = service_can_reload,
3839
3840         .kill = service_kill,
3841
3842         .serialize = service_serialize,
3843         .deserialize_item = service_deserialize_item,
3844
3845         .active_state = service_active_state,
3846         .sub_state_to_string = service_sub_state_to_string,
3847
3848         .check_gc = service_check_gc,
3849         .check_snapshot = service_check_snapshot,
3850
3851         .sigchld_event = service_sigchld_event,
3852
3853         .reset_failed = service_reset_failed,
3854
3855         .notify_cgroup_empty = service_notify_cgroup_empty_event,
3856         .notify_message = service_notify_message,
3857
3858         .bus_name_owner_change = service_bus_name_owner_change,
3859
3860         .bus_interface = "org.freedesktop.systemd1.Service",
3861         .bus_vtable = bus_service_vtable,
3862         .bus_set_property = bus_service_set_property,
3863         .bus_commit_properties = bus_service_commit_properties,
3864
3865         .get_timeout = service_get_timeout,
3866
3867 #ifdef HAVE_SYSV_COMPAT
3868         .enumerate = service_enumerate,
3869 #endif
3870
3871         .can_transient = true,
3872
3873         .status_message_formats = {
3874                 .starting_stopping = {
3875                         [0] = "Starting %s...",
3876                         [1] = "Stopping %s...",
3877                 },
3878                 .finished_start_job = {
3879                         [JOB_DONE]       = "Started %s.",
3880                         [JOB_FAILED]     = "Failed to start %s.",
3881                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
3882                         [JOB_TIMEOUT]    = "Timed out starting %s.",
3883                 },
3884                 .finished_stop_job = {
3885                         [JOB_DONE]       = "Stopped %s.",
3886                         [JOB_FAILED]     = "Stopped (with error) %s.",
3887                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
3888                 },
3889         },
3890 };