initrd/bin/run-init源代码来源与klibc-2.0.4/usr/kinit目录

run-init源代码

下载

klibc，一种C标准库，开发者为汉·彼得·艾文（Hans Peter Anvin）。它是自由软件，采用GNU 通用公共许可协议或BSD许可协议。它主要应用于Linux开机流程中，而且它也是早期用户空间（Early user space）与initramfs的一部份。在此时，这些应用程序无法使用glibc。它也适用于嵌入式系统的开发。

#include <stdlib.h>

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "run-init.h"

static const char *program;

static void __attribute__ ((noreturn)) usage(void)
{
    fprintf(stderr,
        "Usage: exec %s [-d caps] [-c consoledev] /real-root /sbin/init [args]\n",
        program);
    exit(1);
}

int main(int argc, char *argv[])
{
    /* Command-line options and defaults */
    const char *console = "/dev/console";
    const char *realroot;
    const char *init;
    const char *error;
    const char *drop_caps = NULL;
    char **initargs;

    /* Variables... */
    int o;

    /* Parse the command line */
    program = argv[0];

    while ((o = getopt(argc, argv, "c:d:")) != -1) {
        if (o == 'c') {
            console = optarg;
        } else if (o == 'd') {
            drop_caps = optarg;
        } else {
            usage();
        }
    }

    if (argc - optind < 2)
        usage();

    realroot = argv[optind];
    init = argv[optind + 1];
    initargs = argv + optind + 1;

    error = run_init(realroot, console, drop_caps, init, initargs);

    /* If run_init returns, something went wrong */
    fprintf(stderr, "%s: %s: %s\n", program, error, strerror(errno));
    return 1;

}

runinitlib.c文件清单

/*
 * run_init(realroot, consoledev, drop_caps, init, initargs)
 *
 * This function should be called as the last thing in kinit,
 * from initramfs, it does the following:
 *
 * - Delete all files in the initramfs;
 * - Remounts /real-root onto the root filesystem;
 * - Chroots;
 * - Drops comma-separated list of capabilities;
 * - Opens /dev/console;
 * - Spawns the specified init program (with arguments.)
 *
 * On failure, returns a human-readable error message.
 */

#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/vfs.h>
#include "run-init.h"
#include "capabilities.h"

/* Make it possible to compile on glibc by including constants that the
   always-behind shipped glibc headers may not include.  Classic example
   on why the lack of ABI headers screw us up. */
#ifndef TMPFS_MAGIC
# define TMPFS_MAGIC    0x01021994
#endif
#ifndef RAMFS_MAGIC
# define RAMFS_MAGIC    0x858458f6
#endif
#ifndef MS_MOVE
# define MS_MOVE    8192
#endif

static int nuke(const char *what);

static int nuke_dirent(int len, const char *dir, const char *name, dev_t me)
{
    int bytes = len + strlen(name) + 2;
    char path[bytes];
    int xlen;
    struct stat st;

    xlen = snprintf(path, bytes, "%s/%s", dir, name);
    assert(xlen < bytes);

    if (lstat(path, &st))
        return ENOENT;    /* Return 0 since already gone? */

    if (st.st_dev != me)
        return 0;    /* DO NOT recurse down mount points!!!!! */

    return nuke(path);
}

/* Wipe the contents of a directory, but not the directory itself */
static int nuke_dir(const char *what)
{
    int len = strlen(what);
    DIR *dir;
    struct dirent *d;
    int err = 0;
    struct stat st;

    if (lstat(what, &st))
        return errno;

    if (!S_ISDIR(st.st_mode))
        return ENOTDIR;

    if (!(dir = opendir(what))) {
        /* EACCES means we can't read it.  Might be empty and removable;
           if not, the rmdir() in nuke() will trigger an error. */
        return (errno == EACCES) ? 0 : errno;
    }

    while ((d = readdir(dir))) {
        /* Skip . and .. */
        if (d->d_name[0] == '.' &&
            (d->d_name[1] == '\0' ||
             (d->d_name[1] == '.' && d->d_name[2] == '\0')))
            continue;

        err = nuke_dirent(len, what, d->d_name, st.st_dev);
        if (err) {
            closedir(dir);
            return err;
        }
    }

    closedir(dir);

    return 0;
}

static int nuke(const char *what)
{
    int rv;
    int err = 0;

    rv = unlink(what);
    if (rv < 0) {
        if (errno == EISDIR) {
            /* It's a directory. */
            err = nuke_dir(what);
            if (!err)
                err = rmdir(what) ? errno : err;
        } else {
            err = errno;
        }
    }

    if (err) {
        errno = err;
        return err;
    } else {
        return 0;
    }
}

const char *run_init(const char *realroot, const char *console,
             const char *drop_caps, const char *init,
             char **initargs)
{
    struct stat rst, cst;
    struct statfs sfs;
    int confd;

    /* First, change to the new root directory */
    if (chdir(realroot))
        return "chdir to new root";

    /* This is a potentially highly destructive program.  Take some
       extra precautions. */

    /* Make sure the current directory is not on the same filesystem
       as the root directory */
    if (stat("/", &rst) || stat(".", &cst))
        return "stat";

    if (rst.st_dev == cst.st_dev)
        return "current directory on the same filesystem as the root";

    /* Make sure we're on a ramfs */
    if (statfs("/", &sfs))
        return "statfs /";
    if (sfs.f_type != RAMFS_MAGIC && sfs.f_type != TMPFS_MAGIC)
        return "rootfs not a ramfs or tmpfs";

    /* Okay, I think we should be safe... */

    /* Delete rootfs contents */
    if (nuke_dir("/"))
        return "nuking initramfs contents";

    /* Overmount the root */
    if (mount(".", "/", NULL, MS_MOVE, NULL))
        return "overmounting root";

    /* chroot, chdir */
    if (chroot(".") || chdir("/"))
        return "chroot";

    /* Drop capabilities */
    if (drop_capabilities(drop_caps) < 0)
        return "dropping capabilities";

    /* Open /dev/console */
    if ((confd = open(console, O_RDWR)) < 0)
        return "opening console";
    dup2(confd, 0);
    dup2(confd, 1);
    dup2(confd, 2);
    close(confd);

    /* Spawn init */
    execv(init, initargs);
    return init;        /* Failed to spawn init */
}