139 lines
3.8 KiB
C
139 lines
3.8 KiB
C
/**
|
|
* @brief init - First process.
|
|
*
|
|
* `init` calls startup scripts and then waits for them to complete.
|
|
* It also waits for orphaned proceses so they can be collected.
|
|
*
|
|
* `init` itself is statically-linked, so minimizing libc dependencies
|
|
* is worthwhile as it reduces to the total size of init itself, which
|
|
* remains in memory throughout the entire lifetime of the OS.
|
|
*
|
|
* Startup scripts for init are stored in /etc/startup.d and are run
|
|
* in sorted alphabetical order. It is generally recommended that these
|
|
* startup scripts be named with numbers at the front to ensure easy
|
|
* ordering. This system of running a set of scripts on startup is
|
|
* somewhat similar to how sysvinit worked, but no claims of
|
|
* compatibility are made.
|
|
*
|
|
* Startup scripts can be any executable binary. Shell scripts are
|
|
* generally used to allow easy editing, but you could also use
|
|
* a binary (even a dynamically linked one) as a startup script.
|
|
* `init` will wait for each startup script (that is, it will wait for
|
|
* the original process it started to exit) before running the next one.
|
|
* So if you wish to run daemons, be sure to fork them off and then
|
|
* exit so that the rest of the startup process can continue.
|
|
*
|
|
* When the last startup script finishes, `init` will reboot the system.
|
|
*
|
|
* @copyright
|
|
* This file is part of ToaruOS and is released under the terms
|
|
* of the NCSA / University of Illinois License - see LICENSE.md
|
|
* Copyright (C) 2018 K. Lange
|
|
*/
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <syscall.h>
|
|
#include <unistd.h>
|
|
#include <wait.h>
|
|
#include <sys/wait.h>
|
|
|
|
#define INITD_PATH "/etc/startup.d"
|
|
|
|
/* Initialize fd 0, 1, 2 */
|
|
void set_console(void) {
|
|
syscall_open("/dev/null", 0, 0);
|
|
syscall_open("/dev/null", 1, 0);
|
|
syscall_open("/dev/null", 1, 0);
|
|
}
|
|
|
|
/* Run a startup script and wait for it to finish */
|
|
int start_options(char * args[]) {
|
|
|
|
/* Fork child to run script */
|
|
int cpid = syscall_fork();
|
|
|
|
/* Child process... */
|
|
if (!cpid) {
|
|
/* Pass environment from init to child */
|
|
syscall_execve(args[0], args, environ);
|
|
/* exec failed, exit this subprocess */
|
|
syscall_exit(0);
|
|
}
|
|
|
|
/* Wait for the child process to finish */
|
|
int pid = 0;
|
|
do {
|
|
/*
|
|
* Wait, ignoring kernel threads
|
|
* (which also end up as children to init)
|
|
*/
|
|
pid = waitpid(-1, NULL, WNOKERN);
|
|
|
|
if (pid == -1 && errno == ECHILD) {
|
|
/* There are no more children */
|
|
break;
|
|
}
|
|
|
|
if (pid == cpid) {
|
|
/* The child process finished */
|
|
break;
|
|
}
|
|
|
|
/* Continue while no error (or error was "interrupted") */
|
|
} while ((pid > 0) || (pid == -1 && errno == EINTR));
|
|
|
|
return cpid;
|
|
}
|
|
|
|
int main(int argc, char * argv[]) {
|
|
/* Initialize stdin/out/err */
|
|
set_console();
|
|
|
|
/* Get directory listing for /etc/startup.d */
|
|
int initd_dir = syscall_open(INITD_PATH, 0, 0);
|
|
if (initd_dir < 0) {
|
|
/* No init scripts; try to start getty as a fallback */
|
|
start_options((char *[]){"/bin/getty",NULL});
|
|
} else {
|
|
int count = 0, i = 0, ret = 0;
|
|
|
|
/* Figure out how many entries we have with a dry run */
|
|
do {
|
|
struct dirent ent;
|
|
ret = syscall_readdir(initd_dir, ++count, &ent);
|
|
} while (ret > 0);
|
|
|
|
/* Read each directory entry */
|
|
struct dirent entries[count];
|
|
do {
|
|
syscall_readdir(initd_dir, i, &entries[i]);
|
|
i++;
|
|
} while (i < count);
|
|
|
|
/* Sort the directory entries */
|
|
int comparator(const void * c1, const void * c2) {
|
|
const struct dirent * d1 = c1;
|
|
const struct dirent * d2 = c2;
|
|
return strcmp(d1->d_name, d2->d_name);
|
|
}
|
|
qsort(entries, count, sizeof(struct dirent), comparator);
|
|
|
|
/* Run scripts */
|
|
for (int i = 0; i < count; ++i) {
|
|
if (entries[i].d_name[0] != '.') {
|
|
char path[256];
|
|
sprintf(path, "/etc/startup.d/%s", entries[i].d_name);
|
|
start_options((char *[]){path, NULL});
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Self-explanatory */
|
|
syscall_reboot();
|
|
return 0;
|
|
}
|