src/service.cc

   1 #include <cstring>
   2 #include <cerrno>
   3 #include <sstream>
   4 #include <iterator>
   5 #include <memory>
   6 #include <cstddef>
   7
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <sys/ioctl.h>
  11 #include <sys/un.h>
  12 #include <sys/socket.h>
  13 #include <fcntl.h>
  14 #include <unistd.h>
  15 #include <termios.h>
  16
  17 #include "service.h"
  18 #include "dinit-log.h"
  19 #include "dinit-socket.h"
  20 #include "dinit-util.h"
  21
  22 /*
  23  * service.cc - Service management.
  24  * See service.h for details.
  25  */
  26
  27 // from dinit.cc:
  28 void open_control_socket(bool report_ro_failure = true) noexcept;
  29 void setup_external_log() noexcept;
  30 extern eventloop_t eventLoop;
  31
  32 // Find the requested service by name
  33 static service_record * find_service(const std::list<service_record *> & records,
  34                                     const char *name) noexcept
  35 {
  36     using std::list;
  37     list<service_record *>::const_iterator i = records.begin();
  38     for ( ; i != records.end(); i++ ) {
  39         if (strcmp((*i)->get_name().c_str(), name) == 0) {
  40             return *i;
  41         }
  42     }
  43     return nullptr;
  44 }
  45
  46 service_record * service_set::find_service(const std::string &name) noexcept
  47 {
  48     return ::find_service(records, name.c_str());
  49 }
  50
  51 void service_set::stop_service(const std::string & name) noexcept
  52 {
  53     service_record *record = find_service(name);
  54     if (record != nullptr) {
  55         record->stop();
  56         process_queues();
  57     }
  58 }
  59
  60 // Called when a service has actually stopped; dependents have stopped already, unless this stop
  61 // is due to an unexpected process termination.
  62 void service_record::stopped() noexcept
  63 {
  64     if (onstart_flags.runs_on_console) {
  65         tcsetpgrp(0, getpgrp());
  66         discard_console_log_buffer();
  67         release_console();
  68     }
  69
  70     force_stop = false;
  71
  72     // If we are a soft dependency of another target, break the acquisition from that target now:
  73     for (auto & dependent : dependents) {
  74         if (dependent->dep_type != dependency_type::REGULAR) {
  75             if (dependent->holding_acq) {
  76                 dependent->holding_acq = false;
  77                 release();
  78             }
  79         }
  80     }
  81
  82     bool will_restart = (desired_state == service_state_t::STARTED)
  83             && services->get_auto_restart();
  84
  85     for (auto dependency : depends_on) {
  86         // we signal dependencies in case they are waiting for us to stop:
  87         dependency.get_to()->dependent_stopped();
  88     }
  89
  90     service_state = service_state_t::STOPPED;
  91
  92     if (will_restart) {
  93         // Desired state is "started".
  94         restarting = true;
  95         start(false);
  96     }
  97     else {
  98         if (socket_fd != -1) {
  99             close(socket_fd);
 100             socket_fd = -1;
 101         }
 102
 103         if (start_explicit) {
 104             start_explicit = false;
 105             release();
 106         }
 107         else if (required_by == 0) {
 108             services->service_inactive(this);
 109         }
 110     }
 111
 112     log_service_stopped(service_name);
 113     notify_listeners(service_event_t::STOPPED);
 114 }
 115
 116 dasynq::rearm service_child_watcher::status_change(eventloop_t &loop, pid_t child, int status) noexcept
 117 {
 118     base_process_service *sr = service;
 119
 120     sr->pid = -1;
 121     sr->exit_status = status;
 122
 123     // Ok, for a process service, any process death which we didn't rig
 124     // ourselves is a bit... unexpected. Probably, the child died because
 125     // we asked it to (sr->service_state == STOPPING). But even if
 126     // we didn't, there's not much we can do.
 127
 128     if (sr->waiting_for_execstat) {
 129         // We still don't have an exec() status from the forked child, wait for that
 130         // before doing any further processing.
 131         return rearm::NOOP; // hold watch reservation
 132     }
 133
 134     // Must stop watch now since handle_exit_status might result in re-launch:
 135     // (stop_watch instead of deregister, so that we hold watch reservation).
 136     stop_watch(loop);
 137
 138     if (sr->stop_timer_armed) {
 139         sr->restart_timer.stop_timer(loop);
 140         sr->stop_timer_armed = false;
 141     }
 142
 143     sr->handle_exit_status(status);
 144     return rearm::NOOP;
 145 }
 146
 147 bool service_record::do_auto_restart() noexcept
 148 {
 149     if (auto_restart) {
 150         return services->get_auto_restart();
 151     }
 152     return false;
 153 }
 154
 155 void service_record::emergency_stop() noexcept
 156 {
 157     if (! do_auto_restart() && start_explicit) {
 158         start_explicit = false;
 159         release();
 160     }
 161     forced_stop();
 162     stop_dependents();
 163     stopped();
 164 }
 165
 166 void base_process_service::do_smooth_recovery() noexcept
 167 {
 168     if (! restart_ps_process()) {
 169         emergency_stop();
 170         services->process_queues();
 171     }
 172 }
 173
 174 void process_service::handle_exit_status(int exit_status) noexcept
 175 {
 176     bool did_exit = WIFEXITED(exit_status);
 177     bool was_signalled = WIFSIGNALED(exit_status);
 178     restarting = false;
 179     auto service_state = get_state();
 180
 181     if (exit_status != 0 && service_state != service_state_t::STOPPING) {
 182         if (did_exit) {
 183             log(loglevel_t::ERROR, "Service ", get_name(), " process terminated with exit code ",
 184                     WEXITSTATUS(exit_status));
 185         }
 186         else if (was_signalled) {
 187             log(loglevel_t::ERROR, "Service ", get_name(), " terminated due to signal ",
 188                     WTERMSIG(exit_status));
 189         }
 190     }
 191
 192     if (service_state == service_state_t::STARTING) {
 193         if (did_exit && WEXITSTATUS(exit_status) == 0) {
 194             started();
 195         }
 196         else {
 197             failed_to_start();
 198         }
 199     }
 200     else if (service_state == service_state_t::STOPPING) {
 201         // We won't log a non-zero exit status or termination due to signal here -
 202         // we assume that the process died because we signalled it.
 203         stopped();
 204     }
 205     else if (smooth_recovery && service_state == service_state_t::STARTED
 206             && get_target_state() == service_state_t::STARTED) {
 207         do_smooth_recovery();
 208         return;
 209     }
 210     else {
 211         emergency_stop();
 212     }
 213     services->process_queues();
 214 }
 215
 216 void process_service::exec_failed(int errcode) noexcept
 217 {
 218     log(loglevel_t::ERROR, get_name(), ": execution failed: ", strerror(errcode));
 219     if (get_state() == service_state_t::STARTING) {
 220         failed_to_start();
 221     }
 222     else {
 223         // Process service in smooth recovery:
 224         emergency_stop();
 225     }
 226 }
 227
 228 void bgproc_service::handle_exit_status(int exit_status) noexcept
 229 {
 230     begin:
 231     bool did_exit = WIFEXITED(exit_status);
 232     bool was_signalled = WIFSIGNALED(exit_status);
 233     auto service_state = get_state();
 234
 235     if (exit_status != 0 && service_state != service_state_t::STOPPING) {
 236         if (did_exit) {
 237             log(loglevel_t::ERROR, "Service ", get_name(), " process terminated with exit code ",
 238                     WEXITSTATUS(exit_status));
 239         }
 240         else if (was_signalled) {
 241             log(loglevel_t::ERROR, "Service ", get_name(), " terminated due to signal ",
 242                     WTERMSIG(exit_status));
 243         }
 244     }
 245
 246     // This may be a "smooth recovery" where we are restarting the process while leaving the
 247     // service in the STARTED state.
 248     if (restarting && service_state == service_state_t::STARTED) {
 249         restarting = false;
 250         bool need_stop = false;
 251         if ((did_exit && WEXITSTATUS(exit_status) != 0) || was_signalled) {
 252             need_stop = true;
 253         }
 254         else {
 255             // We need to re-read the PID, since it has now changed.
 256             if (pid_file.length() != 0) {
 257                 auto pid_result = read_pid_file(&exit_status);
 258                 switch (pid_result) {
 259                     case pid_result_t::FAILED:
 260                         // Failed startup: no auto-restart.
 261                         need_stop = true;
 262                         break;
 263                     case pid_result_t::TERMINATED:
 264                         goto begin;
 265                     case pid_result_t::OK:
 266                         break;
 267                 }
 268             }
 269         }
 270
 271         if (need_stop) {
 272             // Failed startup: no auto-restart.
 273             emergency_stop();
 274             services->process_queues();
 275         }
 276
 277         return;
 278     }
 279
 280     restarting = false;
 281     if (service_state == service_state_t::STARTING) {
 282         // POSIX requires that if the process exited clearly with a status code of 0,
 283         // the exit status value will be 0:
 284         if (exit_status == 0) {
 285             auto pid_result = read_pid_file(&exit_status);
 286             switch (pid_result) {
 287                 case pid_result_t::FAILED:
 288                     // Failed startup: no auto-restart.
 289                     failed_to_start();
 290                     break;
 291                 case pid_result_t::TERMINATED:
 292                     // started, but immediately terminated
 293                     started();
 294                     goto begin;
 295                 case pid_result_t::OK:
 296                     started();
 297                     break;
 298             }
 299         }
 300         else {
 301             failed_to_start();
 302         }
 303     }
 304     else if (service_state == service_state_t::STOPPING) {
 305         // We won't log a non-zero exit status or termination due to signal here -
 306         // we assume that the process died because we signalled it.
 307         stopped();
 308     }
 309     else if (smooth_recovery && service_state == service_state_t::STARTED
 310             && get_target_state() == service_state_t::STARTED) {
 311         do_smooth_recovery();
 312         return;
 313     }
 314     else {
 315         // we must be STARTED
 316         if (! do_auto_restart() && start_explicit) {
 317             start_explicit = false;
 318             release();
 319         }
 320         forced_stop();
 321         stop_dependents();
 322         stopped();
 323     }
 324     services->process_queues();
 325 }
 326
 327 void bgproc_service::exec_failed(int errcode) noexcept
 328 {
 329     log(loglevel_t::ERROR, get_name(), ": execution failed: ", strerror(errcode));
 330     // Only time we execute is for startup:
 331     failed_to_start();
 332 }
 333
 334 void scripted_service::handle_exit_status(int exit_status) noexcept
 335 {
 336     bool did_exit = WIFEXITED(exit_status);
 337     bool was_signalled = WIFSIGNALED(exit_status);
 338     auto service_state = get_state();
 339
 340     if (service_state == service_state_t::STOPPING) {
 341         // We might be running the stop script, or we might be running the start script and have issued
 342         // a cancel order via SIGINT:
 343         if (did_exit && WEXITSTATUS(exit_status) == 0) {
 344             if (interrupting_start) {
 345                 interrupting_start = false;
 346                 // launch stop script:
 347                 bring_down();
 348             }
 349             else {
 350                 // We were running the stop script and finished successfully
 351                 stopped();
 352             }
 353         }
 354         else {
 355             if (interrupting_start) {
 356                 // We issued a start interrupt, so we expected this failure:
 357                 if (did_exit) {
 358                     log(loglevel_t::INFO, "Service ", get_name(), " start cancelled; exit code ",
 359                             WEXITSTATUS(exit_status));
 360                 }
 361                 else if (was_signalled) {
 362                     log(loglevel_t::INFO, "Service ", get_name(), " start cancelled from signal ",
 363                             WTERMSIG(exit_status));
 364                 }
 365             }
 366             else {
 367                 // ??? failed to stop! Let's log it as warning:
 368                 if (did_exit) {
 369                     log(loglevel_t::WARN, "Service ", get_name(), " stop command failed with exit code ",
 370                             WEXITSTATUS(exit_status));
 371                 }
 372                 else if (was_signalled) {
 373                     log(loglevel_t::WARN, "Service ", get_name(), " stop command terminated due to signal ",
 374                             WTERMSIG(exit_status));
 375                 }
 376             }
 377             // Just assume that we stopped, so that any dependencies
 378             // can be stopped:
 379             interrupting_start = false;
 380             stopped();
 381         }
 382         services->process_queues();
 383     }
 384     else { // STARTING
 385         if (exit_status == 0) {
 386             started();
 387         }
 388         else {
 389             // failed to start
 390             if (did_exit) {
 391                 log(loglevel_t::ERROR, "Service ", get_name(), " command failed with exit code ",
 392                         WEXITSTATUS(exit_status));
 393             }
 394             else if (was_signalled) {
 395                 log(loglevel_t::ERROR, "Service ", get_name(), " command terminated due to signal ",
 396                         WTERMSIG(exit_status));
 397             }
 398             failed_to_start();
 399         }
 400         services->process_queues();
 401     }
 402 }
 403
 404 void scripted_service::exec_failed(int errcode) noexcept
 405 {
 406     log(loglevel_t::ERROR, get_name(), ": execution failed: ", strerror(errcode));
 407     auto service_state = get_state();
 408     if (service_state == service_state_t::STARTING) {
 409         failed_to_start();
 410     }
 411     else if (service_state == service_state_t::STOPPING) {
 412         // We've logged the failure, but it's probably better not to leave the service in
 413         // STOPPING state:
 414         stopped();
 415     }
 416 }
 417
 418 rearm exec_status_pipe_watcher::fd_event(eventloop_t &loop, int fd, int flags) noexcept
 419 {
 420     base_process_service *sr = service;
 421     sr->waiting_for_execstat = false;
 422
 423     int exec_status;
 424     int r = read(get_watched_fd(), &exec_status, sizeof(int));
 425     deregister(loop);
 426     close(get_watched_fd());
 427
 428     if (r > 0) {
 429         // We read an errno code; exec() failed, and the service startup failed.
 430         if (sr->pid != -1) {
 431             sr->child_listener.deregister(eventLoop, sr->pid);
 432             sr->reserved_child_watch = false;
 433             if (sr->stop_timer_armed) {
 434                 sr->restart_timer.stop_timer(loop);
 435                 sr->stop_timer_armed = false;
 436             }
 437         }
 438         sr->pid = -1;
 439         sr->exec_failed(exec_status);
 440     }
 441     else {
 442         // exec() succeeded.
 443         if (sr->get_type() == service_type_t::PROCESS) {
 444             // This could be a smooth recovery (state already STARTED). Even more, the process
 445             // might be stopped (and killed via a signal) during smooth recovery.  We don't to
 446             // process startup again in either case, so we check for state STARTING:
 447             if (sr->get_state() == service_state_t::STARTING) {
 448                 sr->started();
 449             }
 450             else if (sr->get_state() == service_state_t::STOPPING) {
 451                 // stopping, but smooth recovery was in process. That's now over so we can
 452                 // commence normal stop. Note that if pid == -1 the process already stopped(!),
 453                 // that's handled below.
 454                 if (sr->pid != -1 && sr->stop_check_dependents()) {
 455                     sr->bring_down();
 456                 }
 457             }
 458         }
 459
 460         if (sr->pid == -1) {
 461             // Somehow the process managed to complete before we even saw the status.
 462             sr->handle_exit_status(sr->exit_status);
 463         }
 464     }
 465
 466     sr->services->process_queues();
 467
 468     return rearm::REMOVED;
 469 }
 470
 471 void service_record::require() noexcept
 472 {
 473     if (required_by++ == 0) {
 474         prop_require = !prop_release;
 475         prop_release = false;
 476         services->add_prop_queue(this);
 477     }
 478 }
 479
 480 void service_record::release() noexcept
 481 {
 482     if (--required_by == 0) {
 483         desired_state = service_state_t::STOPPED;
 484
 485         // Can stop, and can release dependencies now. We don't need to issue a release if
 486         // the require was pending though:
 487         prop_release = !prop_require;
 488         prop_require = false;
 489         services->add_prop_queue(this);
 490
 491         if (service_state == service_state_t::STOPPED) {
 492             services->service_inactive(this);
 493         }
 494         else {
 495             do_stop();
 496         }
 497     }
 498 }
 499
 500 void service_record::release_dependencies() noexcept
 501 {
 502     for (auto & dependency : depends_on) {
 503         service_record * dep_to = dependency.get_to();
 504         if (dependency.holding_acq) {
 505             dep_to->release();
 506             dependency.holding_acq = false;
 507         }
 508     }
 509 }
 510
 511 void service_record::start(bool activate) noexcept
 512 {
 513     if (activate && ! start_explicit) {
 514         require();
 515         start_explicit = true;
 516     }
 517
 518     if (desired_state == service_state_t::STARTED && service_state != service_state_t::STOPPED) return;
 519
 520     bool was_active = service_state != service_state_t::STOPPED || desired_state != service_state_t::STOPPED;
 521     desired_state = service_state_t::STARTED;
 522
 523     if (service_state != service_state_t::STOPPED) {
 524         // We're already starting/started, or we are stopping and need to wait for
 525         // that the complete.
 526         if (service_state != service_state_t::STOPPING || ! can_interrupt_stop()) {
 527             return;
 528         }
 529         // We're STOPPING, and that can be interrupted. Our dependencies might be STOPPING,
 530         // but if so they are waiting (for us), so they too can be instantly returned to
 531         // STARTING state.
 532         notify_listeners(service_event_t::STOPCANCELLED);
 533     }
 534     else if (! was_active) {
 535         services->service_active(this);
 536     }
 537
 538     service_state = service_state_t::STARTING;
 539     waiting_for_deps = true;
 540
 541     if (start_check_dependencies()) {
 542         services->add_transition_queue(this);
 543     }
 544 }
 545
 546 void service_record::do_propagation() noexcept
 547 {
 548     if (prop_require) {
 549         // Need to require all our dependencies
 550         for (auto & dep : depends_on) {
 551             dep.get_to()->require();
 552             dep.holding_acq = true;
 553         }
 554         prop_require = false;
 555     }
 556
 557     if (prop_release) {
 558         release_dependencies();
 559         prop_release = false;
 560     }
 561
 562     if (prop_failure) {
 563         prop_failure = false;
 564         failed_to_start(true);
 565     }
 566
 567     if (prop_start) {
 568         prop_start = false;
 569         start(false);
 570     }
 571
 572     if (prop_stop) {
 573         prop_stop = false;
 574         do_stop();
 575     }
 576 }
 577
 578 void service_record::execute_transition() noexcept
 579 {
 580     // state is STARTED with restarting set true if we are running a smooth recovery.
 581     if (service_state == service_state_t::STARTING || (service_state == service_state_t::STARTED
 582             && restarting)) {
 583         if (check_deps_started()) {
 584             bool have_console = service_state == service_state_t::STARTED && onstart_flags.runs_on_console;
 585             all_deps_started(have_console);
 586         }
 587     }
 588     else if (service_state == service_state_t::STOPPING) {
 589         if (stop_check_dependents()) {
 590             bring_down();
 591         }
 592     }
 593 }
 594
 595 void service_record::do_start() noexcept
 596 {
 597     if (pinned_stopped) return;
 598
 599     if (service_state != service_state_t::STARTING) {
 600         return;
 601     }
 602
 603     service_state = service_state_t::STARTING;
 604
 605     waiting_for_deps = true;
 606
 607     // Ask dependencies to start, mark them as being waited on.
 608     if (check_deps_started()) {
 609         // Once all dependencies are started, we start properly:
 610         all_deps_started();
 611     }
 612 }
 613
 614 void service_record::dependency_started() noexcept
 615 {
 616     if ((service_state == service_state_t::STARTING || service_state == service_state_t::STARTED)
 617             && waiting_for_deps) {
 618         services->add_transition_queue(this);
 619     }
 620 }
 621
 622 bool service_record::start_check_dependencies() noexcept
 623 {
 624     bool all_deps_started = true;
 625
 626     for (auto & dep : depends_on) {
 627         service_record * to = dep.get_to();
 628         if (to->service_state != service_state_t::STARTED) {
 629             if (to->service_state != service_state_t::STARTING) {
 630                 to->prop_start = true;
 631                 services->add_prop_queue(to);
 632             }
 633             dep.waiting_on = true;
 634             all_deps_started = false;
 635         }
 636     }
 637
 638     return all_deps_started;
 639 }
 640
 641 bool service_record::check_deps_started() noexcept
 642 {
 643     for (auto & dep : depends_on) {
 644         if (dep.waiting_on) {
 645             return false;
 646         }
 647     }
 648
 649     return true;
 650 }
 651
 652 bool service_record::open_socket() noexcept
 653 {
 654     if (socket_path.empty() || socket_fd != -1) {
 655         // No socket, or already open
 656         return true;
 657     }
 658
 659     const char * saddrname = socket_path.c_str();
 660
 661     // Check the specified socket path
 662     struct stat stat_buf;
 663     if (stat(saddrname, &stat_buf) == 0) {
 664         if ((stat_buf.st_mode & S_IFSOCK) == 0) {
 665             // Not a socket
 666             log(loglevel_t::ERROR, service_name, ": Activation socket file exists (and is not a socket)");
 667             return false;
 668         }
 669     }
 670     else if (errno != ENOENT) {
 671         // Other error
 672         log(loglevel_t::ERROR, service_name, ": Error checking activation socket: ", strerror(errno));
 673         return false;
 674     }
 675
 676     // Remove stale socket file (if it exists).
 677     // We won't test the return from unlink - if it fails other than due to ENOENT, we should get an
 678     // error when we try to create the socket anyway.
 679     unlink(saddrname);
 680
 681     uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + socket_path.length() + 1;
 682     struct sockaddr_un * name = static_cast<sockaddr_un *>(malloc(sockaddr_size));
 683     if (name == nullptr) {
 684         log(loglevel_t::ERROR, service_name, ": Opening activation socket: out of memory");
 685         return false;
 686     }
 687
 688     name->sun_family = AF_UNIX;
 689     strcpy(name->sun_path, saddrname);
 690
 691     int sockfd = dinit_socket(AF_UNIX, SOCK_STREAM, 0, SOCK_NONBLOCK | SOCK_CLOEXEC);
 692     if (sockfd == -1) {
 693         log(loglevel_t::ERROR, service_name, ": Error creating activation socket: ", strerror(errno));
 694         free(name);
 695         return false;
 696     }
 697
 698     if (bind(sockfd, (struct sockaddr *) name, sockaddr_size) == -1) {
 699         log(loglevel_t::ERROR, service_name, ": Error binding activation socket: ", strerror(errno));
 700         close(sockfd);
 701         free(name);
 702         return false;
 703     }
 704
 705     free(name);
 706
 707     // POSIX (1003.1, 2013) says that fchown and fchmod don't necessarily work on sockets. We have to
 708     // use chown and chmod instead.
 709     if (chown(saddrname, socket_uid, socket_gid)) {
 710         log(loglevel_t::ERROR, service_name, ": Error setting activation socket owner/group: ", strerror(errno));
 711         close(sockfd);
 712         return false;
 713     }
 714
 715     if (chmod(saddrname, socket_perms) == -1) {
 716         log(loglevel_t::ERROR, service_name, ": Error setting activation socket permissions: ", strerror(errno));
 717         close(sockfd);
 718         return false;
 719     }
 720
 721     if (listen(sockfd, 128) == -1) { // 128 "seems reasonable".
 722         log(loglevel_t::ERROR, ": Error listening on activation socket: ", strerror(errno));
 723         close(sockfd);
 724         return false;
 725     }
 726
 727     socket_fd = sockfd;
 728     return true;
 729 }
 730
 731 void service_record::all_deps_started(bool has_console) noexcept
 732 {
 733     if (onstart_flags.starts_on_console && ! has_console) {
 734         waiting_for_deps = true;
 735         queue_for_console();
 736         return;
 737     }
 738
 739     waiting_for_deps = false;
 740
 741     if (! can_proceed_to_start()) {
 742         waiting_for_deps = true;
 743         return;
 744     }
 745
 746     if (! open_socket()) {
 747         failed_to_start();
 748     }
 749
 750     bool start_success = bring_up();
 751     if (! start_success) {
 752         failed_to_start();
 753     }
 754 }
 755
 756 void service_record::acquired_console() noexcept
 757 {
 758     if (service_state != service_state_t::STARTING) {
 759         // We got the console but no longer want it.
 760         release_console();
 761     }
 762     else if (check_deps_started()) {
 763         all_deps_started(true);
 764     }
 765     else {
 766         // We got the console but can't use it yet.
 767         release_console();
 768     }
 769 }
 770
 771 bgproc_service::pid_result_t
 772 bgproc_service::read_pid_file(int *exit_status) noexcept
 773 {
 774     const char *pid_file_c = pid_file.c_str();
 775     int fd = open(pid_file_c, O_CLOEXEC);
 776     if (fd == -1) {
 777         log(loglevel_t::ERROR, get_name(), ": read pid file: ", strerror(errno));
 778         return pid_result_t::FAILED;
 779     }
 780
 781     char pidbuf[21]; // just enough to hold any 64-bit integer
 782     int r = ss_read(fd, pidbuf, 20);
 783     if (r < 0) {
 784         // Could not read from PID file
 785         log(loglevel_t::ERROR, get_name(), ": could not read from pidfile; ", strerror(errno));
 786         close(fd);
 787         return pid_result_t::FAILED;
 788     }
 789
 790     close(fd);
 791     pidbuf[r] = 0; // store nul terminator
 792
 793     bool valid_pid = false;
 794     try {
 795         unsigned long long v = std::stoull(pidbuf, nullptr, 0);
 796         if (v <= std::numeric_limits<pid_t>::max()) {
 797             pid = (pid_t) v;
 798             valid_pid = true;
 799         }
 800     }
 801     catch (std::out_of_range &exc) {
 802         // Too large?
 803     }
 804     catch (std::invalid_argument &exc) {
 805         // Ok, so it doesn't look like a number: proceed...
 806     }
 807
 808     if (valid_pid) {
 809         pid_t wait_r = waitpid(pid, exit_status, WNOHANG);
 810         if (wait_r == -1 && errno == ECHILD) {
 811             // We can't track this child - check process exists:
 812             if (kill(pid, 0) == 0 || errno != ESRCH) {
 813                 tracking_child = false;
 814                 return pid_result_t::OK;
 815             }
 816             else {
 817                 log(loglevel_t::ERROR, get_name(), ": pid read from pidfile (", pid, ") is not valid");
 818                 pid = -1;
 819                 return pid_result_t::FAILED;
 820             }
 821         }
 822         else if (wait_r == pid) {
 823             pid = -1;
 824             return pid_result_t::TERMINATED;
 825         }
 826         else if (wait_r == 0) {
 827             // We can track the child
 828             child_listener.add_reserved(eventLoop, pid, DEFAULT_PRIORITY - 10);
 829             tracking_child = true;
 830             reserved_child_watch = true;
 831             return pid_result_t::OK;
 832         }
 833     }
 834
 835     log(loglevel_t::ERROR, get_name(), ": pid read from pidfile (", pid, ") is not valid");
 836     pid = -1;
 837     return pid_result_t::FAILED;
 838 }
 839
 840 void service_record::started() noexcept
 841 {
 842     if (onstart_flags.starts_on_console && ! onstart_flags.runs_on_console) {
 843         tcsetpgrp(0, getpgrp());
 844         release_console();
 845     }
 846
 847     log_service_started(get_name());
 848     service_state = service_state_t::STARTED;
 849     notify_listeners(service_event_t::STARTED);
 850
 851     if (onstart_flags.rw_ready) {
 852         open_control_socket();
 853     }
 854     if (onstart_flags.log_ready) {
 855         setup_external_log();
 856     }
 857
 858     if (force_stop || desired_state == service_state_t::STOPPED) {
 859         // We must now stop.
 860         do_stop();
 861         return;
 862     }
 863
 864     // Notify any dependents whose desired state is STARTED:
 865     for (auto dept : dependents) {
 866         dept->get_from()->dependency_started();
 867         dept->waiting_on = false;
 868     }
 869 }
 870
 871 void service_record::failed_to_start(bool depfailed) noexcept
 872 {
 873     if (!depfailed && onstart_flags.starts_on_console) {
 874         tcsetpgrp(0, getpgrp());
 875         release_console();
 876     }
 877
 878     log_service_failed(get_name());
 879     service_state = service_state_t::STOPPED;
 880     if (start_explicit) {
 881         start_explicit = false;
 882         release();
 883     }
 884     notify_listeners(service_event_t::FAILEDSTART);
 885
 886     // Cancel start of dependents:
 887     for (auto & dept : dependents) {
 888         switch (dept->dep_type) {
 889         case dependency_type::REGULAR:
 890         case dependency_type::MILESTONE:
 891             if (dept->get_from()->service_state == service_state_t::STARTING) {
 892                 dept->get_from()->prop_failure = true;
 893                 services->add_prop_queue(dept->get_from());
 894             }
 895             break;
 896         case dependency_type::WAITS_FOR:
 897         case dependency_type::SOFT:
 898             if (dept->waiting_on) {
 899                 dept->waiting_on = false;
 900                 dept->get_from()->dependency_started();
 901             }
 902             if (dept->holding_acq) {
 903                 dept->holding_acq = false;
 904                 release();
 905             }
 906         }
 907     }
 908 }
 909
 910 bool service_record::bring_up() noexcept
 911 {
 912     // default implementation: there is no process, so we are started.
 913     started();
 914     return true;
 915 }
 916
 917 bool base_process_service::bring_up() noexcept
 918 {
 919     if (restarting) {
 920         if (pid == -1) {
 921             return restart_ps_process();
 922         }
 923         return true;
 924     }
 925     else {
 926         eventLoop.get_time(restart_interval_time, clock_type::MONOTONIC);
 927         restart_interval_count = 0;
 928         if (start_ps_process(exec_arg_parts, onstart_flags.starts_on_console)) {
 929             if (start_timeout != time_val(0,0)) {
 930                 restart_timer.arm_timer_rel(eventLoop, start_timeout);
 931                 stop_timer_armed = true;
 932             }
 933             else if (stop_timer_armed) {
 934                 restart_timer.stop_timer(eventLoop);
 935                 stop_timer_armed = false;
 936             }
 937             return true;
 938         }
 939         return false;
 940     }
 941 }
 942
 943 bool base_process_service::start_ps_process(const std::vector<const char *> &cmd, bool on_console) noexcept
 944 {
 945     // In general, you can't tell whether fork/exec is successful. We use a pipe to communicate
 946     // success/failure from the child to the parent. The pipe is set CLOEXEC so a successful
 947     // exec closes the pipe, and the parent sees EOF. If the exec is unsuccessful, the errno
 948     // is written to the pipe, and the parent can read it.
 949
 950     eventLoop.get_time(last_start_time, clock_type::MONOTONIC);
 951
 952     int pipefd[2];
 953     if (pipe2(pipefd, O_CLOEXEC)) {
 954         log(loglevel_t::ERROR, get_name(), ": can't create status check pipe: ", strerror(errno));
 955         return false;
 956     }
 957
 958     const char * logfile = this->logfile.c_str();
 959     if (*logfile == 0) {
 960         logfile = "/dev/null";
 961     }
 962
 963     bool child_status_registered = false;
 964     control_conn_t *control_conn = nullptr;
 965
 966     int control_socket[2] = {-1, -1};
 967     if (onstart_flags.pass_cs_fd) {
 968         if (dinit_socketpair(AF_UNIX, SOCK_STREAM, /* protocol */ 0, control_socket, SOCK_NONBLOCK)) {
 969             log(loglevel_t::ERROR, get_name(), ": can't create control socket: ", strerror(errno));
 970             goto out_p;
 971         }
 972
 973         // Make the server side socket close-on-exec:
 974         int fdflags = fcntl(control_socket[0], F_GETFD);
 975         fcntl(control_socket[0], F_SETFD, fdflags | FD_CLOEXEC);
 976
 977         try {
 978             control_conn = new control_conn_t(eventLoop, services, control_socket[0]);
 979         }
 980         catch (std::exception &exc) {
 981             log(loglevel_t::ERROR, get_name(), ": can't launch process; out of memory");
 982             goto out_cs;
 983         }
 984     }
 985
 986     // Set up complete, now fork and exec:
 987
 988     pid_t forkpid;
 989
 990     try {
 991         child_status_listener.add_watch(eventLoop, pipefd[0], IN_EVENTS);
 992         child_status_registered = true;
 993
 994         // We specify a high priority (i.e. low priority value) so that process termination is
 995         // handled early. This means we have always recorded that the process is terminated by the
 996         // time that we handle events that might otherwise cause us to signal the process, so we
 997         // avoid sending a signal to an invalid (and possibly recycled) process ID.
 998         forkpid = child_listener.fork(eventLoop, reserved_child_watch, DEFAULT_PRIORITY - 10);
 999         reserved_child_watch = true;
1000     }
1001     catch (std::exception &e) {
1002         log(loglevel_t::ERROR, get_name(), ": Could not fork: ", e.what());
1003         goto out_cs_h;
1004     }
1005
1006     if (forkpid == 0) {
1007         run_child_proc(cmd.data(), logfile, on_console, pipefd[1], control_socket[1]);
1008     }
1009     else {
1010         // Parent process
1011         close(pipefd[1]); // close the 'other end' fd
1012         if (control_socket[1] != -1) {
1013             close(control_socket[1]);
1014         }
1015         pid = forkpid;
1016
1017         waiting_for_execstat = true;
1018         return true;
1019     }
1020
1021     // Failure exit:
1022
1023     out_cs_h:
1024     if (child_status_registered) {
1025         child_status_listener.deregister(eventLoop);
1026     }
1027
1028     if (onstart_flags.pass_cs_fd) {
1029         delete control_conn;
1030
1031         out_cs:
1032         close(control_socket[0]);
1033         close(control_socket[1]);
1034     }
1035
1036     out_p:
1037     close(pipefd[0]);
1038     close(pipefd[1]);
1039
1040     return false;
1041 }
1042
1043 void service_record::run_child_proc(const char * const *args, const char *logfile, bool on_console,
1044         int wpipefd, int csfd) noexcept
1045 {
1046     // Child process. Must not allocate memory (or otherwise risk throwing any exception)
1047     // from here until exit().
1048
1049     // If the console already has a session leader, presumably it is us. On the other hand
1050     // if it has no session leader, and we don't create one, then control inputs such as
1051     // ^C will have no effect.
1052     bool do_set_ctty = (tcgetsid(0) == -1);
1053
1054     // Copy signal mask, but unmask signals that we masked on startup. For the moment, we'll
1055     // also block all signals, since apparently dup() can be interrupted (!!! really, POSIX??).
1056     sigset_t sigwait_set;
1057     sigset_t sigall_set;
1058     sigfillset(&sigall_set);
1059     sigprocmask(SIG_SETMASK, &sigall_set, &sigwait_set);
1060     sigdelset(&sigwait_set, SIGCHLD);
1061     sigdelset(&sigwait_set, SIGINT);
1062     sigdelset(&sigwait_set, SIGTERM);
1063     sigdelset(&sigwait_set, SIGQUIT);
1064
1065     constexpr int bufsz = ((CHAR_BIT * sizeof(pid_t)) / 3 + 2) + 11;
1066     // "LISTEN_PID=" - 11 characters; the expression above gives a conservative estimate
1067     // on the maxiumum number of bytes required for LISTEN=nnn, including nul terminator,
1068     // where nnn is a pid_t in decimal (i.e. one decimal digit is worth just over 3 bits).
1069     char nbuf[bufsz];
1070
1071     // "DINIT_CS_FD=" - 12 bytes. (we -1 from sizeof(int) in account of sign bit).
1072     constexpr int csenvbufsz = ((CHAR_BIT * sizeof(int) - 1) / 3 + 2) + 12;
1073     char csenvbuf[csenvbufsz];
1074
1075     int minfd = (socket_fd == -1) ? 3 : 4;
1076
1077     // Move wpipefd/csfd to another fd if necessary
1078     if (wpipefd < minfd) {
1079         wpipefd = fcntl(wpipefd, F_DUPFD_CLOEXEC, minfd);
1080         if (wpipefd == -1) goto failure_out;
1081     }
1082
1083     if (csfd != -1 && csfd < minfd) {
1084         csfd = fcntl(csfd, F_DUPFD, minfd);
1085         if (csfd == -1) goto failure_out;
1086     }
1087
1088     if (socket_fd != -1) {
1089
1090         if (dup2(socket_fd, 3) == -1) goto failure_out;
1091         if (socket_fd != 3) {
1092             close(socket_fd);
1093         }
1094
1095         if (putenv(const_cast<char *>("LISTEN_FDS=1"))) goto failure_out;
1096         snprintf(nbuf, bufsz, "LISTEN_PID=%jd", static_cast<intmax_t>(getpid()));
1097         if (putenv(nbuf)) goto failure_out;
1098     }
1099
1100     if (csfd != -1) {
1101         snprintf(csenvbuf, csenvbufsz, "DINIT_CS_FD=%d", csfd);
1102         if (putenv(csenvbuf)) goto failure_out;
1103     }
1104
1105     if (! on_console) {
1106         // Re-set stdin, stdout, stderr
1107         close(0); close(1); close(2);
1108
1109         if (open("/dev/null", O_RDONLY) == 0) {
1110             // stdin = 0. That's what we should have; proceed with opening
1111             // stdout and stderr.
1112             if (open(logfile, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR) != 1) {
1113                 goto failure_out;
1114             }
1115             if (dup2(1, 2) != 2) {
1116                 goto failure_out;
1117             }
1118         }
1119         else goto failure_out;
1120
1121         // We have the option of creating a session and process group, or just a new process
1122         // group. If we just create a new process group, the child process cannot make itself
1123         // a session leader if it wants to do that (eg getty/login will generally want this).
1124         // If we do neither, and we are running with a controlling terminal, a ^C or similar
1125         // will also affect the child process (which probably isn't so bad, though since we
1126         // will handle the shutdown ourselves it's not necessary). Creating a new session
1127         // (and a new process group as part of that) seems like a safe bet, and has the
1128         // advantage of letting us signal the process as part of a process group.
1129         setsid();
1130     }
1131     else {
1132         // "run on console" - run as a foreground job on the terminal/console device
1133
1134         // if do_set_ctty is false, we are the session leader; we are probably running
1135         // as a user process. Don't create a new session leader in that case, and run
1136         // as part of the parent session. Otherwise, the new session cannot claim the
1137         // terminal as a controlling terminal (it is already claimed), meaning that it
1138         // will not see control signals from ^C etc.
1139
1140         if (do_set_ctty) {
1141             // Disable suspend (^Z) (and on some systems, delayed suspend / ^Y)
1142             signal(SIGTSTP, SIG_IGN);
1143
1144             // Become session leader
1145             setsid();
1146             ioctl(0, TIOCSCTTY, 0);
1147         }
1148         setpgid(0,0);
1149         tcsetpgrp(0, getpgrp());
1150     }
1151
1152     sigprocmask(SIG_SETMASK, &sigwait_set, nullptr);
1153
1154     execvp(args[0], const_cast<char **>(args));
1155
1156     // If we got here, the exec failed:
1157     failure_out:
1158     int exec_status = errno;
1159     write(wpipefd, &exec_status, sizeof(int));
1160     _exit(0);
1161 }
1162
1163 // Mark this and all dependent services as force-stopped.
1164 void service_record::forced_stop() noexcept
1165 {
1166     if (service_state != service_state_t::STOPPED) {
1167         force_stop = true;
1168         services->add_transition_queue(this);
1169     }
1170 }
1171
1172 void service_record::dependent_stopped() noexcept
1173 {
1174     if (service_state == service_state_t::STOPPING && waiting_for_deps) {
1175         services->add_transition_queue(this);
1176     }
1177 }
1178
1179 void service_record::stop(bool bring_down) noexcept
1180 {
1181     if (start_explicit) {
1182         start_explicit = false;
1183         release();
1184     }
1185
1186     if (bring_down) {
1187         do_stop();
1188     }
1189 }
1190
1191 void service_record::do_stop() noexcept
1192 {
1193     if (pinned_started) return;
1194
1195     if (start_explicit && ! do_auto_restart()) {
1196         start_explicit = false;
1197         release();
1198         if (required_by == 0) return; // release will re-call us anyway
1199     }
1200
1201     bool all_deps_stopped = stop_dependents();
1202
1203     if (service_state != service_state_t::STARTED) {
1204         if (service_state == service_state_t::STARTING) {
1205             if (! can_interrupt_start()) {
1206                 // Well this is awkward: we're going to have to continue starting. We can stop once we've
1207                 // reached the started state.
1208                 return;
1209             }
1210
1211             if (! interrupt_start()) {
1212                 // Now wait for service startup to actually end; we don't need to handle it here.
1213                 return;
1214             }
1215
1216             // We must have had desired_state == STARTED.
1217             notify_listeners(service_event_t::STARTCANCELLED);
1218
1219             // Reaching this point, we are starting interruptibly - so we
1220             // stop now (by falling through to below).
1221         }
1222         else {
1223             // If we're starting we need to wait for that to complete.
1224             // If we're already stopping/stopped there's nothing to do.
1225             return;
1226         }
1227     }
1228
1229     service_state = service_state_t::STOPPING;
1230     waiting_for_deps = true;
1231     if (all_deps_stopped) {
1232         services->add_transition_queue(this);
1233     }
1234 }
1235
1236 bool service_record::stop_check_dependents() noexcept
1237 {
1238     bool all_deps_stopped = true;
1239     for (auto dept : dependents) {
1240         if (dept->dep_type == dependency_type::REGULAR && ! dept->get_from()->is_stopped()) {
1241             all_deps_stopped = false;
1242             break;
1243         }
1244     }
1245
1246     return all_deps_stopped;
1247 }
1248
1249 bool service_record::stop_dependents() noexcept
1250 {
1251     bool all_deps_stopped = true;
1252     for (auto dept : dependents) {
1253         if (dept->dep_type == dependency_type::REGULAR) {
1254             if (! dept->get_from()->is_stopped()) {
1255                 // Note we check *first* since if the dependent service is not stopped,
1256                 // 1. We will issue a stop to it shortly and
1257                 // 2. It will notify us when stopped, at which point the stop_check_dependents()
1258                 //    check is run anyway.
1259                 all_deps_stopped = false;
1260             }
1261
1262             if (force_stop) {
1263                 // If this service is to be forcefully stopped, dependents must also be.
1264                 dept->get_from()->forced_stop();
1265             }
1266
1267             dept->get_from()->prop_stop = true;
1268             services->add_prop_queue(dept->get_from());
1269         }
1270     }
1271
1272     return all_deps_stopped;
1273 }
1274
1275 // All dependents have stopped; we can stop now, too. Only called when STOPPING.
1276 void service_record::bring_down() noexcept
1277 {
1278     waiting_for_deps = false;
1279     stopped();
1280 }
1281
1282 void base_process_service::kill_pg(int signo) noexcept
1283 {
1284     pid_t pgid = getpgid(pid);
1285     if (pgid == -1) {
1286         // only should happen if pid is invalid, which should never happen...
1287         log(loglevel_t::ERROR, get_name(), ": can't signal process: ", strerror(errno));
1288         return;
1289     }
1290     kill(-pgid, signo);
1291 }
1292
1293 void base_process_service::bring_down() noexcept
1294 {
1295     waiting_for_deps = false;
1296     if (pid != -1) {
1297         // The process is still kicking on - must actually kill it. We signal the process
1298         // group (-pid) rather than just the process as there's less risk then of creating
1299         // an orphaned process group:
1300         if (! onstart_flags.no_sigterm) {
1301             kill_pg(SIGTERM);
1302         }
1303         if (term_signal != -1) {
1304             kill_pg(term_signal);
1305         }
1306
1307         // In most cases, the rest is done in handle_exit_status.
1308         // If we are a BGPROCESS and the process is not our immediate child, however, that
1309         // won't work - check for this now:
1310         if (get_type() == service_type_t::BGPROCESS && ! tracking_child) {
1311             stopped();
1312         }
1313         else if (stop_timeout != time_val(0,0)) {
1314             restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1315             stop_timer_armed = true;
1316         }
1317     }
1318     else {
1319         // The process is already dead.
1320         stopped();
1321     }
1322 }
1323
1324 void process_service::bring_down() noexcept
1325 {
1326     waiting_for_deps = false;
1327     if (waiting_for_execstat) {
1328         // The process is still starting. This should be uncommon, but can occur during
1329         // smooth recovery. We can't do much now; we have to wait until we get the
1330         // status, and then act appropriately.
1331         return;
1332     }
1333     else if (pid != -1) {
1334         // The process is still kicking on - must actually kill it. We signal the process
1335         // group (-pid) rather than just the process as there's less risk then of creating
1336         // an orphaned process group:
1337         if (! onstart_flags.no_sigterm) {
1338             kill_pg(SIGTERM);
1339         }
1340         if (term_signal != -1) {
1341             kill_pg(term_signal);
1342         }
1343
1344         // In most cases, the rest is done in handle_exit_status.
1345         // If we are a BGPROCESS and the process is not our immediate child, however, that
1346         // won't work - check for this now:
1347         if (get_type() == service_type_t::BGPROCESS && ! tracking_child) {
1348             stopped();
1349         }
1350         else if (stop_timeout != time_val(0,0)) {
1351             restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1352             stop_timer_armed = true;
1353         }
1354     }
1355     else {
1356         // The process is already dead.
1357         stopped();
1358     }
1359 }
1360
1361 void scripted_service::bring_down() noexcept
1362 {
1363     waiting_for_deps = false;
1364     if (stop_command.length() == 0) {
1365         stopped();
1366     }
1367     else if (! start_ps_process(stop_arg_parts, false)) {
1368         // Couldn't execute stop script, but there's not much we can do:
1369         stopped();
1370     }
1371     else {
1372         // successfully started stop script: start kill timer:
1373         if (stop_timeout != time_val(0,0)) {
1374             restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1375             stop_timer_armed = true;
1376         }
1377     }
1378 }
1379
1380 void service_record::unpin() noexcept
1381 {
1382     if (pinned_started) {
1383         pinned_started = false;
1384         if (desired_state == service_state_t::STOPPED || force_stop) {
1385             do_stop();
1386             services->process_queues();
1387         }
1388     }
1389     if (pinned_stopped) {
1390         pinned_stopped = false;
1391         if (desired_state == service_state_t::STARTED) {
1392             do_start();
1393             services->process_queues();
1394         }
1395     }
1396 }
1397
1398 void service_record::queue_for_console() noexcept
1399 {
1400     services->append_console_queue(this);
1401 }
1402
1403 void service_record::release_console() noexcept
1404 {
1405     services->pull_console_queue();
1406 }
1407
1408 bool service_record::interrupt_start() noexcept
1409 {
1410     services->unqueue_console(this);
1411     return true;
1412 }
1413
1414 void service_set::service_active(service_record *sr) noexcept
1415 {
1416     active_services++;
1417 }
1418
1419 void service_set::service_inactive(service_record *sr) noexcept
1420 {
1421     active_services--;
1422 }
1423
1424 base_process_service::base_process_service(service_set *sset, string name,
1425         service_type_t service_type_p, string &&command,
1426         std::list<std::pair<unsigned,unsigned>> &command_offsets,
1427         const std::list<prelim_dep> &deplist_p)
1428      : service_record(sset, name, service_type_p, deplist_p), child_listener(this),
1429        child_status_listener(this), restart_timer(this)
1430 {
1431     program_name = std::move(command);
1432     exec_arg_parts = separate_args(program_name, command_offsets);
1433
1434     restart_interval_count = 0;
1435     restart_interval_time = {0, 0};
1436     restart_timer.service = this;
1437     restart_timer.add_timer(eventLoop);
1438
1439     // By default, allow a maximum of 3 restarts within 10.0 seconds:
1440     restart_interval.seconds() = 10;
1441     restart_interval.nseconds() = 0;
1442     max_restart_interval_count = 3;
1443
1444     waiting_restart_timer = false;
1445     reserved_child_watch = false;
1446     tracking_child = false;
1447     stop_timer_armed = false;
1448     start_is_interruptible = false;
1449 }
1450
1451 void base_process_service::do_restart() noexcept
1452 {
1453     waiting_restart_timer = false;
1454     restart_interval_count++;
1455     auto service_state = get_state();
1456
1457     // We may be STARTING (regular restart) or STARTED ("smooth recovery"). This affects whether
1458     // the process should be granted access to the console:
1459     bool on_console = service_state == service_state_t::STARTING
1460             ? onstart_flags.starts_on_console : onstart_flags.runs_on_console;
1461
1462     if (service_state == service_state_t::STARTING) {
1463         // for a smooth recovery, we want to check dependencies are available before actually
1464         // starting:
1465         if (! check_deps_started()) {
1466             waiting_for_deps = true;
1467             return;
1468         }
1469     }
1470
1471     if (! start_ps_process(exec_arg_parts, on_console)) {
1472         restarting = false;
1473         if (service_state == service_state_t::STARTING) {
1474             failed_to_start();
1475         }
1476         else {
1477             // desired_state = service_state_t::STOPPED;
1478             forced_stop();
1479         }
1480         services->process_queues();
1481     }
1482 }
1483
1484 bool base_process_service::restart_ps_process() noexcept
1485 {
1486     using time_val = dasynq::time_val;
1487
1488     time_val current_time;
1489     eventLoop.get_time(current_time, clock_type::MONOTONIC);
1490
1491     if (max_restart_interval_count != 0) {
1492         // Check whether we're still in the most recent restart check interval:
1493         time_val int_diff = current_time - restart_interval_time;
1494         if (int_diff < restart_interval) {
1495             if (restart_interval_count >= max_restart_interval_count) {
1496                 log(loglevel_t::ERROR, "Service ", get_name(), " restarting too quickly; stopping.");
1497                 return false;
1498             }
1499         }
1500         else {
1501             restart_interval_time = current_time;
1502             restart_interval_count = 0;
1503         }
1504     }
1505
1506     // Check if enough time has lapsed since the prevous restart. If not, start a timer:
1507     time_val tdiff = current_time - last_start_time;
1508     if (restart_delay <= tdiff) {
1509         // > restart delay (normally 200ms)
1510         do_restart();
1511     }
1512     else {
1513         time_val timeout = restart_delay - tdiff;
1514         restart_timer.arm_timer_rel(eventLoop, timeout);
1515         waiting_restart_timer = true;
1516     }
1517     return true;
1518 }
1519
1520 bool base_process_service::interrupt_start() noexcept
1521 {
1522     if (waiting_restart_timer) {
1523         restart_timer.stop_timer(eventLoop);
1524         waiting_restart_timer = false;
1525         return service_record::interrupt_start();
1526     }
1527     else {
1528         log(loglevel_t::WARN, "Interrupting start of service ", get_name(), " with pid ", pid, " (with SIGINT).");
1529         kill_pg(SIGINT);
1530         if (stop_timeout != time_val(0,0)) {
1531             restart_timer.arm_timer(eventLoop, stop_timeout);
1532             stop_timer_armed = true;
1533         }
1534         else if (stop_timer_armed) {
1535             restart_timer.stop_timer(eventLoop);
1536             stop_timer_armed = false;
1537         }
1538         set_state(service_state_t::STOPPING);
1539         return false;
1540     }
1541 }
1542
1543 void base_process_service::kill_with_fire() noexcept
1544 {
1545     if (pid != -1) {
1546         log(loglevel_t::WARN, "Service ", get_name(), " with pid ", pid, " exceeded allowed stop time; killing.");
1547         kill_pg(SIGKILL);
1548     }
1549 }
1550
1551 dasynq::rearm process_restart_timer::timer_expiry(eventloop_t &, int expiry_count)
1552 {
1553     service->stop_timer_armed = false;
1554
1555     // Timer expires if:
1556     // We are stopping, including after having startup cancelled (stop timeout, state is STOPPING); We are
1557     // starting (start timeout, state is STARTING); We are waiting for restart timer before restarting,
1558     // including smooth recovery (restart timeout, state is STARTING or STARTED).
1559     if (service->get_state() == service_state_t::STOPPING) {
1560         service->kill_with_fire();
1561     }
1562     else if (service->pid != -1) {
1563         // Starting, start timed out.
1564         service->interrupt_start();
1565     }
1566     else {
1567         // STARTING / STARTED, and we have a pid: must be restarting (smooth recovery if STARTED)
1568         service->do_restart();
1569     }
1570
1571     // Leave the timer disabled, or, if it has been reset by any processing above, leave it armed:
1572     return dasynq::rearm::NOOP;
1573 }