src/baseproc-service.cc

   1 #include <cstring>
   2
   3 #include <sys/un.h>
   4 #include <sys/socket.h>
   5 #include <sys/types.h>
   6 #include <sys/stat.h>
   7 #include <unistd.h>
   8
   9 #include "dinit.h"
  10 #include "dinit-log.h"
  11 #include "dinit-socket.h"
  12 #include "proc-service.h"
  13
  14 #include "baseproc-sys.h"
  15
  16 /*
  17  * Base process implementation (base_process_service).
  18  *
  19  * See proc-service.h for interface documentation.
  20  */
  21
  22 void base_process_service::do_smooth_recovery() noexcept
  23 {
  24     if (! restart_ps_process()) {
  25         emergency_stop();
  26         services->process_queues();
  27     }
  28 }
  29
  30 bool base_process_service::bring_up() noexcept
  31 {
  32     if (restarting) {
  33         if (pid == -1) {
  34             return restart_ps_process();
  35         }
  36         return true;
  37     }
  38     else {
  39         if (! open_socket()) {
  40             return false;
  41         }
  42
  43         event_loop.get_time(restart_interval_time, clock_type::MONOTONIC);
  44         restart_interval_count = 0;
  45         if (start_ps_process(exec_arg_parts, onstart_flags.starts_on_console)) {
  46             if (start_timeout != time_val(0,0)) {
  47                 restart_timer.arm_timer_rel(event_loop, start_timeout);
  48                 stop_timer_armed = true;
  49             }
  50             else if (stop_timer_armed) {
  51                 restart_timer.stop_timer(event_loop);
  52                 stop_timer_armed = false;
  53             }
  54             return true;
  55         }
  56         return false;
  57     }
  58 }
  59
  60 bool base_process_service::start_ps_process(const std::vector<const char *> &cmd, bool on_console) noexcept
  61 {
  62     // In general, you can't tell whether fork/exec is successful. We use a pipe to communicate
  63     // success/failure from the child to the parent. The pipe is set CLOEXEC so a successful
  64     // exec closes the pipe, and the parent sees EOF. If the exec is unsuccessful, the errno
  65     // is written to the pipe, and the parent can read it.
  66
  67     event_loop.get_time(last_start_time, clock_type::MONOTONIC);
  68
  69     int pipefd[2];
  70     if (bp_sys::pipe2(pipefd, O_CLOEXEC)) {
  71         log(loglevel_t::ERROR, get_name(), ": can't create status check pipe: ", strerror(errno));
  72         return false;
  73     }
  74
  75     const char * logfile = this->logfile.c_str();
  76     if (*logfile == 0) {
  77         logfile = "/dev/null";
  78     }
  79
  80     bool child_status_registered = false;
  81     control_conn_t *control_conn = nullptr;
  82
  83     int control_socket[2] = {-1, -1};
  84     if (onstart_flags.pass_cs_fd) {
  85         if (dinit_socketpair(AF_UNIX, SOCK_STREAM, /* protocol */ 0, control_socket, SOCK_NONBLOCK)) {
  86             log(loglevel_t::ERROR, get_name(), ": can't create control socket: ", strerror(errno));
  87             goto out_p;
  88         }
  89
  90         // Make the server side socket close-on-exec:
  91         int fdflags = bp_sys::fcntl(control_socket[0], F_GETFD);
  92         bp_sys::fcntl(control_socket[0], F_SETFD, fdflags | FD_CLOEXEC);
  93
  94         try {
  95             control_conn = new control_conn_t(event_loop, services, control_socket[0]);
  96         }
  97         catch (std::exception &exc) {
  98             log(loglevel_t::ERROR, get_name(), ": can't launch process; out of memory");
  99             goto out_cs;
 100         }
 101     }
 102
 103     // Set up complete, now fork and exec:
 104
 105     pid_t forkpid;
 106
 107     try {
 108         child_status_listener.add_watch(event_loop, pipefd[0], dasynq::IN_EVENTS);
 109         child_status_registered = true;
 110
 111         // We specify a high priority (i.e. low priority value) so that process termination is
 112         // handled early. This means we have always recorded that the process is terminated by the
 113         // time that we handle events that might otherwise cause us to signal the process, so we
 114         // avoid sending a signal to an invalid (and possibly recycled) process ID.
 115         forkpid = child_listener.fork(event_loop, reserved_child_watch, dasynq::DEFAULT_PRIORITY - 10);
 116         reserved_child_watch = true;
 117     }
 118     catch (std::exception &e) {
 119         log(loglevel_t::ERROR, get_name(), ": Could not fork: ", e.what());
 120         goto out_cs_h;
 121     }
 122
 123     if (forkpid == 0) {
 124         run_child_proc(cmd.data(), logfile, on_console, pipefd[1], control_socket[1], socket_fd,
 125                 run_as_uid, run_as_gid);
 126     }
 127     else {
 128         // Parent process
 129         bp_sys::close(pipefd[1]); // close the 'other end' fd
 130         if (control_socket[1] != -1) {
 131             bp_sys::close(control_socket[1]);
 132         }
 133         pid = forkpid;
 134
 135         waiting_for_execstat = true;
 136         return true;
 137     }
 138
 139     // Failure exit:
 140
 141     out_cs_h:
 142     if (child_status_registered) {
 143         child_status_listener.deregister(event_loop);
 144     }
 145
 146     if (onstart_flags.pass_cs_fd) {
 147         delete control_conn;
 148
 149         out_cs:
 150         bp_sys::close(control_socket[0]);
 151         bp_sys::close(control_socket[1]);
 152     }
 153
 154     out_p:
 155     bp_sys::close(pipefd[0]);
 156     bp_sys::close(pipefd[1]);
 157
 158     return false;
 159 }
 160
 161 base_process_service::base_process_service(service_set *sset, string name,
 162         service_type_t service_type_p, string &&command,
 163         std::list<std::pair<unsigned,unsigned>> &command_offsets,
 164         const std::list<prelim_dep> &deplist_p)
 165      : service_record(sset, name, service_type_p, deplist_p), child_listener(this),
 166        child_status_listener(this), restart_timer(this)
 167 {
 168     program_name = std::move(command);
 169     exec_arg_parts = separate_args(program_name, command_offsets);
 170
 171     restart_interval_count = 0;
 172     restart_interval_time = {0, 0};
 173     restart_timer.service = this;
 174     restart_timer.add_timer(event_loop);
 175
 176     // By default, allow a maximum of 3 restarts within 10.0 seconds:
 177     restart_interval.seconds() = 10;
 178     restart_interval.nseconds() = 0;
 179     max_restart_interval_count = 3;
 180
 181     waiting_restart_timer = false;
 182     reserved_child_watch = false;
 183     tracking_child = false;
 184     stop_timer_armed = false;
 185     start_is_interruptible = false;
 186 }
 187
 188 void base_process_service::do_restart() noexcept
 189 {
 190     waiting_restart_timer = false;
 191     restart_interval_count++;
 192     auto service_state = get_state();
 193
 194     if (service_state == service_state_t::STARTING) {
 195         // for a smooth recovery, we want to check dependencies are available before actually
 196         // starting:
 197         if (! check_deps_started()) {
 198             waiting_for_deps = true;
 199             return;
 200         }
 201     }
 202
 203     if (! start_ps_process(exec_arg_parts, have_console)) {
 204         restarting = false;
 205         if (service_state == service_state_t::STARTING) {
 206             failed_to_start();
 207         }
 208         else {
 209             // desired_state = service_state_t::STOPPED;
 210             forced_stop();
 211         }
 212         services->process_queues();
 213     }
 214 }
 215
 216 bool base_process_service::restart_ps_process() noexcept
 217 {
 218     using time_val = dasynq::time_val;
 219
 220     time_val current_time;
 221     event_loop.get_time(current_time, clock_type::MONOTONIC);
 222
 223     if (max_restart_interval_count != 0) {
 224         // Check whether we're still in the most recent restart check interval:
 225         time_val int_diff = current_time - restart_interval_time;
 226         if (int_diff < restart_interval) {
 227             if (restart_interval_count >= max_restart_interval_count) {
 228                 log(loglevel_t::ERROR, "Service ", get_name(), " restarting too quickly; stopping.");
 229                 return false;
 230             }
 231         }
 232         else {
 233             restart_interval_time = current_time;
 234             restart_interval_count = 0;
 235         }
 236     }
 237
 238     // Check if enough time has lapsed since the previous restart. If not, start a timer:
 239     time_val tdiff = current_time - last_start_time;
 240     if (restart_delay <= tdiff) {
 241         // > restart delay (normally 200ms)
 242         do_restart();
 243     }
 244     else {
 245         time_val timeout = restart_delay - tdiff;
 246         restart_timer.arm_timer_rel(event_loop, timeout);
 247         waiting_restart_timer = true;
 248     }
 249     return true;
 250 }
 251
 252 bool base_process_service::interrupt_start() noexcept
 253 {
 254     if (waiting_restart_timer) {
 255         restart_timer.stop_timer(event_loop);
 256         waiting_restart_timer = false;
 257         return service_record::interrupt_start();
 258     }
 259     else {
 260         log(loglevel_t::WARN, "Interrupting start of service ", get_name(), " with pid ", pid, " (with SIGINT).");
 261         kill_pg(SIGINT);
 262         if (stop_timeout != time_val(0,0)) {
 263             restart_timer.arm_timer_rel(event_loop, stop_timeout);
 264             stop_timer_armed = true;
 265         }
 266         else if (stop_timer_armed) {
 267             restart_timer.stop_timer(event_loop);
 268             stop_timer_armed = false;
 269         }
 270         set_state(service_state_t::STOPPING);
 271         notify_listeners(service_event_t::STARTCANCELLED);
 272         return false;
 273     }
 274 }
 275
 276 void base_process_service::kill_with_fire() noexcept
 277 {
 278     if (pid != -1) {
 279         log(loglevel_t::WARN, "Service ", get_name(), " with pid ", pid, " exceeded allowed stop time; killing.");
 280         kill_pg(SIGKILL);
 281     }
 282 }
 283
 284 void base_process_service::kill_pg(int signo) noexcept
 285 {
 286     pid_t pgid = bp_sys::getpgid(pid);
 287     if (pgid == -1) {
 288         // only should happen if pid is invalid, which should never happen...
 289         log(loglevel_t::ERROR, get_name(), ": can't signal process: ", strerror(errno));
 290         return;
 291     }
 292     bp_sys::kill(-pgid, signo);
 293 }
 294
 295 void base_process_service::timer_expired() noexcept
 296 {
 297     stop_timer_armed = false;
 298
 299     // Timer expires if:
 300     // We are stopping, including after having startup cancelled (stop timeout, state is STOPPING); We are
 301     // starting (start timeout, state is STARTING); We are waiting for restart timer before restarting,
 302     // including smooth recovery (restart timeout, state is STARTING or STARTED).
 303     if (get_state() == service_state_t::STOPPING) {
 304         kill_with_fire();
 305     }
 306     else if (pid != -1) {
 307         // Starting, start timed out.
 308         stop_dependents();
 309         if (start_explicit) {
 310             start_explicit = false;
 311             release();
 312         }
 313         interrupt_start();
 314     }
 315     else {
 316         // STARTING / STARTED, and we have a pid: must be restarting (smooth recovery if STARTED)
 317         do_restart();
 318     }
 319 }
 320
 321 void base_process_service::emergency_stop() noexcept
 322 {
 323     if (! do_auto_restart() && start_explicit) {
 324         start_explicit = false;
 325         release(false);
 326     }
 327     forced_stop();
 328     stop_dependents();
 329     stopped();
 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 }