int main(int argc, char *argv[])
{
puts("Mounting...");
do_mounts();
run_process("/virt/init_stage2");
printf("Init failed: %s\n", strerror(errno));
return 0;
}
int main(int argc, char *argv[])
{
puts("Mounting...");
do_mounts();
puts("Starting '/bin/sh'...");
run_process("/bin/sh");
printf("Init failed: %s\n", strerror(errno));
return 0;
}
int main(int argc, char *argv[])
{
pid_t child;
int status;
puts("Mounting...");
do_mounts();
/* get session leader */
setsid();
/* set controlling terminal */
ioctl(0, TIOCSCTTY, 1);
child = fork();
if (child < 0) {
printf("Fatal: fork() failed with %d\n", child);
return 0;
} else if (child == 0) {
if (access("/virt/sandbox.sh", R_OK) == 0)
run_process_sandbox("/bin/sh");
else
run_process("/bin/sh");
} else {
pid_t corpse;
do {
corpse = waitpid(-1, &status, 0);
} while (corpse != child);
}
reboot(LINUX_REBOOT_CMD_RESTART);
printf("Init failed: %s\n", strerror(errno));
return 0;
}
int
parmount(char **mntlist, int count, char *fstype)
{
int maxfd = OPEN_MAX;
struct rlimit rl;
vfsent_t **vl, *vp;
/*
* Process scaling. After running a series
* of tests based on the number of simultaneous processes and
* processors available, optimum performance was achieved near or
* at (PROCN * 2).
*/
if ((maxrun = sysconf(_SC_NPROCESSORS_ONLN)) == -1)
maxrun = 4;
else
maxrun = maxrun * 2 + 1;
if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &rl) == 0)
maxfd = (int)rl.rlim_cur;
}
(void) enable_extended_FILE_stdio(-1, -1);
/*
* The parent needs to maintain 3 of its own fd's, plus 2 for
* each child (the stdout and stderr pipes).
*/
maxfd = (maxfd / 2) - 6; /* 6 takes care of temporary */
/* periods of open fds */
if (maxfd < maxrun)
maxrun = maxfd;
if (maxrun < 4)
maxrun = 4; /* sanity check */
if (count == 0)
mntlist = NULL; /* used as a flag later */
else
fstype = NULL; /* mount points supplied: */
/* ignore fstype */
/*
* Read the whole vfstab into a linked list for quick processing.
* On average, this is the most efficient way to collect and
* manipulate the vfstab data.
*/
vfsll = getvfsall(fstype, mntlist == NULL);
/*
* Make an array out of the vfs linked list for sorting purposes.
*/
if (vfsll == NULL ||
(vfsarray = make_vfsarray(mntlist, count)) == NULL) {
if (mntlist == NULL) /* not an error - just none found */
return (0);
fprintf(stderr, gettext("%s: No valid entries found in %s\n"),
myname, vfstab);
return (1);
}
/*
* Sort the entries based on their resolved path names
*
* If an lofs is encountered, then the original order of the vfstab
* file needs to be maintained until we are done mounting lofs's.
*/
if (!lofscnt)
qsort((void *)vfsarray, vfsarraysize, sizeof (vfsent_t *),
mlevelcmp);
/*
* Shrink the vfsll linked list down to the new list. This will
* speed up the pid search in cleanupkid() later.
*/
vfsll = vfsarray[0];
for (vl = vfsarray; vp = *vl; )
vp->next = *++vl;
/*
* Try to handle interrupts in a reasonable way.
*/
sigset(SIGHUP, cleanup);
sigset(SIGQUIT, cleanup);
sigset(SIGINT, cleanup);
do_mounts(); /* do the mounts */
if (failcnt > 0 && failcnt == lofsfail)
return (ALL_LOFS_FAILURES);
return (exitcode);
}
int main(int argc, char *argv[])
{
char **cmdv, **args;
char *cmdlines[3];
int i;
const char *errmsg;
int ret = 0;
int cmdc;
int fd;
struct timeval now;
char *mount_argv[] = {"mount_part", "rootfs", "/root"};
pid_t pid;
int nandboot = 0;
gettimeofday(&now, NULL);
srand48(now.tv_usec ^ (now.tv_sec << 24));
/* Default parameters for anything init-like we execute */
init_argc = argc;
init_argv = alloca((argc+1)*sizeof(char *));
memcpy(init_argv, argv, (argc+1)*sizeof(char *));
/*
* omit /dev/console when generating initramfs,
* so we create it dynamically
*/
if (access("/dev/console", O_RDWR)) {
mknod("/dev/console", S_IFCHR|0644, makedev(5, 1));
}
if ((fd = open("/dev/console", O_RDWR)) != -1) {
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
if (fd > STDERR_FILENO) {
close(fd);
}
}
mnt_procfs = mount_sys_fs("/proc/cmdline", "/proc", "proc") >= 0;
if (!mnt_procfs) {
ret = 1;
goto bail;
}
mnt_sysfs = mount_sys_fs("/sys/bus", "/sys", "sysfs") >= 0;
if (!mnt_sysfs) {
ret = 1;
goto bail;
}
/* Construct the effective kernel command line. The
effective kernel command line consists of /arch.cmd, if
it exists, /proc/cmdline, plus any arguments after an --
argument on the proper command line, in that order. */
ret = readfile("/arch.cmd", &cmdlines[0]);
if (ret < 0)
cmdlines[0] = "";
ret = readfile("/proc/cmdline", &cmdlines[1]);
if (ret < 0) {
fprintf(stderr, "%s: cannot read /proc/cmdline\n", progname);
ret = 1;
goto bail;
}
cmdlines[2] = NULL;
/* Find an -- argument, and if so append to the command line */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--")) {
i++;
break;
}
}
args = &argv[i]; /* Points either to first argument past -- or
to the final NULL */
/* Count the number of arguments */
cmdc = split_cmdline(INT_MAX, NULL, argv[0], cmdlines, args);
/* Actually generate the cmdline array */
cmdv = (char **)alloca((cmdc+1)*sizeof(char *));
if (split_cmdline(cmdc, cmdv, argv[0], cmdlines, args) != cmdc) {
ret = 1;
goto bail;
}
/* Debugging... */
dump_args(cmdc, cmdv);
{
const char * root_device_name = get_arg(cmdc, cmdv, "root=");
if (strncmp(root_device_name, "/dev/mtdblock", strlen("/dev/mtdblock")) == 0) {
nandboot = 1;
printf("kinit: NAND mode, check online upgrade flag\n");
do_rootfs_OU();
} else {
nandboot = 0;
printf("kinit: None-NAND mode, ignore online upgrade flag\n");
}
}
/* Resume from suspend-to-disk, if appropriate */
/* If successful, does not return */
do_resume(cmdc, cmdv);
/* Initialize networking, if applicable */
do_ipconfig(cmdc, cmdv);
check_path("/root");
if (nandboot) {
int index = 0;
while (1) {
char name[128];
snprintf(name, sizeof(name), "/sys/block/mtdblock%d", index);
if (access(name, F_OK) == 0) {
snprintf(name, sizeof(name), "/dev/mtdblock%d", index);
create_dev(name, name_to_dev_t(name));
index++;
} else {
break;
}
}
if((pid=fork())<0)
fprintf(stderr, "fork error.\n");
else if(pid == 0)
{
if((ret = execve("/bin/mount_part", mount_argv, NULL)) <0)
perror("excute mount_part error\n");
}
if(waitpid(pid, NULL, 0) < 0)
fprintf(stderr, "wait mount_part error.\n");
} else {
do_mounts(cmdc, cmdv);
}
if (mnt_procfs) {
umount2("/proc", 0);
mnt_procfs = 0;
}
if (mnt_sysfs) {
umount2("/sys", 0);
mnt_sysfs = 0;
}
make_devices();
init_path = find_init("/root", get_arg(cmdc, cmdv, "init="));
if (!init_path) {
fprintf(stderr, "%s: init not found!\n", progname);
ret = 2;
goto bail;
}
DEBUG(("kinit: init_path = %s, init=%s\n", init_path, get_arg(cmdc, cmdv, "init=")));
init_argv[0] = strrchr(init_path, '/') + 1;
errmsg = run_init("/root", "/dev/console", init_path, init_argv);
/* If run_init returned, something went bad */
fprintf(stderr, "%s: %s: %s\n", progname, errmsg, strerror(errno));
ret = 2;
goto bail;
bail:
if (mnt_procfs)
umount2("/proc", 0);
if (mnt_sysfs)
umount2("/sys", 0);
/*
* If we get here, something bad probably happened, and the kernel
* will most likely panic. Drain console output so the user can
* figure out what happened.
*/
tcdrain(2);
tcdrain(1);
return ret;
}
