src/dinit.cc

   1 #include <iostream>
   2 #include <list>
   3 #include <cstring>
   4 #include <csignal>
   5 #include <cstddef>
   6 #include <cstdlib>
   7
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <sys/un.h>
  11 #include <sys/socket.h>
  12 #include <unistd.h>
  13 #include <fcntl.h>
  14 #include <pwd.h>
  15
  16 #include "dasync.h"
  17 #include "service.h"
  18 #include "control.h"
  19 #include "dinit-log.h"
  20
  21 #ifdef __linux__
  22 #include <sys/klog.h>
  23 #include <sys/reboot.h>
  24 #endif
  25
  26 /*
  27  * "simpleinit" from util-linux-ng package handles signals as follows:
  28  * SIGTSTP - spawn no more gettys (in preparation for shutdown etc).
  29  *           In dinit terms this should probably mean "no more auto restarts"
  30  *           (for any service). (Actually the signal acts as a toggle, if
  31  *           respawn is disabled it will be re-enabled and init will
  32  *           act as if SIGHUP had also been sent)
  33  * SIGTERM - kill spawned gettys (which are still alive)
  34  *           Interestingly, simpleinit just sends a SIGTERM to the gettys,
  35  *           which will not normall kill shells (eg bash ignores SIGTERM).
  36  * "/sbin/initctl -r" - rollback services (ran by "shutdown"/halt etc);
  37  *           shouldn't return until all services have been stopped.
  38  *           shutdown calls this after sending SIGTERM to processes running
  39  *           with uid >= 100 ("mortals").
  40  * SIGQUIT - init will exec() shutdown. shutdown will detect that it is
  41  *           running as pid 1 and will just loop and reap child processes.
  42  *           This is used by shutdown so that init will not hang on to its
  43  *           inode, allowing the filesystem to be re-mounted readonly
  44  *           (this is only an issue if the init binary has been unlinked,
  45  *           since it's then holding an inode which can't be maintained
  46  *           when the filesystem is unmounted).
  47  *
  48  * Not sent by shutdown:
  49  * SIGHUP -  re-read inittab and spawn any new getty entries
  50  * SIGINT - (ctrl+alt+del handler) - fork & exec "reboot"
  51  *
  52  * On the contrary dinit currently uses:
  53  * SIGTERM - roll back services and then fork/exec /sbin/halt
  54  * SIGINT - roll back services and then fork/exec /sbin/reboot
  55  * SIGQUIT - exec() /sbin/shutdown as per above.
  56  *
  57  * It's an open question about whether dinit should roll back services *before*
  58  * running halt/reboot, since those commands should prompt rollback of services
  59  * anyway. But it seems safe to do so.
  60  */
  61
  62
  63 using namespace dasync;
  64 using EventLoop_t = EventLoop<NullMutex>;
  65
  66 EventLoop_t eventLoop = EventLoop_t();
  67
  68 // TODO remove:
  69 //static void sigint_reboot_cb(struct ev_loop *loop, ev_signal *w, int revents);
  70 //static void sigquit_cb(struct ev_loop *loop, ev_signal *w, int revents);
  71 //static void sigterm_cb(struct ev_loop *loop, ev_signal *w, int revents);
  72 static void sigint_reboot_cb(EventLoop_t *eloop) noexcept;
  73 static void sigquit_cb(EventLoop_t *eloop) noexcept;
  74 static void sigterm_cb(EventLoop_t *eloop) noexcept;
  75 void open_control_socket(EventLoop_t *loop) noexcept;
  76 void close_control_socket(EventLoop_t *loop) noexcept;
  77
  78 static void control_socket_cb(EventLoop_t *loop, int fd);
  79
  80 class ControlSocketWatcher : public PosixFdWatcher<NullMutex>
  81 {
  82     Rearm gotEvent(EventLoop_t * loop, int fd, int flags)
  83     {
  84         control_socket_cb(loop, fd);
  85         return Rearm::REARM;
  86     }
  87
  88     public:
  89     // TODO the fd is already stored, must we really store it again...
  90     int fd;
  91
  92     void registerWith(EventLoop_t * loop, int fd, int flags)
  93     {
  94         this->fd = fd;
  95         PosixFdWatcher<NullMutex>::registerWith(loop, fd, flags);
  96     }
  97 };
  98
  99 ControlSocketWatcher control_socket_io;
 100
 101
 102 // Variables
 103
 104 static ServiceSet *service_set;
 105
 106 static bool am_system_init = false; // true if we are the system init process
 107
 108 static bool control_socket_open = false;
 109 int active_control_conns = 0;
 110
 111 // Control socket path. We maintain a string (control_socket_str) in case we need
 112 // to allocate storage, but control_socket_path is the authoritative value.
 113 static const char *control_socket_path = "/dev/dinitctl";
 114 static std::string control_socket_str;
 115
 116 static const char *user_home_path = nullptr;
 117
 118
 119 // Get user home (and set user_home_path). (The return may become invalid after
 120 // changing the evironment (HOME variable) or using the getpwuid() function).
 121 const char * get_user_home()
 122 {
 123     if (user_home_path == nullptr) {
 124         user_home_path = getenv("HOME");
 125         if (user_home_path == nullptr) {
 126             struct passwd * pwuid_p = getpwuid(getuid());
 127             if (pwuid_p != nullptr) {
 128                 user_home_path = pwuid_p->pw_dir;
 129             }
 130         }
 131     }
 132     return user_home_path;
 133 }
 134
 135
 136 namespace {
 137     class CallbackSignalHandler : public PosixSignalWatcher<NullMutex>
 138     {
 139         public:
 140         typedef void (*cb_func_t)(EventLoop_t *);
 141
 142         private:
 143         cb_func_t cb_func;
 144
 145         public:
 146         CallbackSignalHandler() : cb_func(nullptr) { }
 147         CallbackSignalHandler(cb_func_t pcb_func) :  cb_func(pcb_func) { }
 148
 149         void setCbFunc(cb_func_t cb_func)
 150         {
 151             this->cb_func = cb_func;
 152         }
 153
 154         Rearm gotSignal(EventLoop_t * eloop, int signo, SigInfo_p siginfo) override
 155         {
 156             service_set->stop_all_services(ShutdownType::REBOOT);
 157             return Rearm::REARM;
 158         }
 159     };
 160
 161     class ControlSocketWatcher : public PosixFdWatcher<NullMutex>
 162     {
 163         Rearm gotEvent(EventLoop_t * loop, int fd, int flags)
 164         {
 165             control_socket_cb(loop, fd);
 166             return Rearm::REARM;
 167         }
 168     };
 169 }
 170
 171 int main(int argc, char **argv)
 172 {
 173     using namespace std;
 174
 175     am_system_init = (getpid() == 1);
 176     const char * service_dir = nullptr;
 177     string service_dir_str; // to hold storage for above if necessary
 178     bool control_socket_path_set = false;
 179
 180     // list of services to start
 181     list<const char *> services_to_start;
 182
 183     // Arguments, if given, specify a list of services to start.
 184     // If we are running as init (PID=1), the kernel gives us any command line
 185     // arguments it was given but didn't recognize, including "single" (usually
 186     // for "boot to single user mode" aka just start the shell). We can treat
 187     // them as service names. In the worst case we can't find any of the named
 188     // services, and so we'll start the "boot" service by default.
 189     if (argc > 1) {
 190       for (int i = 1; i < argc; i++) {
 191         if (argv[i][0] == '-') {
 192             // An option...
 193             if (strcmp(argv[i], "--services-dir") == 0 ||
 194                     strcmp(argv[i], "-d") == 0) {
 195                 if (++i < argc) {
 196                     service_dir = argv[i];
 197                 }
 198                 else {
 199                     cerr << "dinit: '--services-dir' (-d) requires an argument" << endl;
 200                     return 1;
 201                 }
 202             }
 203             else if (strcmp(argv[i], "--system") == 0 ||
 204                     strcmp(argv[i], "-s") == 0) {
 205                 am_system_init = true;
 206             }
 207             else if (strcmp(argv[i], "--socket-path") == 0 ||
 208                     strcmp(argv[i], "-p") == 0) {
 209                 if (++i < argc) {
 210                     control_socket_path = argv[i];
 211                     control_socket_path_set = true;
 212                 }
 213                 else {
 214                     cerr << "dinit: '--socket-path' (-p) requires an argument" << endl;
 215                     return 1;
 216                 }
 217             }
 218             else if (strcmp(argv[i], "--help") == 0) {
 219                 cout << "dinit, an init with dependency management" << endl;
 220                 cout << " --help                       display help" << endl;
 221                 cout << " --services-dir <dir>, -d <dir>" << endl;
 222                 cout << "                              set base directory for service description" << endl;
 223                 cout << "                              files (-d <dir>)" << endl;
 224                 cout << " --system, -s                 run as the system init process" << endl;
 225                 cout << " --socket-path <path>, -p <path>" << endl;
 226                 cout << "                              path to control socket" << endl;
 227                 cout << " <service-name>               start service with name <service-name>" << endl;
 228                 return 0;
 229             }
 230             else {
 231                 // unrecognized
 232                 if (! am_system_init) {
 233                     cerr << "dinit: Unrecognized option: " << argv[i] << endl;
 234                     return 1;
 235                 }
 236             }
 237         }
 238         else {
 239             // LILO puts "auto" on the kernel command line for unattended boots; we'll filter it.
 240             if (! am_system_init || strcmp(argv[i], "auto") != 0) {
 241                 services_to_start.push_back(argv[i]);
 242             }
 243         }
 244       }
 245     }
 246
 247     if (am_system_init) {
 248         // setup STDIN, STDOUT, STDERR so that we can use them
 249         int onefd = open("/dev/console", O_RDONLY, 0);
 250         dup2(onefd, 0);
 251         int twofd = open("/dev/console", O_RDWR, 0);
 252         dup2(twofd, 1);
 253         dup2(twofd, 2);
 254
 255         if (onefd > 2) close(onefd);
 256         if (twofd > 2) close(twofd);
 257     }
 258
 259     /* Set up signal handlers etc */
 260     /* SIG_CHILD is ignored by default: good */
 261     sigset_t sigwait_set;
 262     sigemptyset(&sigwait_set);
 263     sigaddset(&sigwait_set, SIGCHLD);
 264     sigaddset(&sigwait_set, SIGINT);
 265     sigaddset(&sigwait_set, SIGTERM);
 266     sigprocmask(SIG_BLOCK, &sigwait_set, NULL);
 267
 268     // Terminal access control signals - we block these so that dinit can't be
 269     // suspended if it writes to the terminal after some other process has claimed
 270     // ownership of it.
 271     signal(SIGTSTP, SIG_IGN);
 272     signal(SIGTTIN, SIG_IGN);
 273     signal(SIGTTOU, SIG_IGN);
 274
 275     if (! am_system_init && ! control_socket_path_set) {
 276         const char * userhome = get_user_home();
 277         if (userhome != nullptr) {
 278             control_socket_str = userhome;
 279             control_socket_str += "/.dinitctl";
 280             control_socket_path = control_socket_str.c_str();
 281         }
 282     }
 283
 284     /* service directory name */
 285     if (service_dir == nullptr && ! am_system_init) {
 286         const char * userhome = get_user_home();
 287         if (userhome != nullptr) {
 288             service_dir_str = get_user_home();
 289             service_dir_str += "/dinit.d";
 290             service_dir = service_dir_str.c_str();
 291         }
 292     }
 293
 294     if (service_dir == nullptr) {
 295         service_dir = "/etc/dinit.d";
 296     }
 297
 298     if (services_to_start.empty()) {
 299         services_to_start.push_back("boot");
 300     }
 301
 302     // Set up signal handlers
 303     //ev_signal sigint_ev_signal;
 304     CallbackSignalHandler sigint_watcher;
 305     if (am_system_init) {
 306       sigint_watcher.setCbFunc(sigint_reboot_cb);
 307     }
 308     else {
 309       sigint_watcher.setCbFunc(sigterm_cb);
 310     }
 311
 312     CallbackSignalHandler sigquit_watcher;
 313     if (am_system_init) {
 314         // PID 1: SIGQUIT exec's shutdown
 315         sigquit_watcher.setCbFunc(sigquit_cb);
 316     }
 317     else {
 318         // Otherwise: SIGQUIT terminates dinit
 319         sigquit_watcher.setCbFunc(sigterm_cb);
 320     }
 321
 322     auto sigterm_watcher = CallbackSignalHandler(sigterm_cb);
 323
 324     sigint_watcher.registerWatch(&eventLoop, SIGINT);
 325     sigquit_watcher.registerWatch(&eventLoop, SIGQUIT);
 326     sigterm_watcher.registerWatch(&eventLoop, SIGTERM);
 327
 328     // Try to open control socket (may fail due to readonly filesystem)
 329     open_control_socket(&eventLoop);
 330
 331 #ifdef __linux__
 332     if (am_system_init) {
 333         // Disable non-critical kernel output to console
 334         klogctl(6 /* SYSLOG_ACTION_CONSOLE_OFF */, nullptr, 0);
 335         // Make ctrl+alt+del combination send SIGINT to PID 1 (this process)
 336         reboot(RB_DISABLE_CAD);
 337     }
 338 #endif
 339
 340     /* start requested services */
 341     service_set = new ServiceSet(service_dir);
 342
 343     init_log(service_set);
 344
 345     for (list<const char *>::iterator i = services_to_start.begin();
 346             i != services_to_start.end();
 347             ++i) {
 348         try {
 349             service_set->startService(*i);
 350         }
 351         catch (ServiceNotFound &snf) {
 352             log(LogLevel::ERROR, snf.serviceName, ": Could not find service description.");
 353         }
 354         catch (ServiceLoadExc &sle) {
 355             log(LogLevel::ERROR, sle.serviceName, ": ", sle.excDescription);
 356         }
 357         catch (std::bad_alloc &badalloce) {
 358             log(LogLevel::ERROR, "Out of memory when trying to start service: ", *i, ".");
 359         }
 360     }
 361
 362     event_loop:
 363
 364     // Process events until all services have terminated.
 365     while (service_set->count_active_services() != 0) {
 366         eventLoop.run();
 367     }
 368
 369     ShutdownType shutdown_type = service_set->getShutdownType();
 370
 371     if (am_system_init) {
 372         logMsgBegin(LogLevel::INFO, "No more active services.");
 373
 374         if (shutdown_type == ShutdownType::REBOOT) {
 375             logMsgEnd(" Will reboot.");
 376         }
 377         else if (shutdown_type == ShutdownType::HALT) {
 378             logMsgEnd(" Will halt.");
 379         }
 380         else if (shutdown_type == ShutdownType::POWEROFF) {
 381             logMsgEnd(" Will power down.");
 382         }
 383         else {
 384             logMsgEnd(" Re-initiating boot sequence.");
 385         }
 386     }
 387
 388     while (! is_log_flushed()) {
 389         eventLoop.run();
 390     }
 391
 392     close_control_socket(&eventLoop);
 393
 394     if (am_system_init) {
 395         if (shutdown_type == ShutdownType::CONTINUE) {
 396             // It could be that we started in single user mode, and the
 397             // user has now exited the shell. We'll try and re-start the
 398             // boot process...
 399             try {
 400                 service_set->startService("boot");
 401                 goto event_loop; // yes, the "evil" goto
 402             }
 403             catch (...) {
 404                 // Now WTF do we do? try to reboot
 405                 log(LogLevel::ERROR, "Could not start 'boot' service; rebooting.");
 406                 shutdown_type = ShutdownType::REBOOT;
 407             }
 408         }
 409
 410         const char * cmd_arg;
 411         if (shutdown_type == ShutdownType::HALT) {
 412             cmd_arg = "-h";
 413         }
 414         else if (shutdown_type == ShutdownType::REBOOT) {
 415             cmd_arg = "-r";
 416         }
 417         else {
 418             // power off.
 419             cmd_arg = "-p";
 420         }
 421
 422         // Fork and execute dinit-reboot.
 423         execl("/sbin/shutdown", "/sbin/shutdown", "--system", cmd_arg, nullptr);
 424         log(LogLevel::ERROR, "Could not execute /sbin/shutdown: ", strerror(errno));
 425
 426         // PID 1 must not actually exit, although we should never reach this point:
 427         while (true) {
 428             // ev_loop(loop, EVLOOP_ONESHOT);
 429             eventLoop.run();
 430         }
 431     }
 432
 433     return 0;
 434 }
 435
 436 // Callback for control socket
 437 static void control_socket_cb(EventLoop_t *loop, int sockfd)
 438 {
 439     // TODO limit the number of active connections. Keep a tally, and disable the
 440     // control connection listening socket watcher if it gets high, and re-enable
 441     // it once it falls below the maximum.
 442
 443     // Accept a connection
 444     int newfd = accept4(sockfd, nullptr, nullptr, SOCK_NONBLOCK | SOCK_CLOEXEC);
 445
 446     if (newfd != -1) {
 447         try {
 448             new ControlConn(loop, service_set, newfd);  // will delete itself when it's finished
 449         }
 450         catch (std::bad_alloc &bad_alloc_exc) {
 451             log(LogLevel::ERROR, "Accepting control connection: Out of memory");
 452             close(newfd);
 453         }
 454     }
 455 }
 456
 457 void open_control_socket(EventLoop_t *loop) noexcept
 458 {
 459     if (! control_socket_open) {
 460         const char * saddrname = control_socket_path;
 461         uint sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen(saddrname) + 1;
 462
 463         struct sockaddr_un * name = static_cast<sockaddr_un *>(malloc(sockaddr_size));
 464         if (name == nullptr) {
 465             log(LogLevel::ERROR, "Opening control socket: out of memory");
 466             return;
 467         }
 468
 469         if (am_system_init) {
 470             // Unlink any stale control socket file, but only if we are system init, since otherwise
 471             // the 'stale' file may not be stale at all:
 472             unlink(saddrname);
 473         }
 474
 475         name->sun_family = AF_UNIX;
 476         strcpy(name->sun_path, saddrname);
 477
 478         // OpenBSD and Linux both allow combining NONBLOCK/CLOEXEC flags with socket type, however
 479         // it's not actually POSIX. (TODO).
 480         int sockfd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
 481         if (sockfd == -1) {
 482             log(LogLevel::ERROR, "Error creating control socket: ", strerror(errno));
 483             free(name);
 484             return;
 485         }
 486
 487         if (bind(sockfd, (struct sockaddr *) name, sockaddr_size) == -1) {
 488             log(LogLevel::ERROR, "Error binding control socket: ", strerror(errno));
 489             close(sockfd);
 490             free(name);
 491             return;
 492         }
 493
 494         free(name);
 495
 496         // No connections can be made until we listen, so it is fine to change the permissions now
 497         // (and anyway there is no way to atomically create the socket and set permissions):
 498         if (chmod(saddrname, S_IRUSR | S_IWUSR) == -1) {
 499             log(LogLevel::ERROR, "Error setting control socket permissions: ", strerror(errno));
 500             close(sockfd);
 501             return;
 502         }
 503
 504         if (listen(sockfd, 10) == -1) {
 505             log(LogLevel::ERROR, "Error listening on control socket: ", strerror(errno));
 506             close(sockfd);
 507             return;
 508         }
 509
 510         control_socket_open = true;
 511         //ev_io_init(&control_socket_io, control_socket_cb, sockfd, EV_READ);
 512         //ev_io_start(loop, &control_socket_io);
 513         control_socket_io.registerWith(&eventLoop, sockfd, in_events);
 514     }
 515 }
 516
 517 void close_control_socket(EventLoop_t *loop) noexcept
 518 {
 519     if (control_socket_open) {
 520         int fd = control_socket_io.fd;
 521         //ev_io_stop(loop, &control_socket_io);
 522         control_socket_io.deregisterWatch(&eventLoop);
 523         close(fd);
 524
 525         // Unlink the socket:
 526         unlink(control_socket_path);
 527     }
 528 }
 529
 530 /* handle SIGINT signal (generated by kernel when ctrl+alt+del pressed) */
 531 static void sigint_reboot_cb(EventLoop_t *eloop) noexcept
 532 {
 533     service_set->stop_all_services(ShutdownType::REBOOT);
 534 }
 535
 536 /* handle SIGQUIT (if we are system init) */
 537 static void sigquit_cb(EventLoop_t *eloop) noexcept
 538 {
 539     // This allows remounting the filesystem read-only if the dinit binary has been
 540     // unlinked. In that case the kernel holds the binary open, so that it can't be
 541     // properly removed.
 542     close_control_socket(eloop);
 543     execl("/sbin/shutdown", "/sbin/shutdown", (char *) 0);
 544     log(LogLevel::ERROR, "Error executing /sbin/shutdown: ", strerror(errno));
 545 }
 546
 547 /* handle SIGTERM/SIGQUIT - stop all services (not used for system daemon) */
 548 static void sigterm_cb(EventLoop_t *eloop) noexcept
 549 {
 550     service_set->stop_all_services();
 551 }