10 #include <sys/ioctl.h>
12 #include <sys/socket.h>
18 #include "dinit-log.h"
19 #include "dinit-socket.h"
20 #include "dinit-util.h"
23 * service.cc - Service management.
24 * See service.h for details.
28 void open_control_socket(bool report_ro_failure = true) noexcept;
29 void setup_external_log() noexcept;
30 extern eventloop_t eventLoop;
32 // Find the requested service by name
33 static service_record * find_service(const std::list<service_record *> & records,
34 const char *name) noexcept
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) {
46 service_record * service_set::find_service(const std::string &name) noexcept
48 return ::find_service(records, name.c_str());
51 void service_set::stop_service(const std::string & name) noexcept
53 service_record *record = find_service(name);
54 if (record != nullptr) {
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
64 if (onstart_flags.runs_on_console) {
65 tcsetpgrp(0, getpgrp());
66 discard_console_log_buffer();
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;
82 bool will_restart = (desired_state == service_state_t::STARTED)
83 && services->get_auto_restart();
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();
90 service_state = service_state_t::STOPPED;
93 // Desired state is "started".
98 if (socket_fd != -1) {
103 if (start_explicit) {
104 start_explicit = false;
107 else if (required_by == 0) {
108 services->service_inactive(this);
112 log_service_stopped(service_name);
113 notify_listeners(service_event_t::STOPPED);
116 dasynq::rearm service_child_watcher::status_change(eventloop_t &loop, pid_t child, int status) noexcept
118 base_process_service *sr = service;
121 sr->exit_status = status;
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.
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
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).
138 if (sr->stop_timer_armed) {
139 sr->restart_timer.stop_timer(loop);
140 sr->stop_timer_armed = false;
143 sr->handle_exit_status(status);
147 bool service_record::do_auto_restart() noexcept
150 return services->get_auto_restart();
155 void service_record::emergency_stop() noexcept
157 if (! do_auto_restart() && start_explicit) {
158 start_explicit = false;
166 void base_process_service::do_smooth_recovery() noexcept
168 if (! restart_ps_process()) {
170 services->process_queues();
174 void process_service::handle_exit_status(int exit_status) noexcept
176 bool did_exit = WIFEXITED(exit_status);
177 bool was_signalled = WIFSIGNALED(exit_status);
180 if (exit_status != 0 && service_state != service_state_t::STOPPING) {
182 log(loglevel_t::ERROR, "Service ", service_name, " process terminated with exit code ",
183 WEXITSTATUS(exit_status));
185 else if (was_signalled) {
186 log(loglevel_t::ERROR, "Service ", service_name, " terminated due to signal ",
187 WTERMSIG(exit_status));
191 if (service_state == service_state_t::STARTING) {
192 if (did_exit && WEXITSTATUS(exit_status) == 0) {
199 else if (service_state == service_state_t::STOPPING) {
200 // We won't log a non-zero exit status or termination due to signal here -
201 // we assume that the process died because we signalled it.
204 else if (smooth_recovery && service_state == service_state_t::STARTED
205 && desired_state == service_state_t::STARTED) {
206 do_smooth_recovery();
212 services->process_queues();
215 void process_service::exec_failed(int errcode) noexcept
217 log(loglevel_t::ERROR, service_name, ": execution failed: ", strerror(errcode));
218 if (service_state == service_state_t::STARTING) {
222 // Process service in smooth recovery:
227 void bgproc_service::handle_exit_status(int exit_status) noexcept
230 bool did_exit = WIFEXITED(exit_status);
231 bool was_signalled = WIFSIGNALED(exit_status);
233 if (exit_status != 0 && service_state != service_state_t::STOPPING) {
235 log(loglevel_t::ERROR, "Service ", service_name, " process terminated with exit code ",
236 WEXITSTATUS(exit_status));
238 else if (was_signalled) {
239 log(loglevel_t::ERROR, "Service ", service_name, " terminated due to signal ",
240 WTERMSIG(exit_status));
244 // This may be a "smooth recovery" where we are restarting the process while leaving the
245 // service in the STARTED state.
246 if (restarting && service_state == service_state_t::STARTED) {
248 bool need_stop = false;
249 if ((did_exit && WEXITSTATUS(exit_status) != 0) || was_signalled) {
253 // We need to re-read the PID, since it has now changed.
254 if (pid_file.length() != 0) {
255 auto pid_result = read_pid_file(&exit_status);
256 switch (pid_result) {
257 case pid_result_t::FAILED:
258 // Failed startup: no auto-restart.
261 case pid_result_t::TERMINATED:
263 case pid_result_t::OK:
270 // Failed startup: no auto-restart.
272 services->process_queues();
279 if (service_state == service_state_t::STARTING) {
280 // POSIX requires that if the process exited clearly with a status code of 0,
281 // the exit status value will be 0:
282 if (exit_status == 0) {
283 auto pid_result = read_pid_file(&exit_status);
284 switch (pid_result) {
285 case pid_result_t::FAILED:
286 // Failed startup: no auto-restart.
289 case pid_result_t::TERMINATED:
290 // started, but immediately terminated
293 case pid_result_t::OK:
302 else if (service_state == service_state_t::STOPPING) {
303 // We won't log a non-zero exit status or termination due to signal here -
304 // we assume that the process died because we signalled it.
307 else if (smooth_recovery && service_state == service_state_t::STARTED && desired_state == service_state_t::STARTED) {
308 do_smooth_recovery();
312 // we must be STARTED
313 if (! do_auto_restart() && start_explicit) {
314 start_explicit = false;
321 services->process_queues();
324 void bgproc_service::exec_failed(int errcode) noexcept
326 log(loglevel_t::ERROR, service_name, ": execution failed: ", strerror(errcode));
327 // Only time we execute is for startup:
331 void scripted_service::handle_exit_status(int exit_status) noexcept
333 bool did_exit = WIFEXITED(exit_status);
334 bool was_signalled = WIFSIGNALED(exit_status);
336 if (service_state == service_state_t::STOPPING) {
337 if (did_exit && WEXITSTATUS(exit_status) == 0) {
341 // ??? failed to stop! Let's log it as info:
343 log(loglevel_t::INFO, "Service ", service_name, " stop command failed with exit code ",
344 WEXITSTATUS(exit_status));
346 else if (was_signalled) {
347 log(loglevel_t::INFO, "Service ", service_name, " stop command terminated due to signal ",
348 WTERMSIG(exit_status));
350 // Just assume that we stopped, so that any dependencies
354 services->process_queues();
357 if (exit_status == 0) {
363 log(loglevel_t::ERROR, "Service ", service_name, " command failed with exit code ",
364 WEXITSTATUS(exit_status));
366 else if (was_signalled) {
367 log(loglevel_t::ERROR, "Service ", service_name, " command terminated due to signal ",
368 WTERMSIG(exit_status));
372 services->process_queues();
376 void scripted_service::exec_failed(int errcode) noexcept
378 log(loglevel_t::ERROR, service_name, ": execution failed: ", strerror(errcode));
379 if (service_state == service_state_t::STARTING) {
382 else if (service_state == service_state_t::STOPPING) {
383 // We've logged the failure, but it's probably better not to leave the service in
389 rearm exec_status_pipe_watcher::fd_event(eventloop_t &loop, int fd, int flags) noexcept
391 base_process_service *sr = service;
392 sr->waiting_for_execstat = false;
395 int r = read(get_watched_fd(), &exec_status, sizeof(int));
397 close(get_watched_fd());
400 // We read an errno code; exec() failed, and the service startup failed.
402 sr->child_listener.deregister(eventLoop, sr->pid);
403 sr->reserved_child_watch = false;
404 if (sr->stop_timer_armed) {
405 sr->restart_timer.stop_timer(loop);
406 sr->stop_timer_armed = false;
410 sr->exec_failed(exec_status);
414 if (sr->record_type == service_type::PROCESS) {
415 // This could be a smooth recovery (state already STARTED). Even more, the process
416 // might be stopped (and killed via a signal) during smooth recovery. We don't to
417 // process startup again in either case, so we check for state STARTING:
418 if (sr->service_state == service_state_t::STARTING) {
421 else if (sr->service_state == service_state_t::STOPPING) {
422 // stopping, but smooth recovery was in process. That's now over so we can
423 // commence normal stop. Note that if pid == -1 the process already stopped(!),
424 // that's handled below.
425 if (sr->pid != -1 && sr->stop_check_dependents()) {
426 sr->all_deps_stopped();
432 // Somehow the process managed to complete before we even saw the status.
433 sr->handle_exit_status(sr->exit_status);
437 sr->services->process_queues();
439 return rearm::REMOVED;
442 void service_record::require() noexcept
444 if (required_by++ == 0) {
445 prop_require = !prop_release;
446 prop_release = false;
447 services->add_prop_queue(this);
451 void service_record::release() noexcept
453 if (--required_by == 0) {
454 desired_state = service_state_t::STOPPED;
456 // Can stop, and can release dependencies now. We don't need to issue a release if
457 // the require was pending though:
458 prop_release = !prop_require;
459 prop_require = false;
460 services->add_prop_queue(this);
462 if (service_state == service_state_t::STOPPED) {
463 services->service_inactive(this);
471 void service_record::release_dependencies() noexcept
473 for (auto & dependency : depends_on) {
474 service_record * dep_to = dependency.get_to();
475 if (dependency.holding_acq) {
477 dependency.holding_acq = false;
482 void service_record::start(bool activate) noexcept
484 if (activate && ! start_explicit) {
486 start_explicit = true;
489 if (desired_state == service_state_t::STARTED && service_state != service_state_t::STOPPED) return;
491 bool was_active = service_state != service_state_t::STOPPED || desired_state != service_state_t::STOPPED;
492 desired_state = service_state_t::STARTED;
494 if (service_state != service_state_t::STOPPED) {
495 // We're already starting/started, or we are stopping and need to wait for
496 // that the complete.
497 if (service_state != service_state_t::STOPPING || ! can_interrupt_stop()) {
500 // We're STOPPING, and that can be interrupted. Our dependencies might be STOPPING,
501 // but if so they are waiting (for us), so they too can be instantly returned to
503 notify_listeners(service_event_t::STOPCANCELLED);
505 else if (! was_active) {
506 services->service_active(this);
509 service_state = service_state_t::STARTING;
510 waiting_for_deps = true;
512 if (start_check_dependencies()) {
513 services->add_transition_queue(this);
517 void service_record::do_propagation() noexcept
520 // Need to require all our dependencies
521 for (auto & dep : depends_on) {
522 dep.get_to()->require();
523 dep.holding_acq = true;
525 prop_require = false;
529 release_dependencies();
530 prop_release = false;
534 prop_failure = false;
535 failed_to_start(true);
549 void service_record::execute_transition() noexcept
551 // state is STARTED with restarting set true if we are running a smooth recovery.
552 if (service_state == service_state_t::STARTING || (service_state == service_state_t::STARTED
554 if (check_deps_started()) {
555 bool have_console = service_state == service_state_t::STARTED && onstart_flags.runs_on_console;
556 all_deps_started(have_console);
559 else if (service_state == service_state_t::STOPPING) {
560 if (stop_check_dependents()) {
566 void service_record::do_start() noexcept
568 if (pinned_stopped) return;
570 if (service_state != service_state_t::STARTING) {
574 service_state = service_state_t::STARTING;
576 waiting_for_deps = true;
578 // Ask dependencies to start, mark them as being waited on.
579 if (check_deps_started()) {
580 // Once all dependencies are started, we start properly:
585 void service_record::dependency_started() noexcept
587 if ((service_state == service_state_t::STARTING || service_state == service_state_t::STARTED)
588 && waiting_for_deps) {
589 services->add_transition_queue(this);
593 bool service_record::start_check_dependencies() noexcept
595 bool all_deps_started = true;
597 for (auto & dep : depends_on) {
598 service_record * to = dep.get_to();
599 if (to->service_state != service_state_t::STARTED) {
600 if (to->service_state != service_state_t::STARTING) {
601 to->prop_start = true;
602 services->add_prop_queue(to);
604 dep.waiting_on = true;
605 all_deps_started = false;
609 return all_deps_started;
612 bool service_record::check_deps_started() noexcept
614 for (auto & dep : depends_on) {
615 if (dep.waiting_on) {
623 bool service_record::open_socket() noexcept
625 if (socket_path.empty() || socket_fd != -1) {
626 // No socket, or already open
630 const char * saddrname = socket_path.c_str();
632 // Check the specified socket path
633 struct stat stat_buf;
634 if (stat(saddrname, &stat_buf) == 0) {
635 if ((stat_buf.st_mode & S_IFSOCK) == 0) {
637 log(loglevel_t::ERROR, service_name, ": Activation socket file exists (and is not a socket)");
641 else if (errno != ENOENT) {
643 log(loglevel_t::ERROR, service_name, ": Error checking activation socket: ", strerror(errno));
647 // Remove stale socket file (if it exists).
648 // We won't test the return from unlink - if it fails other than due to ENOENT, we should get an
649 // error when we try to create the socket anyway.
652 uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + socket_path.length() + 1;
653 struct sockaddr_un * name = static_cast<sockaddr_un *>(malloc(sockaddr_size));
654 if (name == nullptr) {
655 log(loglevel_t::ERROR, service_name, ": Opening activation socket: out of memory");
659 name->sun_family = AF_UNIX;
660 strcpy(name->sun_path, saddrname);
662 int sockfd = dinit_socket(AF_UNIX, SOCK_STREAM, 0, SOCK_NONBLOCK | SOCK_CLOEXEC);
664 log(loglevel_t::ERROR, service_name, ": Error creating activation socket: ", strerror(errno));
669 if (bind(sockfd, (struct sockaddr *) name, sockaddr_size) == -1) {
670 log(loglevel_t::ERROR, service_name, ": Error binding activation socket: ", strerror(errno));
678 // POSIX (1003.1, 2013) says that fchown and fchmod don't necessarily work on sockets. We have to
679 // use chown and chmod instead.
680 if (chown(saddrname, socket_uid, socket_gid)) {
681 log(loglevel_t::ERROR, service_name, ": Error setting activation socket owner/group: ", strerror(errno));
686 if (chmod(saddrname, socket_perms) == -1) {
687 log(loglevel_t::ERROR, service_name, ": Error setting activation socket permissions: ", strerror(errno));
692 if (listen(sockfd, 128) == -1) { // 128 "seems reasonable".
693 log(loglevel_t::ERROR, ": Error listening on activation socket: ", strerror(errno));
702 void service_record::all_deps_started(bool has_console) noexcept
704 if (onstart_flags.starts_on_console && ! has_console) {
705 waiting_for_deps = true;
710 waiting_for_deps = false;
712 if (! can_proceed_to_start()) {
713 waiting_for_deps = true;
717 if (! open_socket()) {
721 bool start_success = start_ps_process();
722 if (! start_success) {
727 void service_record::acquired_console() noexcept
729 if (service_state != service_state_t::STARTING) {
730 // We got the console but no longer want it.
733 else if (check_deps_started()) {
734 all_deps_started(true);
737 // We got the console but can't use it yet.
742 bgproc_service::pid_result_t
743 bgproc_service::read_pid_file(int *exit_status) noexcept
745 const char *pid_file_c = pid_file.c_str();
746 int fd = open(pid_file_c, O_CLOEXEC);
748 log(loglevel_t::ERROR, service_name, ": read pid file: ", strerror(errno));
749 return pid_result_t::FAILED;
752 char pidbuf[21]; // just enough to hold any 64-bit integer
753 int r = ss_read(fd, pidbuf, 20);
755 // Could not read from PID file
756 log(loglevel_t::ERROR, service_name, ": could not read from pidfile; ", strerror(errno));
758 return pid_result_t::FAILED;
762 pidbuf[r] = 0; // store nul terminator
764 bool valid_pid = false;
766 unsigned long long v = std::stoull(pidbuf, nullptr, 0);
767 if (v <= std::numeric_limits<pid_t>::max()) {
772 catch (std::out_of_range &exc) {
775 catch (std::invalid_argument &exc) {
776 // Ok, so it doesn't look like a number: proceed...
780 pid_t wait_r = waitpid(pid, exit_status, WNOHANG);
781 if (wait_r == -1 && errno == ECHILD) {
782 // We can't track this child - check process exists:
783 if (kill(pid, 0) == 0 || errno != ESRCH) {
784 tracking_child = false;
785 return pid_result_t::OK;
788 log(loglevel_t::ERROR, service_name, ": pid read from pidfile (", pid, ") is not valid");
790 return pid_result_t::FAILED;
793 else if (wait_r == pid) {
795 return pid_result_t::TERMINATED;
797 else if (wait_r == 0) {
798 // We can track the child
799 child_listener.add_reserved(eventLoop, pid, DEFAULT_PRIORITY - 10);
800 tracking_child = true;
801 reserved_child_watch = true;
802 return pid_result_t::OK;
806 log(loglevel_t::ERROR, service_name, ": pid read from pidfile (", pid, ") is not valid");
808 return pid_result_t::FAILED;
811 void service_record::started() noexcept
813 if (onstart_flags.starts_on_console && ! onstart_flags.runs_on_console) {
814 tcsetpgrp(0, getpgrp());
818 log_service_started(service_name);
819 service_state = service_state_t::STARTED;
820 notify_listeners(service_event_t::STARTED);
822 if (onstart_flags.rw_ready) {
823 open_control_socket();
825 if (onstart_flags.log_ready) {
826 setup_external_log();
829 if (force_stop || desired_state == service_state_t::STOPPED) {
835 // Notify any dependents whose desired state is STARTED:
836 for (auto dept : dependents) {
837 dept->get_from()->dependency_started();
838 dept->waiting_on = false;
842 void service_record::failed_to_start(bool depfailed) noexcept
844 if (!depfailed && onstart_flags.starts_on_console) {
845 tcsetpgrp(0, getpgrp());
849 log_service_failed(service_name);
850 service_state = service_state_t::STOPPED;
851 if (start_explicit) {
852 start_explicit = false;
855 notify_listeners(service_event_t::FAILEDSTART);
857 // Cancel start of dependents:
858 for (auto & dept : dependents) {
859 switch (dept->dep_type) {
860 case dependency_type::REGULAR:
861 case dependency_type::MILESTONE:
862 if (dept->get_from()->service_state == service_state_t::STARTING) {
863 dept->get_from()->prop_failure = true;
864 services->add_prop_queue(dept->get_from());
867 case dependency_type::WAITS_FOR:
868 case dependency_type::SOFT:
869 if (dept->waiting_on) {
870 dept->waiting_on = false;
871 dept->get_from()->dependency_started();
873 if (dept->holding_acq) {
874 dept->holding_acq = false;
881 bool service_record::start_ps_process() noexcept
883 // default implementation: there is no process, so we are started.
888 bool base_process_service::start_ps_process() noexcept
892 return restart_ps_process();
897 eventLoop.get_time(restart_interval_time, clock_type::MONOTONIC);
898 restart_interval_count = 0;
899 return start_ps_process(exec_arg_parts, onstart_flags.starts_on_console);
903 bool base_process_service::start_ps_process(const std::vector<const char *> &cmd, bool on_console) noexcept
905 // In general, you can't tell whether fork/exec is successful. We use a pipe to communicate
906 // success/failure from the child to the parent. The pipe is set CLOEXEC so a successful
907 // exec closes the pipe, and the parent sees EOF. If the exec is unsuccessful, the errno
908 // is written to the pipe, and the parent can read it.
910 eventLoop.get_time(last_start_time, clock_type::MONOTONIC);
913 if (pipe2(pipefd, O_CLOEXEC)) {
914 log(loglevel_t::ERROR, service_name, ": can't create status check pipe: ", strerror(errno));
918 const char * logfile = this->logfile.c_str();
920 logfile = "/dev/null";
923 bool child_status_registered = false;
924 control_conn_t *control_conn = nullptr;
926 int control_socket[2] = {-1, -1};
927 if (onstart_flags.pass_cs_fd) {
928 if (dinit_socketpair(AF_UNIX, SOCK_STREAM, /* protocol */ 0, control_socket, SOCK_NONBLOCK)) {
929 log(loglevel_t::ERROR, service_name, ": can't create control socket: ", strerror(errno));
933 // Make the server side socket close-on-exec:
934 int fdflags = fcntl(control_socket[0], F_GETFD);
935 fcntl(control_socket[0], F_SETFD, fdflags | FD_CLOEXEC);
938 control_conn = new control_conn_t(eventLoop, services, control_socket[0]);
940 catch (std::exception &exc) {
941 log(loglevel_t::ERROR, service_name, ": can't launch process; out of memory");
946 // Set up complete, now fork and exec:
951 child_status_listener.add_watch(eventLoop, pipefd[0], IN_EVENTS);
952 child_status_registered = true;
954 // We specify a high priority (i.e. low priority value) so that process termination is
955 // handled early. This means we have always recorded that the process is terminated by the
956 // time that we handle events that might otherwise cause us to signal the process, so we
957 // avoid sending a signal to an invalid (and possibly recycled) process ID.
958 forkpid = child_listener.fork(eventLoop, reserved_child_watch, DEFAULT_PRIORITY - 10);
959 reserved_child_watch = true;
961 catch (std::exception &e) {
962 log(loglevel_t::ERROR, service_name, ": Could not fork: ", e.what());
967 run_child_proc(cmd.data(), logfile, on_console, pipefd[1], control_socket[1]);
971 close(pipefd[1]); // close the 'other end' fd
972 if (control_socket[1] != -1) {
973 close(control_socket[1]);
977 waiting_for_execstat = true;
984 if (child_status_registered) {
985 child_status_listener.deregister(eventLoop);
988 if (onstart_flags.pass_cs_fd) {
992 close(control_socket[0]);
993 close(control_socket[1]);
1003 void service_record::run_child_proc(const char * const *args, const char *logfile, bool on_console,
1004 int wpipefd, int csfd) noexcept
1006 // Child process. Must not allocate memory (or otherwise risk throwing any exception)
1007 // from here until exit().
1009 // If the console already has a session leader, presumably it is us. On the other hand
1010 // if it has no session leader, and we don't create one, then control inputs such as
1011 // ^C will have no effect.
1012 bool do_set_ctty = (tcgetsid(0) == -1);
1014 // Copy signal mask, but unmask signals that we masked on startup. For the moment, we'll
1015 // also block all signals, since apparently dup() can be interrupted (!!! really, POSIX??).
1016 sigset_t sigwait_set;
1017 sigset_t sigall_set;
1018 sigfillset(&sigall_set);
1019 sigprocmask(SIG_SETMASK, &sigall_set, &sigwait_set);
1020 sigdelset(&sigwait_set, SIGCHLD);
1021 sigdelset(&sigwait_set, SIGINT);
1022 sigdelset(&sigwait_set, SIGTERM);
1023 sigdelset(&sigwait_set, SIGQUIT);
1025 constexpr int bufsz = ((CHAR_BIT * sizeof(pid_t)) / 3 + 2) + 11;
1026 // "LISTEN_PID=" - 11 characters; the expression above gives a conservative estimate
1027 // on the maxiumum number of bytes required for LISTEN=nnn, including nul terminator,
1028 // where nnn is a pid_t in decimal (i.e. one decimal digit is worth just over 3 bits).
1031 // "DINIT_CS_FD=" - 12 bytes. (we -1 from sizeof(int) in account of sign bit).
1032 constexpr int csenvbufsz = ((CHAR_BIT * sizeof(int) - 1) / 3 + 2) + 12;
1033 char csenvbuf[csenvbufsz];
1035 int minfd = (socket_fd == -1) ? 3 : 4;
1037 // Move wpipefd/csfd to another fd if necessary
1038 if (wpipefd < minfd) {
1039 wpipefd = fcntl(wpipefd, F_DUPFD_CLOEXEC, minfd);
1040 if (wpipefd == -1) goto failure_out;
1043 if (csfd != -1 && csfd < minfd) {
1044 csfd = fcntl(csfd, F_DUPFD, minfd);
1045 if (csfd == -1) goto failure_out;
1048 if (socket_fd != -1) {
1050 if (dup2(socket_fd, 3) == -1) goto failure_out;
1051 if (socket_fd != 3) {
1055 if (putenv(const_cast<char *>("LISTEN_FDS=1"))) goto failure_out;
1056 snprintf(nbuf, bufsz, "LISTEN_PID=%jd", static_cast<intmax_t>(getpid()));
1057 if (putenv(nbuf)) goto failure_out;
1061 snprintf(csenvbuf, csenvbufsz, "DINIT_CS_FD=%d", csfd);
1062 if (putenv(csenvbuf)) goto failure_out;
1066 // Re-set stdin, stdout, stderr
1067 close(0); close(1); close(2);
1069 if (open("/dev/null", O_RDONLY) == 0) {
1070 // stdin = 0. That's what we should have; proceed with opening
1071 // stdout and stderr.
1072 if (open(logfile, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR) != 1) {
1075 if (dup2(1, 2) != 2) {
1079 else goto failure_out;
1081 // We have the option of creating a session and process group, or just a new process
1082 // group. If we just create a new process group, the child process cannot make itself
1083 // a session leader if it wants to do that (eg getty/login will generally want this).
1084 // If we do neither, and we are running with a controlling terminal, a ^C or similar
1085 // will also affect the child process (which probably isn't so bad, though since we
1086 // will handle the shutdown ourselves it's not necessary). Creating a new session
1087 // (and a new process group as part of that) seems like a safe bet, and has the
1088 // advantage of letting us signal the process as part of a process group.
1092 // "run on console" - run as a foreground job on the terminal/console device
1094 // if do_set_ctty is false, we are the session leader; we are probably running
1095 // as a user process. Don't create a new session leader in that case, and run
1096 // as part of the parent session. Otherwise, the new session cannot claim the
1097 // terminal as a controlling terminal (it is already claimed), meaning that it
1098 // will not see control signals from ^C etc.
1101 // Disable suspend (^Z) (and on some systems, delayed suspend / ^Y)
1102 signal(SIGTSTP, SIG_IGN);
1104 // Become session leader
1106 ioctl(0, TIOCSCTTY, 0);
1109 tcsetpgrp(0, getpgrp());
1112 sigprocmask(SIG_SETMASK, &sigwait_set, nullptr);
1114 execvp(args[0], const_cast<char **>(args));
1116 // If we got here, the exec failed:
1118 int exec_status = errno;
1119 write(wpipefd, &exec_status, sizeof(int));
1123 // Mark this and all dependent services as force-stopped.
1124 void service_record::forced_stop() noexcept
1126 if (service_state != service_state_t::STOPPED) {
1128 services->add_transition_queue(this);
1132 void service_record::dependent_stopped() noexcept
1134 if (service_state == service_state_t::STOPPING && waiting_for_deps) {
1135 services->add_transition_queue(this);
1139 void service_record::stop(bool bring_down) noexcept
1141 if (start_explicit) {
1142 start_explicit = false;
1151 void service_record::do_stop() noexcept
1153 if (pinned_started) return;
1155 if (start_explicit && ! do_auto_restart()) {
1156 start_explicit = false;
1158 if (required_by == 0) return; // release will re-call us anyway
1161 if (service_state != service_state_t::STARTED) {
1162 if (service_state == service_state_t::STARTING) {
1163 if (! can_interrupt_start()) {
1164 // Well this is awkward: we're going to have to continue
1165 // starting, but we don't want any dependents to think that
1166 // they are still waiting to start.
1167 // Make sure they remain stopped:
1172 // We must have had desired_state == STARTED.
1173 notify_listeners(service_event_t::STARTCANCELLED);
1177 // Reaching this point, we are starting interruptibly - so we
1178 // stop now (by falling through to below).
1181 // If we're starting we need to wait for that to complete.
1182 // If we're already stopping/stopped there's nothing to do.
1187 service_state = service_state_t::STOPPING;
1188 waiting_for_deps = true;
1189 if (stop_dependents()) {
1190 services->add_transition_queue(this);
1194 bool service_record::stop_check_dependents() noexcept
1196 bool all_deps_stopped = true;
1197 for (auto dept : dependents) {
1198 if (dept->dep_type == dependency_type::REGULAR && ! dept->get_from()->is_stopped()) {
1199 all_deps_stopped = false;
1204 return all_deps_stopped;
1207 bool service_record::stop_dependents() noexcept
1209 bool all_deps_stopped = true;
1210 for (auto dept : dependents) {
1211 if (dept->dep_type == dependency_type::REGULAR) {
1212 if (! dept->get_from()->is_stopped()) {
1213 // Note we check *first* since if the dependent service is not stopped,
1214 // 1. We will issue a stop to it shortly and
1215 // 2. It will notify us when stopped, at which point the stop_check_dependents()
1216 // check is run anyway.
1217 all_deps_stopped = false;
1221 // If this service is to be forcefully stopped, dependents must also be.
1222 dept->get_from()->forced_stop();
1225 dept->get_from()->prop_stop = true;
1226 services->add_prop_queue(dept->get_from());
1230 return all_deps_stopped;
1233 // All dependents have stopped; we can stop now, too. Only called when STOPPING.
1234 void service_record::all_deps_stopped() noexcept
1236 waiting_for_deps = false;
1240 void base_process_service::kill_pg(int signo) noexcept
1242 pid_t pgid = getpgid(pid);
1244 // only should happen if pid is invalid, which should never happen...
1245 log(loglevel_t::ERROR, service_name, ": can't signal process: ", strerror(errno));
1251 void base_process_service::all_deps_stopped() noexcept
1253 waiting_for_deps = false;
1255 // The process is still kicking on - must actually kill it. We signal the process
1256 // group (-pid) rather than just the process as there's less risk then of creating
1257 // an orphaned process group:
1258 if (! onstart_flags.no_sigterm) {
1261 if (term_signal != -1) {
1262 kill_pg(term_signal);
1265 // In most cases, the rest is done in handle_exit_status.
1266 // If we are a BGPROCESS and the process is not our immediate child, however, that
1267 // won't work - check for this now:
1268 if (record_type == service_type::BGPROCESS && ! tracking_child) {
1271 else if (stop_timeout != time_val(0,0)) {
1272 restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1273 stop_timer_armed = true;
1277 // The process is already dead.
1282 void process_service::all_deps_stopped() noexcept
1284 waiting_for_deps = false;
1285 if (waiting_for_execstat) {
1286 // The process is still starting. This should be uncommon, but can occur during
1287 // smooth recovery. We can't do much now; we have to wait until we get the
1288 // status, and then act appropriately.
1291 else if (pid != -1) {
1292 // The process is still kicking on - must actually kill it. We signal the process
1293 // group (-pid) rather than just the process as there's less risk then of creating
1294 // an orphaned process group:
1295 if (! onstart_flags.no_sigterm) {
1298 if (term_signal != -1) {
1299 kill_pg(term_signal);
1302 // In most cases, the rest is done in handle_exit_status.
1303 // If we are a BGPROCESS and the process is not our immediate child, however, that
1304 // won't work - check for this now:
1305 if (record_type == service_type::BGPROCESS && ! tracking_child) {
1308 else if (stop_timeout != time_val(0,0)) {
1309 restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1310 stop_timer_armed = true;
1314 // The process is already dead.
1319 void scripted_service::all_deps_stopped() noexcept
1321 waiting_for_deps = false;
1322 if (stop_command.length() == 0) {
1325 else if (! start_ps_process(stop_arg_parts, false)) {
1326 // Couldn't execute stop script, but there's not much we can do:
1330 // successfully started stop script: start kill timer:
1331 if (stop_timeout != time_val(0,0)) {
1332 restart_timer.arm_timer_rel(eventLoop, stop_timeout);
1333 stop_timer_armed = true;
1338 void service_record::unpin() noexcept
1340 if (pinned_started) {
1341 pinned_started = false;
1342 if (desired_state == service_state_t::STOPPED || force_stop) {
1344 services->process_queues();
1347 if (pinned_stopped) {
1348 pinned_stopped = false;
1349 if (desired_state == service_state_t::STARTED) {
1351 services->process_queues();
1356 void service_record::queue_for_console() noexcept
1358 services->append_console_queue(this);
1361 void service_record::release_console() noexcept
1363 services->pull_console_queue();
1366 void service_record::interrupt_start() noexcept
1368 services->unqueue_console(this);
1371 void service_set::service_active(service_record *sr) noexcept
1376 void service_set::service_inactive(service_record *sr) noexcept
1381 base_process_service::base_process_service(service_set *sset, string name,
1382 service_type service_type_p, string &&command,
1383 std::list<std::pair<unsigned,unsigned>> &command_offsets,
1384 const std::list<prelim_dep> &deplist_p)
1385 : service_record(sset, name, service_type_p, std::move(command), command_offsets,
1386 deplist_p), child_listener(this), child_status_listener(this)
1388 restart_interval_count = 0;
1389 restart_interval_time = {0, 0};
1390 restart_timer.service = this;
1391 restart_timer.add_timer(eventLoop);
1393 // By default, allow a maximum of 3 restarts within 10.0 seconds:
1394 restart_interval.seconds() = 10;
1395 restart_interval.nseconds() = 0;
1396 max_restart_interval_count = 3;
1398 waiting_restart_timer = false;
1399 reserved_child_watch = false;
1400 tracking_child = false;
1401 stop_timer_armed = false;
1404 void base_process_service::do_restart() noexcept
1406 waiting_restart_timer = false;
1407 restart_interval_count++;
1409 // We may be STARTING (regular restart) or STARTED ("smooth recovery"). This affects whether
1410 // the process should be granted access to the console:
1411 bool on_console = service_state == service_state_t::STARTING
1412 ? onstart_flags.starts_on_console : onstart_flags.runs_on_console;
1414 if (service_state == service_state_t::STARTING) {
1415 // for a smooth recovery, we want to check dependencies are available before actually
1417 if (! check_deps_started()) {
1418 waiting_for_deps = true;
1423 if (! start_ps_process(exec_arg_parts, on_console)) {
1425 if (service_state == service_state_t::STARTING) {
1429 desired_state = service_state_t::STOPPED;
1432 services->process_queues();
1436 bool base_process_service::restart_ps_process() noexcept
1438 using time_val = dasynq::time_val;
1440 time_val current_time;
1441 eventLoop.get_time(current_time, clock_type::MONOTONIC);
1443 if (max_restart_interval_count != 0) {
1444 // Check whether we're still in the most recent restart check interval:
1445 time_val int_diff = current_time - restart_interval_time;
1446 if (int_diff < restart_interval) {
1447 if (restart_interval_count >= max_restart_interval_count) {
1448 log(loglevel_t::ERROR, "Service ", service_name, " restarting too quickly; stopping.");
1453 restart_interval_time = current_time;
1454 restart_interval_count = 0;
1458 // Check if enough time has lapsed since the prevous restart. If not, start a timer:
1459 time_val tdiff = current_time - last_start_time;
1460 if (restart_delay <= tdiff) {
1461 // > restart delay (normally 200ms)
1465 time_val timeout = restart_delay - tdiff;
1466 restart_timer.arm_timer_rel(eventLoop, timeout);
1467 waiting_restart_timer = true;
1472 void base_process_service::interrupt_start() noexcept
1474 // overridden in subclasses
1475 if (waiting_restart_timer) {
1476 restart_timer.stop_timer(eventLoop);
1477 waiting_restart_timer = false;
1479 service_record::interrupt_start();
1482 void base_process_service::kill_with_fire() noexcept
1485 log(loglevel_t::WARN, "Service ", service_name, "with pid ", pid, " exceeded allowed stop time; killing.");
1490 dasynq::rearm process_restart_timer::timer_expiry(eventloop_t &, int expiry_count)
1492 if (service->service_state == service_state_t::STOPPING) {
1493 service->kill_with_fire();
1494 service->stop_timer_armed = false;
1497 // STARTING / STARTED:
1498 service->do_restart();
1500 return dasynq::rearm::DISARM;