OpenWrt Boot Process (New OpenWrt)

void procd_signal(void)
{
        signal(SIGPIPE, SIG_IGN);
        if (getpid() != 1)
                return;
        sigaction(SIGTERM, &sa_shutdown, NULL);
        sigaction(SIGINT, &sa_shutdown, NULL);
        sigaction(SIGUSR1, &sa_shutdown, NULL);
        sigaction(SIGUSR2, &sa_shutdown, NULL);
        sigaction(SIGSEGV, &sa_crash, NULL);
        sigaction(SIGBUS, &sa_crash, NULL);
        sigaction(SIGHUP, &sa_dummy, NULL);
        sigaction(SIGKILL, &sa_dummy, NULL);
        sigaction(SIGSTOP, &sa_dummy, NULL);
        reboot(RB_DISABLE_CAD);
}

static void state_enter(void)
{
        char ubus_cmd[] = "/sbin/ubusd";

        switch (state) {
        case STATE_EARLY:
                LOG("- early -\n");
                watchdog_init(0);
                hotplug("/etc/hotplug.json");
                procd_coldplug();
                break;

        case STATE_UBUS:
                // try to reopen incase the wdt was not available before coldplug
                watchdog_init(0);
                set_stdio("console");
                LOG("- ubus -\n");
                procd_connect_ubus();
                service_init();
                service_start_early("ubus", ubus_cmd);
                break;

        case STATE_INIT:
                LOG("- init -\n");
                procd_inittab();
                procd_inittab_run("respawn");
                procd_inittab_run("askconsole");
                procd_inittab_run("askfirst");
                procd_inittab_run("sysinit");

                // switch to syslog log channel
                ulog_open(ULOG_SYSLOG, LOG_DAEMON, "procd");
                break;

        case STATE_RUNNING:
                LOG("- init complete -\n");
                break;

        case STATE_SHUTDOWN:
                /* Redirect output to the console for the users' benefit */
                set_console();
                LOG("- shutdown -\n");
                procd_inittab_run("shutdown");
                sync();
                break;

        case STATE_HALT:
                // To prevent killed processes from interrupting the sleep
                signal(SIGCHLD, SIG_IGN);
                LOG("- SIGTERM processes -\n");
                kill(-1, SIGTERM);
                sync();
                sleep(1);
                LOG("- SIGKILL processes -\n");
                kill(-1, SIGKILL);
                sync();
                sleep(1);
                if (reboot_event == RB_POWER_OFF)
                        LOG("- power down -\n");
                else
                        LOG("- reboot -\n");

                /* Allow time for last message to reach serial console, etc */
                sleep(1);

                /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
                 * in linux/kernel/sys.c, which can cause the machine to panic when
                 * the init process exits... */
                if (!vfork( )) { /* child */
                        reboot(reboot_event);
                        _exit(EXIT_SUCCESS);
                }

                while (1)
                        sleep(1);
                break;

        default:
                ERROR("Unhandled state %d\n", state);
                return;
        };
}

int
main(int argc, char **argv)
{
        pid_t pid;

        ulog_open(ULOG_KMSG, LOG_DAEMON, "init");

        sigaction(SIGTERM, &sa_shutdown, NULL);
        sigaction(SIGUSR1, &sa_shutdown, NULL);
        sigaction(SIGUSR2, &sa_shutdown, NULL);

        early();
        cmdline();
        watchdog_init(1);

        pid = fork();
        if (!pid) {
                char *kmod[] = { "/sbin/kmodloader", "/etc/modules-boot.d/", NULL };

                if (debug < 3) {
                        int fd = open("/dev/null", O_RDWR);

                        if (fd > -1) {
                                dup2(fd, STDIN_FILENO);
                                dup2(fd, STDOUT_FILENO);
                                dup2(fd, STDERR_FILENO);
                                if (fd > STDERR_FILENO)
                                        close(fd);
                        }
                }
                execvp(kmod[0], kmod);
                ERROR("Failed to start kmodloader\n");
                exit(-1);
        }
        if (pid <= 0) {
                ERROR("Failed to start kmodloader instance\n");
        } else {
                int i;

                for (i = 0; i < 120; i++) {
                        if (waitpid(pid, NULL, WNOHANG) > 0)
                                break;
                        sleep(1);
                        watchdog_ping();
                }
        }
        uloop_init();
        preinit();
        uloop_run();

        return 0;
}

static struct init_handler handlers[] = {
        {
                .name = "sysinit",
                .cb = runrc,
        }, {
                .name = "shutdown",
                .cb = runrc,
        }, {
                .name = "askfirst",
                .cb = askfirst,
                .multi = 1,
        }, {
                .name = "askconsole",
                .cb = askconsole,
                .multi = 1,
        }, {
                .name = "respawn",
                .cb = rcrespawn,
                .multi = 1,
        }
};

int rcS(char *pattern, char *param, void (*q_empty)(struct runqueue *))
{
        runqueue_init(&q);
        q.empty_cb = q_empty;
        q.max_running_tasks = 1;

        return _rc(&q, "/etc/rc.d", pattern, "*", param);
}

static int _rc(struct runqueue *q, char *path, const char *file, char *pattern, char *param)
{
        char *dir = alloca(2 + strlen(path) + strlen(file) + strlen(pattern));
        glob_t gl;
        int j;

        if (!dir) {
                ERROR("Out of memory in %s.\n", file);
                return -1;
        }

        DEBUG(2, "running %s/%s%s %s\n", path, file, pattern, param);
        sprintf(dir, "%s/%s%s", path, file, pattern);
        if (glob(dir, GLOB_NOESCAPE | GLOB_MARK, NULL, &gl)) {
                DEBUG(2, "glob failed on %s\n", dir);
                return -1;
        }

        for (j = 0; j < gl.gl_pathc; j++)
                add_initd(q, gl.gl_pathv[j], param);

        globfree(&gl);

        return 0;
}

static void rcdone(struct runqueue *q)
{
        procd_state_next();
}