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