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