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