src/baseproc-service.cc

   1 #include <cstring>
   2 #include <cstdlib>
   3
   4 #include <sys/un.h>
   5 #include <sys/socket.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <unistd.h>
   9
  10 #include "dinit.h"
  11 #include "dinit-log.h"
  12 #include "dinit-socket.h"
  13 #include "proc-service.h"
  14
  15 #include "baseproc-sys.h"
  16
  17 /*
  18  * Base process implementation (base_process_service).
  19  *
  20  * See proc-service.h for interface documentation.
  21  */
  22
  23 void base_process_service::do_smooth_recovery() noexcept
  24 {
  25     if (! restart_ps_process()) {
  26         emergency_stop();
  27         services->process_queues();
  28     }
  29 }
  30
  31 bool base_process_service::bring_up() noexcept
  32 {
  33     if (restarting) {
  34         if (pid == -1) {
  35             return restart_ps_process();
  36         }
  37         return true;
  38     }
  39     else {
  40         if (! open_socket()) {
  41             return false;
  42         }
  43
  44         event_loop.get_time(restart_interval_time, clock_type::MONOTONIC);
  45         restart_interval_count = 0;
  46         if (start_ps_process(exec_arg_parts, onstart_flags.starts_on_console)) {
  47             // Note: we don't set a start timeout for PROCESS services.
  48             if (start_timeout != time_val(0,0) && get_type() != service_type_t::PROCESS) {
  49                 restart_timer.arm_timer_rel(event_loop, start_timeout);
  50                 stop_timer_armed = true;
  51             }
  52             else if (stop_timer_armed) {
  53                 restart_timer.stop_timer(event_loop);
  54                 stop_timer_armed = false;
  55             }
  56             return true;
  57         }
  58         return false;
  59     }
  60 }
  61
  62 bool base_process_service::start_ps_process(const std::vector<const char *> &cmd, bool on_console) noexcept
  63 {
  64     // In general, you can't tell whether fork/exec is successful. We use a pipe to communicate
  65     // success/failure from the child to the parent. The pipe is set CLOEXEC so a successful
  66     // exec closes the pipe, and the parent sees EOF. If the exec is unsuccessful, the errno
  67     // is written to the pipe, and the parent can read it.
  68
  69     event_loop.get_time(last_start_time, clock_type::MONOTONIC);
  70
  71     int pipefd[2];
  72     if (bp_sys::pipe2(pipefd, O_CLOEXEC)) {
  73         log(loglevel_t::ERROR, get_name(), ": can't create status check pipe: ", strerror(errno));
  74         return false;
  75     }
  76
  77     const char * logfile = this->logfile.c_str();
  78     if (*logfile == 0) {
  79         logfile = "/dev/null";
  80     }
  81
  82     bool child_status_registered = false;
  83     control_conn_t *control_conn = nullptr;
  84
  85     int control_socket[2] = {-1, -1};
  86     if (onstart_flags.pass_cs_fd) {
  87         if (dinit_socketpair(AF_UNIX, SOCK_STREAM, /* protocol */ 0, control_socket, SOCK_NONBLOCK)) {
  88             log(loglevel_t::ERROR, get_name(), ": can't create control socket: ", strerror(errno));
  89             goto out_p;
  90         }
  91
  92         // Make the server side socket close-on-exec:
  93         int fdflags = bp_sys::fcntl(control_socket[0], F_GETFD);
  94         bp_sys::fcntl(control_socket[0], F_SETFD, fdflags | FD_CLOEXEC);
  95
  96         try {
  97             control_conn = new control_conn_t(event_loop, services, control_socket[0]);
  98         }
  99         catch (std::exception &exc) {
 100             log(loglevel_t::ERROR, get_name(), ": can't launch process; out of memory");
 101             goto out_cs;
 102         }
 103     }
 104
 105     // Set up complete, now fork and exec:
 106
 107     pid_t forkpid;
 108
 109     try {
 110         child_status_listener.add_watch(event_loop, pipefd[0], dasynq::IN_EVENTS);
 111         child_status_registered = true;
 112
 113         // We specify a high priority (i.e. low priority value) so that process termination is
 114         // handled early. This means we have always recorded that the process is terminated by the
 115         // time that we handle events that might otherwise cause us to signal the process, so we
 116         // avoid sending a signal to an invalid (and possibly recycled) process ID.
 117         forkpid = child_listener.fork(event_loop, reserved_child_watch, dasynq::DEFAULT_PRIORITY - 10);
 118         reserved_child_watch = true;
 119     }
 120     catch (std::exception &e) {
 121         log(loglevel_t::ERROR, get_name(), ": Could not fork: ", e.what());
 122         goto out_cs_h;
 123     }
 124
 125     if (forkpid == 0) {
 126         const char * working_dir_c = nullptr;
 127         if (! working_dir.empty()) working_dir_c = working_dir.c_str();
 128         run_child_proc(cmd.data(), working_dir_c, logfile, on_console, pipefd[1], control_socket[1],
 129                 socket_fd, run_as_uid, run_as_gid);
 130     }
 131     else {
 132         // Parent process
 133         bp_sys::close(pipefd[1]); // close the 'other end' fd
 134         if (control_socket[1] != -1) {
 135             bp_sys::close(control_socket[1]);
 136         }
 137         pid = forkpid;
 138
 139         waiting_for_execstat = true;
 140         return true;
 141     }
 142
 143     // Failure exit:
 144
 145     out_cs_h:
 146     if (child_status_registered) {
 147         child_status_listener.deregister(event_loop);
 148     }
 149
 150     if (onstart_flags.pass_cs_fd) {
 151         delete control_conn;
 152
 153         out_cs:
 154         bp_sys::close(control_socket[0]);
 155         bp_sys::close(control_socket[1]);
 156     }
 157
 158     out_p:
 159     bp_sys::close(pipefd[0]);
 160     bp_sys::close(pipefd[1]);
 161
 162     return false;
 163 }
 164
 165 base_process_service::base_process_service(service_set *sset, string name,
 166         service_type_t service_type_p, string &&command,
 167         std::list<std::pair<unsigned,unsigned>> &command_offsets,
 168         const std::list<prelim_dep> &deplist_p)
 169      : service_record(sset, name, service_type_p, deplist_p), child_listener(this),
 170        child_status_listener(this), restart_timer(this)
 171 {
 172     program_name = std::move(command);
 173     exec_arg_parts = separate_args(program_name, command_offsets);
 174
 175     restart_interval_count = 0;
 176     restart_interval_time = {0, 0};
 177     restart_timer.service = this;
 178     restart_timer.add_timer(event_loop);
 179
 180     // By default, allow a maximum of 3 restarts within 10.0 seconds:
 181     restart_interval.seconds() = 10;
 182     restart_interval.nseconds() = 0;
 183     max_restart_interval_count = 3;
 184
 185     waiting_restart_timer = false;
 186     reserved_child_watch = false;
 187     tracking_child = false;
 188     stop_timer_armed = false;
 189 }
 190
 191 void base_process_service::do_restart() noexcept
 192 {
 193     waiting_restart_timer = false;
 194     restart_interval_count++;
 195     auto service_state = get_state();
 196
 197     if (service_state == service_state_t::STARTING) {
 198         // for a smooth recovery, we want to check dependencies are available before actually
 199         // starting:
 200         if (! check_deps_started()) {
 201             waiting_for_deps = true;
 202             return;
 203         }
 204     }
 205
 206     if (! start_ps_process(exec_arg_parts, have_console)) {
 207         restarting = false;
 208         if (service_state == service_state_t::STARTING) {
 209             failed_to_start();
 210         }
 211         else {
 212             // desired_state = service_state_t::STOPPED;
 213             forced_stop();
 214         }
 215         services->process_queues();
 216     }
 217 }
 218
 219 bool base_process_service::restart_ps_process() noexcept
 220 {
 221     using time_val = dasynq::time_val;
 222
 223     time_val current_time;
 224     event_loop.get_time(current_time, clock_type::MONOTONIC);
 225
 226     if (max_restart_interval_count != 0) {
 227         // Check whether we're still in the most recent restart check interval:
 228         time_val int_diff = current_time - restart_interval_time;
 229         if (int_diff < restart_interval) {
 230             if (restart_interval_count >= max_restart_interval_count) {
 231                 log(loglevel_t::ERROR, "Service ", get_name(), " restarting too quickly; stopping.");
 232                 return false;
 233             }
 234         }
 235         else {
 236             restart_interval_time = current_time;
 237             restart_interval_count = 0;
 238         }
 239     }
 240
 241     // Check if enough time has lapsed since the previous restart. If not, start a timer:
 242     time_val tdiff = current_time - last_start_time;
 243     if (restart_delay <= tdiff) {
 244         // > restart delay (normally 200ms)
 245         do_restart();
 246     }
 247     else {
 248         time_val timeout = restart_delay - tdiff;
 249         restart_timer.arm_timer_rel(event_loop, timeout);
 250         waiting_restart_timer = true;
 251     }
 252     return true;
 253 }
 254
 255 bool base_process_service::interrupt_start() noexcept
 256 {
 257     if (waiting_restart_timer) {
 258         restart_timer.stop_timer(event_loop);
 259         waiting_restart_timer = false;
 260         return service_record::interrupt_start();
 261     }
 262     else {
 263         log(loglevel_t::WARN, "Interrupting start of service ", get_name(), " with pid ", pid, " (with SIGINT).");
 264         kill_pg(SIGINT);
 265
 266         if (stop_timeout != time_val(0,0)) {
 267             restart_timer.arm_timer_rel(event_loop, stop_timeout);
 268             stop_timer_armed = true;
 269         }
 270         else if (stop_timer_armed) {
 271             restart_timer.stop_timer(event_loop);
 272             stop_timer_armed = false;
 273         }
 274
 275         set_state(service_state_t::STOPPING);
 276         return false;
 277     }
 278 }
 279
 280 void base_process_service::kill_with_fire() noexcept
 281 {
 282     if (pid != -1) {
 283         log(loglevel_t::WARN, "Service ", get_name(), " with pid ", pid, " exceeded allowed stop time; killing.");
 284         kill_pg(SIGKILL);
 285     }
 286 }
 287
 288 void base_process_service::kill_pg(int signo) noexcept
 289 {
 290     pid_t pgid = bp_sys::getpgid(pid);
 291     if (pgid == -1) {
 292         // only should happen if pid is invalid, which should never happen...
 293         log(loglevel_t::ERROR, get_name(), ": can't signal process: ", strerror(errno));
 294         return;
 295     }
 296     bp_sys::kill(-pgid, signo);
 297 }
 298
 299 void base_process_service::timer_expired() noexcept
 300 {
 301     stop_timer_armed = false;
 302
 303     // Timer expires if:
 304     // We are stopping, including after having startup cancelled (stop timeout, state is STOPPING); We are
 305     // starting (start timeout, state is STARTING); We are waiting for restart timer before restarting,
 306     // including smooth recovery (restart timeout, state is STARTING or STARTED).
 307     if (get_state() == service_state_t::STOPPING) {
 308         kill_with_fire();
 309     }
 310     else if (pid != -1) {
 311         // Starting, start timed out.
 312         log(loglevel_t::WARN, "Service ", get_name(), " with pid ", pid, " exceeded allowed start time; cancelling.");
 313         interrupt_start();
 314         failed_to_start(false, false);
 315     }
 316     else {
 317         // STARTING / STARTED, and we have a pid: must be restarting (smooth recovery if STARTED)
 318         do_restart();
 319     }
 320 }
 321
 322 void base_process_service::emergency_stop() noexcept
 323 {
 324     if (! do_auto_restart() && start_explicit) {
 325         start_explicit = false;
 326         release(false);
 327     }
 328     forced_stop();
 329     stop_dependents();
 330 }
 331
 332 void base_process_service::becoming_inactive() noexcept
 333 {
 334     if (socket_fd != -1) {
 335         close(socket_fd);
 336         socket_fd = -1;
 337     }
 338 }
 339
 340 bool base_process_service::open_socket() noexcept
 341 {
 342     if (socket_path.empty() || socket_fd != -1) {
 343         // No socket, or already open
 344         return true;
 345     }
 346
 347     const char * saddrname = socket_path.c_str();
 348
 349     // Check the specified socket path
 350     struct stat stat_buf;
 351     if (stat(saddrname, &stat_buf) == 0) {
 352         if ((stat_buf.st_mode & S_IFSOCK) == 0) {
 353             // Not a socket
 354             log(loglevel_t::ERROR, get_name(), ": Activation socket file exists (and is not a socket)");
 355             return false;
 356         }
 357     }
 358     else if (errno != ENOENT) {
 359         // Other error
 360         log(loglevel_t::ERROR, get_name(), ": Error checking activation socket: ", strerror(errno));
 361         return false;
 362     }
 363
 364     // Remove stale socket file (if it exists).
 365     // We won't test the return from unlink - if it fails other than due to ENOENT, we should get an
 366     // error when we try to create the socket anyway.
 367     unlink(saddrname);
 368
 369     uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + socket_path.length() + 1;
 370     struct sockaddr_un * name = static_cast<sockaddr_un *>(malloc(sockaddr_size));
 371     if (name == nullptr) {
 372         log(loglevel_t::ERROR, get_name(), ": Opening activation socket: out of memory");
 373         return false;
 374     }
 375
 376     name->sun_family = AF_UNIX;
 377     strcpy(name->sun_path, saddrname);
 378
 379     int sockfd = dinit_socket(AF_UNIX, SOCK_STREAM, 0, SOCK_NONBLOCK | SOCK_CLOEXEC);
 380     if (sockfd == -1) {
 381         log(loglevel_t::ERROR, get_name(), ": Error creating activation socket: ", strerror(errno));
 382         free(name);
 383         return false;
 384     }
 385
 386     if (bind(sockfd, (struct sockaddr *) name, sockaddr_size) == -1) {
 387         log(loglevel_t::ERROR, get_name(), ": Error binding activation socket: ", strerror(errno));
 388         close(sockfd);
 389         free(name);
 390         return false;
 391     }
 392
 393     free(name);
 394
 395     // POSIX (1003.1, 2013) says that fchown and fchmod don't necessarily work on sockets. We have to
 396     // use chown and chmod instead.
 397     if (chown(saddrname, socket_uid, socket_gid)) {
 398         log(loglevel_t::ERROR, get_name(), ": Error setting activation socket owner/group: ", strerror(errno));
 399         close(sockfd);
 400         return false;
 401     }
 402
 403     if (chmod(saddrname, socket_perms) == -1) {
 404         log(loglevel_t::ERROR, get_name(), ": Error setting activation socket permissions: ", strerror(errno));
 405         close(sockfd);
 406         return false;
 407     }
 408
 409     if (listen(sockfd, 128) == -1) { // 128 "seems reasonable".
 410         log(loglevel_t::ERROR, ": Error listening on activation socket: ", strerror(errno));
 411         close(sockfd);
 412         return false;
 413     }
 414
 415     socket_fd = sockfd;
 416     return true;
 417 }