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